Rosetta Stone Code Challenges là những thử thách mà bạn phải hoàn thành nhiệm vụ bằng càng nhiều ngôn ngữ càng tốt.

Các thách thức

Bạn sẽ được cung cấp hai số nvà strong danh sách là đầu vào. Đây nsẽ là một số bạn phải đếm đến. nsẽ là bất kỳ số nào từ 2 đến 10000. ssẽ là số bạn bỏ qua khi đếm đến n.ssẽ từ 1 đến n2 (một nửa n). Nếu nlà 600, skhông thể lớn hơn 300. Bạn phải xuất tất cả các số lên đến nbỏ qua bằng cách sbắt đầu bằng 1. Mỗi số đầu ra phải ở trên một dòng mới, trên cùng một dòng được phân tách bằng dấu cách hoặc trong danh sách.

Vắt

Đối với Thử thách Mã Rosetta Stone này, mỗi đoạn bạn viết chương trình phải có cùng độ dài. tức là: Nếu chương trình Python của bạn có 56 ký tự thì chương trình Java của bạn cũng phải là 56 ký tự. Không gian và nhận xét không được tính là ký tự. Tên biến / hàm không được nhiều hơn 10 ký tự. Hãy nhớ rằng, đây cũng là mã golf, vì vậy hãy cố gắng giữ mã của bạn ngắn.

Thí dụ

Đầu vào

[100, 7]

Đầu ra

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

Lưu ý: Đầu ra có thể ở một dòng được phân tách bằng dấu cách hoặc định dạng danh sách

Tiêu chí chiến thắng

Người chiến thắng sẽ được quyết định bởi công thức này:

numberOfLanguages/codeSize

codeSize không phải là tổng kích thước mã mà là kích thước mã trung bình của một đoạn.

Người dùng có số điểm cao nhất sẽ giành chiến thắng. tức là: Một câu trả lời có 4 ngôn ngữ và kích thước 31 byte sẽ giành được câu trả lời với 7 ngôn ngữ và kích thước 80 byte. Một người chiến thắng sẽ được chọn vào lúc 2:00 UTC vào ngày 9 tháng 3 năm 2015.

Bảng điểm

^{Tất cả các điểm được làm tròn đến một phần nghìn gần nhất}

Maltysen - 14 ngôn ngữ / 24 ký tự = 0,583 ---- Người chiến thắng

mbomb007 - 15 ngôn ngữ / 29 ký tự = 0,517

Jakube - 5 ngôn ngữ / 11 ký tự = 0,455

Teun Pronk - 4 ngôn ngữ / 51 ký tự = 0,078

captncraig - 1 ngôn ngữ / 56 ký tự = 0,008

14 ngôn ngữ - 24 byte = 0,58333333333

** Facepalm **. Tôi quên không đếm khoảng trống trong câu trả lời Python của tôi. Vì vậy, bây giờ tôi đang ở mức 24 byte.

Đã học về rất nhiều ngôn ngữ mới từ thử thách này, mà tôi có thể sẽ sử dụng trong golf. Một trang web thực sự giúp tôi tìm thấy những ngôn ngữ này là http://www.tutorialspoint.com/codingground.htmlm . Chỉ không mong đợi các chương trình của tôi chạy trong đó, nó yêu cầu định dạng chương trình đầy đủ và tôi chỉ sử dụng nó để tìm hiểu về các ngôn ngữ và sử dụng các REPL khác để chạy chúng.

1. Kim tự tháp :

Pyth không có chức năng theo từng bước không giống như python, vì vậy tôi đã sử dụng phạm vi thông thường và cắt nhỏ (cảm ơn @Jakube) sử dụng toán tử mod trên nó.

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

Xác định hàm g (cho đến khi, bước)

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

2. Bản đồ chơi gôn:

Đây là chương trình golf đầu tiên của tôi. Có lẽ không phải là cách tốt nhất để làm điều đó.

000000000000000;\),1>\%p

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

3. Sử dụng Bash:

Sử dụng lệnh seq có tham số TĂNG.

seq 00000000000000001 $2 $1

4,5. Con trăn, cây xô thơm :

Mã tự giải thích.

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

Sage là một ngôn ngữ dựa trên Python được sử dụng cho các công cụ toán học.

6. Toán học:

Một lần nữa, tự giải thích.

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

7. Matlab:

Sử dụng ký hiệu phạm vi của Matlab và định nghĩa một hàm ẩn danh.

@(a,b)00000000000001:b:a

