Rosetta Stone Codeチャレンジは、できるだけ多くの言語でタスクを完了する必要があるチャレンジです。

チャレンジ

入力としてリストに2つの数値nとsが表示されます。nあなたがカウントアップしなければならない数になります。nは2〜10000の任意の数です。sは、までカウントするときにスキップする数ですn。s1〜n/ 2（の半分n）になります。nが600の場合、s300を超えることはできません。nスキップするまでのすべての数値sを1から開始して出力する必要があります。各出力番号は、改行、スペースで区切られた同じ行、またはリストのいずれかにある必要があります。

ツイスト

このRosetta Stone Codeチャレンジでは、プログラムを作成する各スニペットは同じ長さである必要があります。つまり、Pythonプログラムが56文字の場合、Javaプログラムも56文字にする必要があります。スペースとコメントは文字としてカウントされません。変数/関数名は10文字を超えることはできません。これはコードゴルフでもあるので、コードは短くしてください。

例

入力

[100, 7]

出力

1
8
15
22
29
36
43
50
57
64
71
78
85
92
99

注：出力は、スペースまたはリスト形式で区切られた単一行である可能性があります

受賞基準

勝者は次の式で決定されます。

numberOfLanguages/codeSize

codeSize 合計コードサイズではなく、スニペットの平均コードサイズです。

最も高いスコアを持つユーザーが勝ちます。つまり、4つの言語と31バイトのサイズの回答は、7つの言語と80バイトのサイズの回答よりも優先されます。勝者は2015年3月9日のUTC 2:00に選ばれます。

スコアボード

^{すべてのスコアは千分の1に四捨五入されます}

マルティセン -14言語/ 24文字= 0.583 ---- 勝者

mbomb007-15言語/ 29文字= 0.517

ジャクベ -5言語/ 11文字= 0.455

Teun Pronk -4言語/ 51文字= 0.078

captncraig -1言語/ 56文字= 0.018

14言語-24バイト= 0.58333333333

** Facepalm **。Pythonの回答のスペースを数えるのを忘れました。だから私は今24バイトです。

このチャレンジから多くの新しい言語を学びました。おそらくゴルフで使用するでしょう。これらの言語を見つけるのに本当に役立つサイトはhttp://www.tutorialspoint.com/codingground.htmでした。私のプログラムがその中で実行されることを期待しないでください。それは完全なプログラム形式を必要とし、私はそれを使用して言語について学び、他のREPLを使用してそれらを実行しました。

1. Pyth：

Pythonとは異なり、Pythにはステップバイレンジ関数がないため、通常の範囲を使用し、それにチョップ（@Jakubeに感謝）したmod演算子を使用しました。

M%Hr+Z+Z+Z+Z+Z+Z+Z+Z1+1G

関数g（until、step）を定義します

M          Define g(G, H)
 %H        Every H elements
  r1+1G      Range 1->G+1

2. Golfscript：

これは私の最初のゴルフスクリプトプログラムです。おそらくそれを行うための最良の方法ではありません。

000000000000000;\),1>\%p

\         swap
 )        increment
  ,       range
   1>     all but first element
   \      swap
    %     take every top of stack elements
     p    print array

3. Bash Utils：

INCREMENTパラメータを持つseqコマンドを使用します。

seq 00000000000000001 $2 $1

4,5。Python、Sage：

自明のコード。

lambda a,b:range(1,a+1,b)

セージは、数学に使用されるPythonベースの言語です。

6. Mathematica：

繰り返しになりますが、一目瞭然です。

r[a_,b_]:=Range[001,a,b]

7. Matlab：

Matlabの範囲表記を使用し、無名関数を定義します。

@(a,b)00000000000001:b:a

8. Livescript：

Coffeescriptのように、それはJS派生物です。クールな範囲の構文があります。再び矢印表記。

r=((((a,b)->[1 to a by b])))

9. Erlang：

これだけのためにアーランを学びました。かなり自明で、関数rを定義します。

r(a,b)->lists:seq(1,a,b)

10. F＃：

F＃の関数定義は変数のようなものです。

let r a b=seq{000001..b..a}

11. Haskell：

Haskellの範囲表記では、明示的な増分ではなく、増分の範囲の最初の2つを指定します。

r a b=[00000000001,a+1..b]

12. R：

