Đây là một thử thách Cops và Robbers. Đây là chủ đề của tên cướp. Các chủ đề của cảnh sát là đây .

Các cảnh sát sẽ chọn bất kỳ chuỗi nào từ OEIS và viết chương trình p in số nguyên đầu tiên từ chuỗi đó. Họ cũng sẽ tìm thấy một số chuỗi s . Nếu bạn chèn s ở đâu đó vào p , chương trình này phải in số nguyên thứ hai từ chuỗi. Nếu bạn chèn s + s vào cùng một vị trí trong p , chương trình này phải in số nguyên thứ ba từ chuỗi. s + s + s ở cùng một vị trí sẽ in thứ tư, v.v. Đây là một ví dụ:

Python 3, trình tự A000027

print(1)

Chuỗi ẩn là hai byte .

Chuỗi là +1bởi vì chương trình print(1+1)sẽ in số nguyên thứ hai trong A000027, chương trình print(1+1+1)sẽ in số nguyên thứ ba, v.v.

Cảnh sát phải tiết lộ chuỗi, chương trình gốc p và độ dài của chuỗi ẩn s . Robbers crack một trình bằng cách tìm bất kỳ chuỗi lên đến đó chiều dài và vị trí để chèn nó để tạo ra các chuỗi. Chuỗi không cần phải khớp với giải pháp dự định là một vết nứt hợp lệ, cũng như vị trí mà nó được chèn vào.

Nếu bạn bẻ khóa một trong những câu trả lời của cảnh sát, hãy đăng giải pháp của bạn (với chuỗi ẩn và vị trí được tiết lộ) và liên kết đến câu trả lời. Sau đó nhận xét về câu trả lời của cảnh sát với một liên kết đến vết nứt của bạn ở đây.

Quy tắc

• Giải pháp của bạn phải hoạt động cho bất kỳ số nào trong chuỗi hoặc ít nhất là cho đến khi giới hạn hợp lý khi bị lỗi do hạn chế bộ nhớ, tràn số nguyên / ngăn xếp, v.v.

• Kẻ cướp chiến thắng là người sử dụng phá vỡ nhiều đệ trình nhất, với người bẻ khóa là người đạt được số lượng vết nứt đó trước tiên.

• Viên cảnh sát trúng thầu là cảnh sát với chuỗi ngắn nhất s mà không bị nứt. Tiebreaker là p ngắn nhất . Nếu không có đệ trình không bị theo dõi, cảnh sát đã có một giải pháp không bị theo dõi cho chiến thắng lâu nhất.

• Để được tuyên bố an toàn, giải pháp của bạn phải được giữ nguyên trong vòng 1 tuần và sau đó tiết lộ chuỗi ẩn (và vị trí để chèn).

• s có thể không được lồng nhau, nó phải nối từ đầu đến cuối. Ví dụ, nếu s là 10, mỗi lần lặp sẽ đi 10, 1010, 101010, 10101010...chứ không phải là10, 1100, 111000, 11110000...

• Tất cả các giải pháp mật mã (ví dụ: kiểm tra hàm băm của chuỗi con) đều bị cấm.

• Nếu s chứa bất kỳ ký tự không phải ASCII nào, bạn cũng phải chỉ định mã hóa đang được sử dụng.

Python 2 , chuỗi A138147 bởi xnor

Nguyên:

print 10

Nứt

print "1%s0"%10
      ^^^^^^^

Hãy thử trực tuyến!

Brain-Flak , A000984 của Nitrodon

({({}<>({}))<>}<>){({}<>)<>}<>

Đây chỉ là 30 byte, không chắc Nitrodon nghĩ gì.

Hãy thử trực tuyến!

Giải trình

Tôi đã thử rất nhiều thứ nhưng đây là những gì đã làm việc. Các điều khoản của A000984 là các yếu tố trung tâm của tam giác Pascal.

Bây giờ tôi đã tìm ra rằng tôi có thể có được chúng bằng cách thêm các đường chéo phía trên chúng:

Ví dụ:

$1+3+6+10 = 20$