8. Bản ghi:

Giống như Coffeescript, nó là một dẫn xuất JS. Có cú pháp phạm vi mát mẻ. Ký hiệu mũi tên một lần nữa.

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

9. Erlang:

Đã học erlang chỉ cho việc này. Khá tự giải thích, định nghĩa hàm r.

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

10. F #:

Rõ ràng, định nghĩa hàm của F # giống như các biến.

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

11. Haskell:

Ký hiệu phạm vi của Haskell có bạn đưa ra hai mức đầu tiên trong phạm vi cho mức tăng và không phải là mức tăng rõ ràng.

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

12. R:

Ngôn ngữ rất tuyệt, ngay cả khi định nghĩa hàm là một chút dài dòng.

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

13. Julia:

Ngôn ngữ tuyệt vời , sẽ được sử dụng để chơi golf trong tương lai.

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

14. CJam:

Giống như câu trả lời golf cũ của tôi ngoại trừ phân tích cú pháp đầu vào và phần đệm.

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

23 ngôn ngữ, 15 ký tự = 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 ngôn ngữ 11 ký tự = 0,4545

Đã thực hiện thử thách này như một cơ hội để kiểm tra một số ngôn ngữ mới (CJam, Burlesque, zsh, gs2). Lần đầu tiên tôi làm việc với những ngôn ngữ này.

Phương pháp đằng sau việc tạo đầu ra là khác nhau trong gần như mỗi ngôn ngữ. Chỉ có phương pháp CJam và gs2 là giống hệt nhau. Cả 4 phương thức là tạo một phạm vi [1, 100] và cắt nó bằng modulo (CJam và gs2), tạo phạm vi [1, ..., 100] và lọc cho các phần tử là 1 mod 7 (Pyth), tạo phạm vi [1, ..., 100], chia nó thành các khối của len 7 và sử dụng phần tử đầu tiên của mỗi đoạn (Burlesque) và tạo chuỗi trực tiếp (zsh).

Tôi đã cố gắng thiết kế mỗi chương trình theo cách như vậy, rằng nó trông giống như một người nào đó không quen thuộc với ngôn ngữ này.

chỉnh sửa 1: thêm Burlesque, 2 ngôn ngữ trước đó với 10 ký tự = 0,2

chỉnh sửa 2: thêm gs2, 3 ngôn ngữ trước đó với 11 ký tự = 0,2727

chỉnh sửa 3: thêm zsh, 4 ngôn ngữ trước đó với 11 ký tự = 0,3636

Camam

q~\1+,0-\%p

Kiểm tra nó trực tuyến với đầu vào 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

Burlesque

jrojcoq-]m[

Bên cạnh zsh, đây là chương trình golf duy nhất. Burlesque là khá tuyệt vời, nó có một loạt các chức năng khác nhau, như thế nào ro. Đáng buồn thay, không có gì giống như [::a]toán tử cắt Python .

Không có thông dịch viên trực tuyến, nhưng bạn có thể nhận Burlesque ở đây . Vì Burlesque không hỗ trợ các hàm hoặc IO, bạn phải đặt các giá trị lên ngăn xếp trước, như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

Đúng, đây chỉ là 11 ký tự. Trong gs2 mỗi byte có một ý nghĩa khác nhau. Nhưng vì viết bằng byte khá khó và không có gì thú vị, bạn cũng có thể viết bằng ghi nhớ, bạn có thể biên dịch thành mã gs2 thực tế. Mã gs2, được thực thi là

W@!'."B !4+

hoặc dưới dạng hex-dump:

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

Sự thật thú vị: Tôi đã không viết bằng những thứ ghi nhớ, nhưng trực tiếp là số của kết xuất hex.

Bạn có thể kiểm tra nó bằng cách tải xuống trình biên dịch . Biên dịch tệp ghi nhớ bằng python gs2c.py < mnemonics.txt > compiledhoặc đơn giản là sao chép W@!'."B !4+vào một tệp có tên compiledvà sau đó thực hiện nó vớiecho 100 7 | python gs2.py compiled .

Việc ghi nhớ khá tự giải thích, nhưng đây là những gì đang diễn ra trong ngăn xếp.

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 là có thể, thậm chí có thể ít hơn.

chỉnh sửa: Tôi đã rẽ nhánh gs2, thao tác một lệnh và thực hiện một yêu cầu kéo, đã được hợp nhất. Vì vậy, bây giờ là nhiệm vụ có thể được thực hiện với 6 byte: read-nums extract-array swap range1 mod unlines, mà dịch để 57 0e 42 2f 34 2b, mà thậm chí còn tốt hơn so với pyth tối ưu.

zsh

f() seq 1 $2 $1

Điều này xác định một chức năng f, tạo ra một chuỗi. Để sử dụng nó trên Windows, tôi đã cài đặt shell babun , nơi bạn có thể chỉ cần gõ các lệnh này. Đơn giản chỉ cần viết f() seq 1 $2 $1và trong dòng tiếp theo f 100 7.

Đầu tiên tôi đã cố gắng viết điều này bằng Bash, nhưng ở đó bạn phải viết ()xung quanh khối mã, như thế f() ( seq 1 $2 $1 ). Vì vậy, tôi chuyển sang zsh thay thế.

Bình

fq1%TeQUhhQ

Điều này thực sự đau đớn, vì tất nhiên tôi thấy golf 7 byte rõ ràng. Bạn có thể kiểm tra nó trực tuyến với đầu vào 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 ngôn ngữ, 29 ký tự = (15/29) 0,517

Tôi đã sửa tất cả mã của tôi cho đến nay. Bây giờ tôi đang tìm kiếm các ngôn ngữ khác.

1. Python (24 đánh gôn)

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

2.> <> (Cá) - (19 + ký tự rác)

Chương trình này giả định rằng số lượng và kích thước bước đã ở trên ngăn xếp trước, được đẩy theo thứ tự đó. Sử dụng aođể in dòng mới giữa các số.

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

Giải thích (mã, ngăn xếp sau khi mã trước thực thi, nhận xét):

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 đánh gôn)

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