関数定義が少し冗長であっても、非常にクールな言語。

function(a,b)seq(01,a,b)

13.ジュリア：

素晴らしい言語、将来のゴルフに使用されます。

r(a,b)=[00000000001:b:a]

14. CJam：

入力の解析とパディングを除いて、私の古いGolfscript回答と同じです。

0000000000000;q~\),1>\%p

23言語、15文字= 1.5333333

+---------------+----------------------+----------------+
|    Language   |         Code         |      Kind      |
+---------------+----------------------+----------------+
|          gs2  |  B/4[RRRRRRRRRRR     |  (stack)       |
|         Pyth  |  M%+Z+Z+Z+Z+ZHSG     |  (definition)  |
|   GolfScript  |  \),000000001>%p     |  (stack)       |
|         CJam  |  \),000000001>%p     |  (stack)       |
|          zsh  |  seq 00000001 $2 $1  |  (script)      |
|         Bash  |  seq 00000001 $2 $1  |  (script)      |
|   FlogScript  |  \),0000001>\%Pa     |  (stack)       |
|          APL  |  {00001+⍵×⍳⌈⍺÷⍵}     |  (lambda)      |
|      Mathics  |  00001~Range~##&     |  (lambda)      |
|  Mathematica  |  00001~Range~##&     |  (lambda)      |
|            J  |  ({.\00001+i.)~-     |  (lambda)      |
|       Matlab  |  @(a,b)00001:b:a     |  (lambda)      |
|       Octave  |  @(a,b)00001:b:a     |  (lambda)      |
|    Burlesque  |  jrojcoq-]m[m]uN     |  (stack)       |
|            K  |  {0001+&~(!x)!y}     |  (lambda)      |
|          Pip  |  {_%b=001FI,++a}     |  (lambda)      |
|      Haskell  |  ff a b=[1,b+1..a]   |  (definition)  |
|        Clean  |  ff a b=[1,b+1..a]   |  (definition)  |
|        Curry  |  ff a b=[1,b+1..a]   |  (definition)  |
|        Frege  |  ff a b=[1,b+1..a]   |  (definition)  |
|        Julia  |  ff(a,b)=[1:b:a]     |  (definition)  |
|       Scotch  |  f(a,b)=[1..a,b]     |  (definition)  |
|        Perl6  |  {1,$^b+1...$^a}     |  (lambda)      |
+---------------+----------------------+----------------+

5言語11文字= 0.4545

この課題を、いくつかの新しい言語（CJam、Burlesque、zsh、gs2）をチェックする機会として取り入れました。初めてこれらの言語で作業しました。

出力を作成する方法は、ほとんどの言語で異なります。CJamとgs2メソッドのみが同じです。4つの方法は、範囲[1、100]を作成し、それをモジュロ（CJamおよびgs2）でスライスすること、範囲[1、...、100]を作成し、1 mod 7（Pyth）である要素をフィルターにかけること、範囲[1、...、100]は、それをlen 7のチャンクに分割し、各チャンクの最初の要素（バーレスク）を使用して、シーケンスを直接作成します（zsh）。

言語に慣れていない人にとってはゴルフのように見えるように、各プログラムを設計しようとしました。

編集1：バーレスクを追加、10文字の前の2言語= 0.2

編集2：gs2を追加、11文字の前の3言語= 0.2727

編集3：zshを追加、11文字の以前の4言語= 0.3636

CJam

q~\1+,0-\%p

入力を使用してオンラインでテストします100 7。

q~           push the evaluated input (100 7)
  \          swap (7 100)
   1         push 1 (7 100 1)
    +        add last to elements (7 101)
     ,        create the range (7, [0, 1, ..., 100])
      0       push 0 (7, [0, 1, ..., 100], 0)
       -      delete 0 from the range (7, [1, 2, ..., 100])
        \     swap ([1, 2, ..., 100], 7)
         %    use every 7th entry ([1, 8, ..., 99])
          p   print pretty

バーレスク

