Rosetta Stone Code Tantangan adalah tantangan di mana Anda harus menyelesaikan tugas dalam bahasa sebanyak mungkin.

Tantangan

Anda akan diberikan dua angka, ndan s, dalam daftar sebagai input. The nakan menjadi nomor Anda harus menghitung sampai. nakan berupa angka dari 2 hingga 10.000. sakan menjadi angka yang Anda lewati saat menghitung hingga n. sakan dari 1 hingga n/ 2 (setengah dari n). Jika n600, stidak bisa lebih besar 300. Anda harus menampilkan semua angka hingga nmelewati dengan smulai dengan 1. Setiap nomor output harus berada pada baris baru, pada baris yang sama dipisahkan oleh spasi, atau dalam daftar.

Twist

Untuk Tantangan Kode Batu Rosetta ini, setiap cuplikan tempat Anda menulis program harus memiliki panjang yang sama. yaitu: Jika program Python Anda memiliki 56 karakter, maka program Java Anda juga harus 56 karakter. Spasi dan komentar tidak dihitung sebagai karakter. Nama variabel / fungsi tidak boleh lebih dari 10 karakter. Ingat, ini juga kode golf, jadi usahakan agar kode Anda singkat.

Contoh

Memasukkan

[100, 7]

Keluaran

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

Catatan: Output bisa dalam satu baris dipisahkan oleh spasi atau format daftar

Kriteria Kemenangan

Pemenang akan ditentukan oleh rumus ini:

numberOfLanguages/codeSize

codeSize bukan ukuran kode total tetapi ukuran kode rata-rata cuplikan.

Pengguna dengan skor tertinggi akan menang. yaitu: Jawaban dengan 4 bahasa dan ukuran 31 byte akan memenangkan jawaban dengan 7 bahasa dan ukuran 80 byte. Pemenang akan dipilih pada pukul 2:00 UTC pada tanggal 9 Maret 2015.

Papan angka

^{Semua skor dibulatkan ke seperseribu terdekat}

Maltysen - 14 bahasa / 24 karakter = 0,583 ---- Pemenang

mbomb007 - 15 bahasa / 29 karakter = 0,517

Jakube - 5 bahasa / 11 karakter = 0,455

Teun Pronk - 4 bahasa / 51 karakter = 0,078

captncraig - 1 bahasa / 56 karakter = 0,018

14 Bahasa - 24 byte = 0,58333333333

**Telapak tangan**. Saya lupa untuk tidak menghitung spasi dalam jawaban Python saya. Jadi saya 24 byte sekarang.

Belajar tentang banyak bahasa baru dari tantangan ini, yang mungkin akan saya gunakan dalam golf. Situs yang sangat membantu saya menemukan bahasa-bahasa ini adalah http://www.tutorialspoint.com/codingground.htm . Hanya saja, jangan berharap program saya berjalan di dalamnya, itu membutuhkan format program lengkap, dan saya hanya menggunakannya untuk belajar tentang bahasa dan menggunakan REPL lain untuk menjalankannya.

1. Pyth :

Pyth tidak memiliki fungsi rentang demi langkah seperti python, jadi saya menggunakan rentang reguler dan memotong (terima kasih @Jakube) menggunakan operator mod di atasnya.

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

Menentukan fungsi g (hingga, langkah)

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

2. Naskah Golf:

Ini adalah program skrip golf pertama saya. Mungkin bukan cara terbaik untuk melakukannya.

000000000000000;\),1>\%p

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

3. Bash Utils:

Menggunakan perintah seq yang memiliki param INCREMENT.

seq 00000000000000001 $2 $1

4,5. Python, Sage :

Kode penjelasan sendiri.

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

Sage adalah bahasa berdasarkan Python yang digunakan untuk hal-hal matematika.

6. Mathematica:

Sekali lagi, cukup jelas.

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

7. Matlab:

Menggunakan notasi rentang Matlab dan mendefinisikan fungsi anonim.

@(a,b)00000000000001:b:a