Và vì hành động cuối cùng trong chương trình của Nitrodon là tổng hợp tất cả mọi thứ có vẻ như là một ứng cử viên tốt (giống như tôi đã thử một loạt các thứ nhưng cái này đã kết thúc hoạt động).

Vì vậy, chúng tôi muốn một chương trình lấy một phần một phần và tạo ra phần tiếp theo. May mắn thay, có một cách khá gọn gàng để đi từ cái này sang cái khác. Mỗi hàng là deltas của hàng tiếp theo. Đó là $n$ thứ hạn trong một hàng là phần chênh lệch giữa $n$ th và $n-1$ ngày điều khoản trong hàng tiếp theo.

Một vấn đề là chúng ta không có đủ hàng cuối cùng để tính hàng chúng ta muốn. Vì mỗi hàng dài hơn một hàng nếu chúng ta có một hàng, chúng ta không thể có được thành viên cuối cùng của hàng tiếp theo bằng phương thức này. Tuy nhiên ở đây chúng tôi có một mẹo khác, thành viên cuối cùng của mỗi hàng bằng với tất cả các thành viên trước đó của hàng đó!

$1+3+6=10$

Và nếu bạn đã quen thuộc với Brain-Flak, thứ sẽ phù hợp với bạn như một thứ gì đó sẽ thực sự dễ làm.

Bây giờ cho mã:

Để bắt đầu, chúng tôi thực hiện phép tính hàng tiếp theo trong đó mỗi thành viên mới là tổng của hai thành viên cũ liền kề. Điều đó có thể được thực hiện với:

{({}<>({}))<>}<>

Về cơ bản di chuyển một yếu tố trên và thêm (không xóa) những gì đã từng ở trên nó. Tuy nhiên, điều này đảo ngược mọi thứ vì vậy trong lần tiếp theo chúng tôi nhận được một hàng, chúng tôi cần phải đặt lại.

{({}<>({}))<>}<>{({}<>)<>}<>

Bây giờ chúng ta cần tính toán thành viên cuối cùng của hàng. Như tôi đã nói trước đây là siêu dễ dàng. Vì chúng ta có một vòng lặp trên tất cả các phần tử của hàng, chúng ta chỉ cần lấy tổng đó và đẩy nó. Chúng tôi đẩy nó trước vòng lặp thứ hai để nó kết thúc ở phía dưới.

({({}<>({}))<>}<>){({}<>)<>}<>

Và đó là nó.

Brain-Flak, A000290 , bởi Sriotchilism O'Z cổ

Nguyên:

((()))({}<>)

Nứt

((()))({}([])[]<>)
         ^^^^^^

Hãy thử trực tuyến!

Cách khác:

((())([])[])({}<>)
     ^^^^^^

Hãy thử trực tuyến!

MATL , trình tự A005206 của Luis Mendo

Nguyên:

voOdoO

Hãy thử trực tuyến!

Nứt

voOdoOdNq17L/k
      ^^^^^^^^

Tôi không phải là chuyên gia MATL, nhưng theo những gì tôi hiểu, bản gốc voOdoOtạo ra hai mảng trống và một mảng [0]trên ngăn xếp. đây [0]là những gì được in mà không có dấu ngoặc là phần tử đầu tiên của chuỗi. Các crack / giải pháp sau đó thực hiện như sau:

• dlấy một phần tử ra khỏi ngăn xếp và (giả sử đó là một số hoặc một mảng có kích thước 1) biến nó thành một mảng trống. Các mảng trống này không được in, nhưng đóng góp vào kích thước ngăn xếp
• Nqđếm kích thước của ngăn xếp và trừ đi một. Đây là n+1thuật ngữ khi đánh giá hàm (vì nó bắt đầu từ 2 và tăng thêm mỗi lần lặp vì dthêm các thứ vô hình vào ngăn xếp)
• 17L đây là hằng số Phi = (1+sqrt(5))/2
• /kđiều này thực hiện floor((n+1)/Phi)đó là một trong những công thức tính toán các phần tử của chuỗi. Công thức này được liệt kê trên OEIS a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2trừ khi chúng tôi sử dụng danh tính(sqrt(5)-1)/2 = 1/Phi