Chơi gôn . Dán vào đây: http://ngn.github.io/apl/web/

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

Gọi như thế này : 7 f 100. Điều này tạo ra một mảng từ 1 đến n, nhân mọi phần tử với s, thêm một phần tử cho mỗi phần tử, sau đó lấy phần tử trần (n / s) đầu tiên.

4-7. Haskell , Clean , Curry , Frege (14 sân golf - không gian không được tính)

Chương trình này có giá trị trong Haskell, Clean, Curry và Frege.

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

Chơi gôn. Chạy ở đây: https://ideone.com/Ii0pgP

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

8. Scotch (15 đánh gôn)

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

9. Jaskell (24 golfed) - Được xây dựng dựa trên tài liệu.

Lọc danh sách trong đó modulo còn lại là 1.

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

10. CoffeeScript (25 đánh gôn) Chạy ở đây

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

11. R (25 đánh gôn) Chạy tại đây: http://www.r-fiddle.org/#/fiddle?id=k3vRnCOW&version=2

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

12. Rắn hổ mang (26 đánh gôn)

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

13. S-Lang (28 đánh gôn)

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

14. Boo (29)

Không chắc chắn nếu chức năng phạm vi có thể mất 3 tham số ...

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

15. Funge-98 (29, có giúp chơi gôn không?)

Gần nhất có thể đến chương trình> <> của tôi. Vì không có hướng dẫn ngăn xếp "xoay", tôi phải sử dụng "đặt" và "lấy" thay thế. Befunge thực sự cần một số hướng dẫn xoay / dịch chuyển ngăn xếp, hoặc thậm chí là một lệnh "qua".

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

Giải trình:

        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)

KHÔNG SỬ DỤNG TẠI MOM, QUÁ DÀI - Điểm của tôi được cải thiện bằng cách không bao gồm những điều này.

Ruby (35) Chạy tại đây: 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) Chạy tại đây: https://ideone.com/HGoleN

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

4 ngôn ngữ 51 ký tự = (4/51) = 0,0784313725490196

Không biết có bao nhiêu số sau dấu phẩy bạn muốn vì vậy tôi sẽ để nó như thế này.
Tất cả các đoạn có độ dài 51 ký tự khi bạn xóa tất cả khoảng trắng.
Làm việc trên nhiều mã hơn và ngắn hơn nhưng đó là một sự khởi đầu.

Đăng nhập

Câu trả lời ban đầu
Gửi Python (3.4), Lua (5.1) và Javascript.
Điểm: 3/51 = 0,0588235294117647

Cập nhật 1
Đã thêm
Điểm Ruby : 4/51 = 0,0784313725490196.

Con trăn 3,4

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

Lôi 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);
  }
}

Hồng ngọc

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

1 ngôn ngữ - 56 ký tự = 0,01785714285

piet (2x28) -