8. Livescript:

Seperti Coffeescript, ini adalah turunan JS. Memiliki sintaks rentang keren. Notasi panah lagi.

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

9. Erlang:

Belajar erlang hanya untuk ini. Cukup jelas, mendefinisikan fungsi r.

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

10. F #:

Agak jelas, definisi fungsi F # seperti variabel.

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

11. Haskell:

Notasi rentang Haskell telah Anda berikan dua yang pertama dalam rentang untuk kenaikan, dan bukan kenaikan eksplisit.

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

12. R:

Bahasa yang sangat keren, meskipun definisi fungsi sedikit bertele-tele.

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

13. Julia:

Mengagumkan bahasa, akan menggunakan untuk bermain golf di masa depan.

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

14. CJam:

Seperti jawaban skrip golf lama saya kecuali dengan input parsing dan padding.

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

23 bahasa, 15 karakter = 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 bahasa 11 karakter = 0,4545

Mengambil tantangan ini sebagai kesempatan untuk memeriksa beberapa bahasa baru (CJam, Burlesque, zsh, gs2). Pertama kali saya bekerja dengan bahasa-bahasa ini.

Metode di balik pembuatan output berbeda di hampir setiap bahasa. Hanya metode CJam dan gs2 yang identik. Keempat metode tersebut adalah, membuat rentang [1, 100] dan mengirisnya dengan modulo (CJam dan gs2), membuat kisaran [1, ..., 100] dan memfilter untuk elemen yang 1 mod 7 (Pyth), membuat kisaran [1, ..., 100], membaginya menjadi potongan len 7 dan menggunakan elemen pertama dari setiap potongan (Burlesque), dan membuat urutan langsung (zsh).

Saya mencoba merancang setiap program sedemikian rupa, sehingga terlihat golf untuk seseorang, yang tidak terbiasa dengan bahasa.

sunting 1: ditambahkan Burlesque, 2 bahasa sebelumnya dengan 10 karakter = 0,2

sunting 2: tambah gs2, 3 bahasa sebelumnya dengan 11 karakter = 0,2727

sunting 3: tambah zsh, 4 bahasa sebelumnya dengan 11 karakter = 0,3636

CJam

q~\1+,0-\%p

Uji secara online dengan input 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

Bahan tertawaan

jrojcoq-]m[

Selain zsh, ini adalah satu-satunya program golf. Burlesque cukup mengagumkan, ia memiliki berbagai fungsi yang sangat besar, seperti ro. Sayangnya tidak ada yang seperti [::a]operator pengiris Python .

Tidak ada penerjemah online, tetapi Anda bisa mendapatkan Burlesque di sini . Karena Burlesque tidak mendukung fungsi atau IO, Anda harus meletakkan nilai ke tumpukan terlebih dahulu100 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

Yap, ini hanya 11 karakter. Dalam gs2 setiap byte memiliki arti yang berbeda. Tetapi karena menulis dalam byte cukup sulit dan tidak menyenangkan, Anda juga dapat menulis dalam mnemonik, yang dapat Anda kompilasi dengan kode gs2 yang sebenarnya. Kode gs2, yang dieksekusi adalah

W@!'."B !4+

atau sebagai hex-dump:

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

Fakta menyenangkan: Saya tidak menulis dalam mnemonik, tetapi secara langsung angka-angka dari hex-dump.

Anda dapat mengujinya dengan mengunduh kompiler . Kompilasi file mnemonics dengan python gs2c.py < mnemonics.txt > compiledatau cukup salin W@!'."B !4+ke file yang bernama compiledlalu jalankan dengan echo 100 7 | python gs2.py compiled.

Mnemonik cukup bisa dijelaskan sendiri, tapi inilah yang terjadi di stack.

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

Btw, 8 byte mungkin, bahkan mungkin lebih sedikit.

sunting: Saya bercabang gs2, sedikit memanipulasi perintah dan membuat permintaan tarikan, yang sudah digabung. Jadi sekarang tugas dapat dilakukan dengan 6 byte :, read-nums extract-array swap range1 mod unlinesyang diterjemahkan menjadi 57 0e 42 2f 34 2b, yang bahkan lebih baik daripada pyth optimal.

zsh

f() seq 1 $2 $1

Ini mendefinisikan fungsi f, yang menciptakan urutan. Untuk menggunakannya di Windows, saya menginstal babun shell, di mana Anda cukup mengetik perintah ini. Cukup tulis f() seq 1 $2 $1dan di baris berikutnya f 100 7.

Pertama saya mencoba menulis ini di Bash, tetapi di sana Anda harus menulis di ()sekitar blok kode, seperti f() ( seq 1 $2 $1 ). Jadi saya beralih ke zsh.

Pyth

fq1%TeQUhhQ

Ini sangat menyakitkan, karena tentu saja saya melihat golf 7 byte yang jelas. Anda dapat mengujinya secara online dengan input 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 bahasa, 29 karakter = (15/29) ≈ 0,517

Saya telah memperbaiki semua kode saya sejauh ini. Sekarang saya sedang mencari bahasa lain.

1. Python (24 golf)

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

2.> <> (Ikan) - (19+ junk chars)

Program ini mengasumsikan bahwa jumlah dan ukuran langkah ada di tumpukan sebelumnya, didorong dalam urutan itu. Menggunakan aountuk mencetak baris baru di antara angka-angka.

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

Penjelasan (kode, susun setelah kode sebelumnya dijalankan, komentar):

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 golf)

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