Con trăn 3 - A__

print(100+-1)

Hãy thử trực tuyến!

100 chai bia, thêm -1để có được số tiếp theo 99, vv

Keg , trình tự A000045 , bởi A__

Nguyên:

0.

Nứt

01":&+.
 ^^^^^

Lưu ý rằng thử thách là tìm chuỗi con có độ dài <= 6, nhưng chuỗi tìm thấy có độ dài 5.

Định nghĩa các lệnh cho những người quá lười biếng để tra cứu đặc tả Keg: 0và 1đẩy số tương ứng vào ngăn xếp; "di chuyển đỉnh ngăn xếp đến đáy ngăn xếp (cuộn); &bật đỉnh ngăn xếp vào thanh ghi nếu nó trống, nếu không sẽ làm trống thanh ghi trên ngăn xếp; +thêm hai giá trị ngăn xếp hàng đầu.

Ban đầu 1"chỉ cần chèn 1 ở dưới cùng của ngăn xếp. Danh sách ngày càng tăng này chỉ đóng một vai trò trong lần lặp đầu tiên, trong đó nó cho phép chúng ta giả sử ngăn xếp bắt đầu 1 0thay vì chỉ 0. Thật vậy, chương trình 10:&+., nơi :&+phần được lặp lại, có hành vi chính xác giống như giải pháp ở trên, ngoại trừ việc nó không có danh sách ngày càng tăng 1 ở phía dưới.

Vì &chỉ được sử dụng một lần trong phần lặp lại và có hành vi xen kẽ, nên hành vi 1":&+phụ thuộc vào tính chẵn lẻ của phép lặp.

Bây giờ, chương trình này không thực sự in chuỗi Fibonacci bắt đầu bằng 0, 1 từ đầu; nó thực sự in chuỗi Fibre 1, 0 từ vị trí thứ hai, tức là từ 0. (Điều này dẫn đến cùng một chuỗi.) Biết được điều này, chương trình được phân tích dễ dàng:

• Trong lần lặp đầu tiên, thứ ba, ... lặp đi lặp lại, trạng thái bắt đầu [a, b]và kết thúc là a+b (&=b).
• Trong lần lặp thứ hai, thứ tư, ... lặp lại, trạng thái bắt đầu [b] (&=a)và kết thúc là [b, b+a].

Điều này thực sự tính toán trình tự theo yêu cầu.

Java 8+, trình tự A010686 của Benjamin Urquhart

()->System.out.println(1^4);
                        ^^

Brain-Flak, A000578 của Sriotchilism O'Z cổ

Nguyên:

((())<>)

Hãy thử trực tuyến!

Nứt

((())(({})([][][]){})<>)
    ^^^^^^^^^^^^^^^^

Hãy thử trực tuyến!

Pyret , trình tự A083420 , bởi MLavrentyev

fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

Bạn có thể chạy nó ở đây, nhưng tôi chưa tìm ra cách liên kết đến mã. Bạn sẽ phải sao chép-dán.

Hàm được cung cấp bỏ qua đối số thứ hai của nó. Nó nhân đôi lần đầu tiên và thêm một lần, sẽ tạo ra 2^n - 1chuỗi cần thiết cần thiết ở đây, tất cả những gì tôi cần làm là nói cho nó biết bao nhiêu lần để thực hiện thao tác đó, được thực hiện bằng cách thay đổi độ dài của danh sách gấp. May mắn thay, Pyret không phàn nàn về dấu phẩy đó.

Python 3 , trình tự A268575 của NieDzejkob

Nguyên:

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

Đã bẻ khóa (100 byte):

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

Hãy thử trực tuyến!

Từ những gì tôi có thể thu thập, mã ban đầu đang thiết lập các định nghĩa để làm cho chuỗi ẩn được viết tắt càng tốt và sau đó xác định mẫu Game of Life ban đầu. Chuỗi ẩn sau đó tương đương với việc viết một vòng lặp của Trò chơi cuộc sống của Conway bằng 102 byte.