jrojcoq-]m[

zshに加えて、これは唯一のゴルフプログラムです。バーレスクは非常に素晴らしいです、それはのような非常に広い範囲の異なる機能を持っていroます。悲しいことに、Pythonの[::a]スライスオペレーターのようなものはありません。

オンライン通訳はありませんが、バーレスクはこちらから入手できます。Burlesqueは関数またはIOをサポートしていないため、次のように、最初に値をスタックに配置する必要があります100 7 jrojcoq-]m[

j            Swap (7 100)
 ro          Range (7 {1 2 ...  100})
   j         Swap ({1 2 ... 100} 7)
    co       ChunksOf ({{1 2 ..  7} {8 ... 14} ... {99 100}})
      q      Create Block ({{1 2 ..  7} {8 ... 14} ... {99 100}} {}) 
       -]    head (first element) ({{1 2 ..  7} {8 ... 14} ... {99 100}} {-]}) 
         m[  map the chunks to the head-block

gs2

read-nums dup head inc range tail swap reverse head mod unlines

うん、これはたったの11文字です。gs2では、各バイトの意味が異なります。しかし、バイトで書き込むのはかなり難しく、面白くないので、ニーモニックで書くこともできます。ニーモニックは、実際のgs2コードにコンパイルできます。実行されるgs2コードは

W@!'."B !4+

または16進ダンプとして：

57 40 21 27 2e 22 42 20 21 34 2b

面白い事実：私はニーモニックではなく、直接16進ダンプの数を書きました。

コンパイラをダウンロードしてテストできます。でニーモニックファイルをコンパイルするpython gs2c.py < mnemonics.txt > compiledかW@!'."B !4+、という名前のファイルにコピーして、でcompiled実行しecho 100 7 | python gs2.py compiledます。

ニーモニックはかなり自明ですが、スタックで何が行われているのかを次に示します。

57 40 21 27 2e 22 42 20 21 34 2b 
57                                 read-nums ([100 7])
   40                              dup ([100 7] [100 7])
      21                           head ([100 7] 100)
         27                        inc ([100 7] 101)
            2e                     range ([100 7] [0 1 ... 100])
               22                  tail ([100 7] [1 2 ... 100])
                  42               swap ([1 2 ... 100] [100 7])
                     20            reverse ([1 2 ... 100] [7 100])
                        21         head ([1 2 ... 100] 7)
                           34      mod ([1 8 ... 99])
                              2b   unlines ('1\n8\n...\n99')
                                   everything on the stack gets printed

ところで、8バイトが可能です。

編集：私はgs2をフォークし、コマンドを少し操作してプルリクエストを作成しましたが、これはすでにマージされています。したがって、タスクは6バイトで実行できます。はread-nums extract-array swap range1 mod unlines、に変換され57 0e 42 2f 34 2b、最適なpythよりもさらに優れています。

zsh

f() seq 1 $2 $1

これは、fシーケンスを作成する関数を定義します。Windowsで使用するために、これらのコマンドを入力するだけのbabunシェルをインストールしました。f() seq 1 $2 $1次の行にと書いてくださいf 100 7。

最初にこれをBashで記述しようとしましたが()、コードブロックの周りにのように記述する必要がありますf() ( seq 1 $2 $1 )。そこで、代わりにzshに切り替えました。

パイス

fq1%TeQUhhQ

もちろん私は明らかな7バイトのゴルフを見ているので、これは本当に痛いです。入力を使用してオンラインでテストできます100, 7。

                 Q = input()
       UhhQ      the range [0, 1, ..., Q[0]]
f                filtered (only use those elements T, which satisfy the equation
 q1%TeQ             1 == T % Q[1]

15言語、29文字=（15/29）≈0.517

これまでにすべてのコードを修正しました。今、私は他の言語を探しています。

1. Python（24ゴルフ）

f=lambda n,s:range(0001,n+1,s)

2.> <>（魚） -（19 +ジャンク文字）

このプログラムは、数とステップサイズが事前にスタックにあり、その順序でプッシュされていることを前提としています。ao番号間の改行を印刷するために使用します。

1           v
$:@+:{:}(?!;>:nao
~~~~~~~~~~

説明（コード、前のコードが実行された後のスタック、コメント）：

1               1 s n           start n0=1. stack is (top)1 s n(bottom)
(skip to print code - last line of explanation, then come back)
 $:@            s 1 s n         swap, duplicate, rotate top 3 (this all is OVER in Forth)
   +:           n1 n1 s n       add step to x and dup
    {:}         n n1 n1 s n     compare to n
       (        n1>n n1 s n     if !(n1 > n), JUMP: dup and print (continue)
        ?!;     n1 s n          else exit
          :nao  n1 s n          dup, print n1, newline, loop around

3. APL（ゴルフ19）

fffffffff←{(⌈⍵÷⍺)↑1+⍺∘.×(⍳⍵)}

ゴルフ。ここに貼り付け：http : //ngn.github.io/apl/web/

f←{(⌈⍵÷⍺)↑1+⍺∘.×⍳⍵}

次のように呼び出します7 f 100。これにより、1からnまでの配列が作成され、すべての要素にsが乗算され、各要素に1が追加され、最初のceil（n / s）要素が取得されます。

4-7。Haskell、Clean、Curry、Frege（14ゴルフ-スペースはカウントされません）

このプログラムは、Haskell、Clean、Curry、Fregeで有効です。

ffffffffff nnnn s=[1,s+1..nnnn]

ゴルフ。ここで実行：https : //ideone.com/Ii0pgP

f n s=[1,s+1..n]

8. スコッチ（15ゴルフ）

fffffffff(nnnn,s)=[1..nnnn,s]

9. Jaskell（24ゴルフ）-ドキュメントに基づいて作成。

剰余sが1であるリストをフィルタリングします。

ffffff n s=filter(.%s==1)[1..n]

10. CoffeeScript（25ゴルフ）ここで実行

fffff=(n,s)->x for x in[1..n]by s

11. R（25ゴルフ）ここで実行：http ://www.r-fiddle.org/#/fiddle?id=k3vRnCOW&version =2

fffff=function(n,s)seq(1,n,s)

12.コブラ（26ゴルフ）

def ffff(n,s)
    for i in 1:n:s
        print i

13. S-Lang（ゴルフ28）

define ff(n,s){return [1:n:s];}

14.ブー（29）

範囲関数が3つのパラメーターを取ることができるかどうかわからない...

def f(n,s):return range(n)[::s]

15. Funge-98（29、ゴルフの助けはありますか？）

> <>プログラムにできるだけ近づきました。「回転」スタック命令がないため、代わりに「put」と「get」を使用する必要がありました。Befungeは実際にいくつかのスタック回転/シフト命令、あるいは「over」命令さえ必要とします。

22p1v
    >:.a,\:33p\33g+:22g\`!j@

説明：

        n s
22p     s           (store n at 2,2)
1       1 s         (push 1)
(v and > are direction changes, so the above only happens once)
\:      s s 1       (swap, dup)
33p     s 1         (store s at 3,3)
\33g    s 1 s       (get s)
+:      n1 n1 s     (add, dup)
22g     n n1 n1 s   (get n)
\`!     !(n1>n) n1 s    (swap, >, not)
j@      n1 s        (conditional exit)
:.a,    n1 s        (print n1, newline)

瞬間に使用しない、長すぎる -これらを含めないことでスコアが向上します。

Ruby（35）ここで実行：http : //ideone.com/yFZELR

def f(n,s)
    (1..n).select{|x|x%s==1}
end

PowerShell（38）

function f($n,$s){(1..$n|?{$_%$s-eq 1})}

Perl（39）ここで実行：https : //ideone.com/HGoleN

sub f{join(" ",grep $_%@_[1]==1, 1..@_[0])}

4言語51文字=（4/51）= 0,0784313725490196

カンマの後の数字の数がわからないので、このままにしておきます。
すべての空白を削除すると、すべてのスニペットは51文字になります。
より多くのより短いコードに取り組んでいますが、それは始まりです。

ログ

最初の回答は
Python（3.4）、Lua（5.1）、Javascriptを提出しました。
スコア：3/51 = 0,0588235294117647

アップデート1
Ruby
スコアを追加：4/51 = 0,0784313725490196。

Python 3.4

def f(NUMB,ST):
    CNT=1
    while CNT<=NUMB:
        print(CNT)
        CNT+=ST

Lua 5.1

function f(num,st)
    for cn=1,num,st do
        print(cn);
    end;
end;

Javascript

function f(n,s){
  for(i=1;i<=n;i+=s){
    console.log(i);
  }
}

ルビー

def faa(numb,st) 
  for i in 1..numb 
    if i%st==1 
      puts i 
    end 
  end 
end

1言語-56文字= 0.01785714285

ピエット（2x28）-