Golf . Rekatkan ke sini: http://ngn.github.io/apl/web/

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

Sebut seperti ini: 7 f 100. Ini menciptakan array dari 1 ke n, mengalikan setiap elemen dengan s, menambahkan satu ke setiap elemen, lalu mengambil elemen ceil pertama (n / s).

4-7. Haskell , Clean , Curry , Frege (14 golf - spasi tidak dihitung)

Program ini berlaku di Haskell, Clean, Curry, dan Frege.

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

Golf. Jalankan di sini: https://ideone.com/Ii0pgP

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

8. Scotch (15 golf)

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

9. Jaskell (24 golf ) - Dibangun berdasarkan dokumentasi.

Memfilter daftar tempat modul lainnya adalah 1.

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

10. CoffeeScript (25 golf ) Jalankan di sini

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

11. R (25 golf) Jalankan di sini: http://www.r-fiddle.org/#/fiddle?id=k3vRnCOW&version=2

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

12. Cobra (26 golf)

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

13. S-Lang (28 bermain golf)

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

14. Boo (29)

Tidak yakin apakah fungsi rentang dapat mengambil 3 parameter ...

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

15. Funge-98 (29, ada yang bisa membantu bermain golf?)

Sedekat saya bisa ke program> <> saya. Karena tidak ada instruksi stack "rotate", saya harus menggunakan "put" dan "get". Befunge benar-benar membutuhkan beberapa instruksi rotasi / shift tumpukan, atau bahkan instruksi "over".

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

Penjelasan:

        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)

TIDAK MENGGUNAKAN SAAT INI, JUGA LAMA - Skor saya ditingkatkan dengan tidak memasukkan ini.

Ruby (35) Jalankan di sini: 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) Jalankan di sini: https://ideone.com/HGoleN

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

4 bahasa 51 karakter = (4/51) = 0,0784313725490196

Tidak tahu berapa banyak angka setelah koma yang Anda inginkan jadi saya akan membiarkannya seperti ini.
Semua cuplikan berukuran 51 karakter saat Anda menghapus semua spasi putih.
Bekerja pada kode yang lebih banyak dan lebih pendek tetapi ini adalah awal.

Catatan

Jawaban awal
Diserahkan Python (3.4), Lua (5.1) dan Javascript.
Nilai: 3/51 = 0,0588235294117647

Perbarui 1
Ditambahkan
Skor 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);
  }
}

Rubi

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

1 bahasa - 56 karakter = 0,01785714285

piet (2x28) -