Đối với mục đích của vết nứt này, Slà một hàm tính tổng các phần tử trong các đối số của nó (là các lần lặp) và Fáp dụng một hàm trả về một lần lặp cho mọi phần tử của danh sách và đập tất cả các kết quả lại với nhau.

• ;A=-1,1,0;kết thúc câu lệnh trước và viết tắt tuple (-1,1,0) bằng A, được sử dụng product(A,A)để cung cấp cho tất cả các lân cận liên quan đến một ô đã cho cũng như chính ô đó.
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);tạo một danh sách mới Xchứa tất cả các lân cận của các ô trong Wvà các ô trong Wchính chúng bằng cách thêm các vị trí tương đối của các ô lân cận vào mỗi ô và đập chúng lại với nhau thành một danh sách.
• W={p for p in X if 2<X.count(p)<4+({p}<W)}đi qua danh sách này Xvà xác định xem mỗi ô Xthuộc về tập hợp các ô trong lần lặp tiếp theo. Điều này đã được lấy gần như nguyên văn từ golf Game of Life này .

Haskell, A014675 của Khuldraeseth na'Barya

Mã gốc

main=print$uncurry(!!)([2],0)

Với chuỗi con

main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

Hãy thử trực tuyến!

Máy tính để bàn, A006125 , bởi A__

Nguyên:

1n

Nứt

1 2lx1+dsx^*n
 ^^^^^^^^^^^

Hãy thử trực tuyến!

Thực hiện đơn giản.

cQuents , trình tự A003617 của Stephen

=10#2:pZ
  ^

Hãy thử trực tuyến!

Bắt đầu với số n + 1 chữ số thấp nhất, một số theo sau là n số không. Chỉ #2định rằng chỉ có thuật ngữ thứ hai của chuỗi, là định nghĩa trình tự được áp dụng một lần cho hạt giống, sẽ được in; định nghĩa trình tự này chỉ đơn giản là tìm và trả về số nguyên tố tiếp theo.

Python 3 - bất cứ lúc nào

from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

Hãy thử trực tuyến!

MATL , trình tự A000796 bởi Luis Mendo

Nguyên:

'pi'td1_&:_1)Y$J)

Hãy thử trực tuyến!

Nứt

'pi'td1_&:|SQ_1)Y$J)
          ^^^

Tác giả ban đầu đã lén lút tạo ra mảng [-7:-1]và sau đó trích xuất và phủ nhận phần tử đầu tiên của nó để có được 7. Sau đó, ông đã sử dụng nó để có được chữ số pi tròn thứ 7 (nghĩa là 3) và trình bày nó như là chữ số đầu tiên của số pi. Thêm vào |SQlàm cho mảng ban đầu tất cả đều tích cực, sắp xếp nó và thêm một vào mọi thứ. Điều này có nghĩa là sau tất cả mọi thứ thay vì lấy chỉ mục, 7nó sẽ nhận được chỉ mục -2sau một ứng dụng, -3sau hai ứng dụng, v.v. Điều -này rất quan trọng vì nó cho biết Y$hàm không làm tròn các chữ số.

Forth (gforth) , A000042 , bởi NieDzejkob

.( 1)1 .
^^^^^

Hãy thử trực tuyến!

1-byter tầm thường chỉ đơn giản là mở rộng nghĩa đen. Vấn đề là, nó vượt quá 64 bit ngay từ chữ số thứ mười chín. Dễ dàng sửa chữa là in các chữ số duy nhất lặp đi lặp lại, phải không? Đúng, nhưng nó không dễ dàng như vậy. Mặc dù1 . xử lý cuối cùng thực sự sẽ in các chữ số bổ sung mà chúng tôi yêu cầu, chúng sẽ được phân tách bằng dấu cách. Điều đó sẽ không làm việc.

Bây giờ, theo Wikipedia, " .((dot-paren) là một từ ngay lập tức phân tích một chuỗi được phân tách bằng dấu ngoặc đơn và hiển thị nó." May mắn thay, việc hiển thị đó không có các ký tự lạ khác, vì vậy sử dụng .(để in một số 1 là đủ. Và nó làm. Không có không gian là cần thiết sau khi đóng paren, vì vậy năm ký tự này (có một khoảng trống sau paren mở) có thể được lặp lại theo nội dung trái tim của chúng ta. Để chứng minh, tôi đã đưa vào TIO một ví dụ có thể đã tràn int int 64 bit nhiều lần. Hoạt động như một lá bùa.

Unefunge-98 (PyFunge) , trình tự A000108 , bởi NieDzejkob

1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

Hãy thử trực tuyến!

Lặp đi lặp lại sáu lần

Hai byte dự phòng của mười chín được phép! Những gì dường như là một không gian thực sự có một nhân vật Start Of Header 0x01.

Giải trình:

Thách thức này là tất cả về việc tạo ra a(n)từ a(n-1)và có lẽ n. OEIS cung cấp công thức rõ ràng a(n) = (2n)!/(n!(n+1)!), dễ dàng chuyển đổi thànha(n) = a(n-1) * (4n-6) / n . Bây giờ để thực hiện điều này trong Funge.

Tôi phải chèn mã giữa 1và .. Đó là một nửa câu đố đã được thực hiện. Tất cả những gì còn lại là những gì mã để chèn? Funge đáng chú ý là thiếu các công cụ thao tác ngăn xếp, do đó, đáy của ngăn xếp là ngoài giới hạn; Tôi cần theo dõi cả hai nvàa(n) không phát triển ngăn xếp. Và làm thế nào tốt hơn để làm điều đó hơn với không gian Funge?

Nhân vật 0x01 đó là đối trọng của tôi n. Tôi tiếp tục a(n)ngăn xếp, vì nó phải ở trên ngăn xếp sau khi bit của tôi kết thúc thực thi.

1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.

Python 3 , A008574 bởi tsh

print(1*2+2)
       ^^^^

Hãy thử trực tuyến!

V, A000290 , bởi DJMcMayhem

é*Ä2é*Ø.
  ^^^^

mang lại các hình vuông từ 1.

Hãy thử trực tuyến!

Cơ sở é*chèn *và Ø.đếm số lượng ký tự không phải dòng mới trong toàn bộ bộ đệm. Việc chèn Ätrùng lặp dòng trên cùng với dòng riêng của nó, trên đó 2é*chèn **. Sự kết hợp của các phần chèn vào tạo ra các số lẻ liên tiếp với số lớn nhất ở trên cùng. Ø.Hiệu ứng cuối cùng tính tổng n số lẻ đầu tiên, từ đó thu được bình phương thứ n.

AsciiDots , trình tự A019523 của Alion

\ +++ /
// \ / \

Một lần!

Hai lần!

Mười lần!

Trong khi cố gắng tìm hiểu làm thế nào mã / ngôn ngữ hoạt động, tôi đã học được rằng hai dòng đầu tiên của mã hiện có thực hiện tất cả công việc xuất ra chuỗi Fibonacci vô hạn. Mã chấm dứt khi bất kỳ dấu chấm nào chạm vào &, vì vậy tôi chỉ cần thêm độ trễ trong các dòng còn lại để cho phép số lượng mục nhập phù hợp xuất ra.

Sau một số thử nghiệm, lỗi và quan sát, tôi phát hiện ra rằng khoảng thời gian trễ chính xác là 16 đơn vị thời gian cho mỗi số. Sắp xếp đủ các ký tự trong một hàng dường như không khả thi, vì vậy tôi sẽ cần đặt độ trễ thành 2 hàng, để lại 10 ký tự cho độ trễ thực tế. Để mô hình khớp với chính nó, cả hai hàng phải có 5 ký tự và vì ba ký tự ở giữa có thể được dịch chuyển hai lần, điều này mang lại 16 đơn vị thời gian như mong muốn.

Yêu cầu để phù hợp với điều này cho đến &cột thứ tám dường như không thể thực hiện được, cho đến khi tôi nhận ra rằng tôi có thể bắt đầu với một dòng mới trong nội thất của hàng thứ ba. Điều này làm cho hàng áp chót có độ dài phù hợp và loại bỏ phần cuối hiện có của dòng thứ ba.

Brachylog , chuỗi A114018 theo chuỗi không liên quan

Chương trình gốc:

≜ṗ↔ṗb&w

Chuỗi để chèn:

≜ṗ↔ṗẹbb&w
    ^^

Hãy thử trực tuyến!

Giải trình

Dưới đây là lời giải thích đầu tiên của chương trình gốc (biết rằng chuỗi được sử dụng là "số nguyên tố n chữ số nhỏ nhất có đảo ngược chữ số cũng là số nguyên tố")

≜         Assign an integer value to a variable named ? 
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

Như bạn có thể thấy, chương trình này khá đơn giản ngoại trừ một điều: có một b - beheadcuộc gọi vị ngữ hoàn toàn vô dụng , loại bỏ yếu tố đầu tiên đảo ngược số của chúng tôi, mà chúng tôi không làm gì cả.

Đây là một manh mối xác định về cách chúng ta có thể tìm thấy chuỗi. Ý tưởng là, vì chúng tôi muốn tăng độ dài của số thêm 1 chữ số mỗi lần chúng tôi thêm chuỗi, chúng tôi cần một chuỗi "đánh giá" độ dài của số đó bằng cách nào đó, sử dụng số đó vô dụng b.

Giải pháp là sử dụng ẹb: đầu tiên, ẹ - elementssẽ chuyển đổi số thành một danh sách các chữ số; sau đó, b - beheadsẽ loại bỏ phần tử đầu tiên của nó. Bí quyết là bsẽ thất bại nếu danh sách các chữ số trống. Vì vậy, mỗi khi chúng ta nối thêm a b, chúng ta sẽ tăng độ dài của số yêu cầu thêm 1 (vì nó sẽ thất bại cho đến khi giá trị được gán ?đủ cao để chứa đủ nhiều chữ số để số cuối cùng bđược áp dụng trên danh sách một chữ số).

Tái xuất hiện ẹmỗi lần không có hiệu lực vì nó đã là một danh sách các chữ số. Chúng ta chỉ cần một lần vào lúc đầu bởi vì nếu chúng ta chặt đầu một số như 9001thay vì danh sách các chữ số của nó, chúng ta sẽ nhận được 001 = 1thông tin về số chữ số.

VDM-SL , A000312 , theo dữ liệu đã hết hạn

let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

Do các letbiểu hiện của VDM-SL có thể liên kết lại các biến đã bị ràng buộc trong phạm vi kèm theo, nên x**xcó thể được đánh giá tùy ý được lồng sâu trong phạm vi trong đó xnhiều hơn một phạm vi so với phạm vi trước đó, trong khi nguyên bản xvẫn thấp hơn so với phạm vi chính m(1).

Haskell, A083318 bởi xnor

f=length     [2]
        $show

Hãy thử trực tuyến!

Haskell , A000045 (Fibonacci) , bởi biến đổi Fourier của Rin

f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

Hãy thử trực tuyến!

Chính xác là 23 byte.

Điều này là vui vẻ và một chút khó khăn. Số 0 và 1 đảo ngược đã ném tôi đi một chút trước khi tôi nhận ra đó không phải là vấn đề. Sự thiếu$ bản gốc đã khiến tôi thử những thứ sơ sài như $...$id(một byte quá dài) trước khi tôi nhận ra rằng tôi chỉ có thể gói tất cả trong ngoặc đơn. Tất cả trong tất cả, một câu đố nhỏ tốt đẹp.

H.PWiz chỉ ra rằng khớp mẫu có thể giúp tôi tiết kiệm ít nhất năm byte : $(\[x,y]->[y,x+y]). Đó là thử thách vô nghĩa khiến tôi suy nghĩ vô tận ở mọi nơi.