Cops 'chủ đề

Trong luồng này, nhiệm vụ của bạn là tạo một chương trình / hàm dựa trên đệ quy để tạo ra bất kỳ chuỗi số nguyên nào. Những tên cướp sẽ thử và tìm một giải pháp không đệ quy ngắn hơn trong chuỗi của Cướp .

Tóm tắt thử thách

Trong nhiều ngôn ngữ, các hàm đệ quy có thể đơn giản hóa đáng kể một tác vụ lập trình. Tuy nhiên, chi phí cú pháp cho một đệ quy thích hợp có thể hạn chế khả năng sử dụng của nó trong môn đánh gôn.

Các cảnh sát sẽ tạo ra một chương trình hoặc hàm lấy một số nguyên duy nhất n, sẽ tạo ra các nmục đầu tiên của một chuỗi số nguyên, chỉ sử dụng đệ quy ¹ . Họ cũng nên đảm bảo rằng có một cách không hồi quy ngắn hơn để tạo chuỗi để đánh dấu mục nhập của họ là an toàn.

Những tên cướp sẽ cố gắng tìm một chương trình hoặc hàm ngắn hơn trong cùng một ngôn ngữ, tạo ra chuỗi số nguyên giống nhau, không sử dụng đệ quy ² .

Nếu đệ trình của cảnh sát không bị bẻ khóa trong vòng mười ngày (240 giờ), cảnh sát sẽ chứng minh rằng trên thực tế có thể có một cách tiếp cận không đệ quy ngắn hơn bằng cách tiết lộ giải pháp của riêng họ. Sau đó họ có thể đánh dấu trình của họ là an toàn .

Người chiến thắng trong thử thách cảnh sát sẽ là người đệ trình dựa trên đệ quy ngắn nhất (theo mã-golf ) được đánh dấu an toàn.

Người chiến thắng trong thử thách cướp sẽ là kẻ cướp phá được nhiều giải pháp nhất.

^{1: Nó chỉ cần được đệ quy theo cú pháp; bạn không cần phải lo lắng về việc tối ưu hóa cuộc gọi ví dụ.}

^{2: Một lần nữa, không đệ quy theo cú pháp; vì vậy bạn không thể đăng một giải pháp đệ quy và yêu cầu nó được biên dịch thành một vòng lặp nhờ tối ưu hóa cuộc gọi đuôi.}

Yêu cầu nộp đơn

Mỗi lần gửi sẽ lấy một số nguyên duy nhất n(không hoặc dựa trên một). Việc gửi sau đó sẽ xuất hoặc trả về các nmục đầu tiên của một chuỗi số nguyên lựa chọn. (lưu ý rằng chuỗi số nguyên này không được phụ thuộc vào n). Phương thức đầu vào và đầu ra có thể khác nhau giữa phương pháp đệ quy và không đệ quy. Chuỗi số nguyên có thể là bất kỳ chuỗi xác định nào có độ dài ít nhất là 5. Chuỗi cần được giải thích chính xác.

Trình của bạn không phải làm việc cho lớn tùy ý n, nhưng nên làm việc ít nhất n=5. Cách tiếp cận không đệ quy phải có khả năng hoạt động tối thiểu giống nnhư cách tiếp cận đệ quy, hoặc tối đa n=2^15-1, tùy theo cái nào nhỏ hơn.

Đệ quy

Vì lợi ích của thách thức này, đệ quy được định nghĩa là tạo ra chuỗi mong muốn bằng cách sử dụng một hàm (hoặc cấu trúc giống như hàm) tự gọi (hoặc gọi một chuỗi các hàm kết thúc bằng cách gọi chính nó, bao gồm các cấu trúc như tổ hợp Y). Độ sâu đệ quy nên đi đến vô cùng như nđi đến vô tận. Cách tiếp cận không đệ quy là bất cứ điều gì không đệ quy.

Python 3 , 65 byte (An toàn)

f=lambda n,a=3,b=0,c=6,d=6:n*[1]and[a+b]+f(n-1,c,d,2*c+d,2*a+3*b)

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

Một thử khác trong Python.

Trình tự này là "số cách để lấp đầy một bảng 2 nhân với các quân cờ trong ba màu, sao cho không có hai quân cờ cùng màu chạm vào nhau". Không phải trên OEIS.

Hãy nói n=6. Bảng trông như:

######
######

và đây là những lát gạch domino hợp lệ trong ba màu ( 1-3đại diện cho một màu mỗi màu):

123123 122331 212332 212121 113311
123123 133221 212112 212121 331133

nhưng đây không phải là (hai domino cùng màu đang chạm vào nhau):

112323 332333 211113
112323 112311 233223

Trình tự đếm tất cả các nghiêng domino có thể đáp ứng các quy tắc cho mỗi n.

Giải pháp dự định, 58 byte

n=int(input());a=3;b=12
for _ in[0]*n:print(a);a,b=b,a*4+b

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

Thật không may, có vẻ như không ai bận tâm để đơn giản hóa mối quan hệ lặp lại, được thể hiện rõ ràng trong mã đệ quy. Tạo một chương trình với sự lặp lại gấp đôi như đã cho là không hoạt động vì đó là Python 3.

Octave , 47 byte, bị bẻ khóa bởi l4m2

@(n)(f=@(r,m){@()[r(r,m-1),m],[]}{~m+1}())(f,n)

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

Ví dụ, đây là một mục Octave tạo ra các nsố nguyên dương đầu tiên , https://oeis.org/A000027 .

Python 3 , 75 byte, bị bẻ khóa bởi xnor

f=lambda n,a=[1]:a*n and[a[0]]+f(n-1,sorted({*a[1:],a[0]*2,a[0]*3,a[0]*5}))

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

Các số Hamming nổi tiếng, còn gọi là số 5 số ( A051037 ).

Giải pháp bẻ khóa, 51 byte

lambda n:[k for k in range(1,2**n)if 60**k%k<1][:n]

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

Giải pháp dự định, 74 byte

lambda n:sorted(2**(i%n)*3**(i//n%n)*5**(i//n**2)for i in range(n**3))[:n]

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

Forth (gforth) , 39 byte, bị bẻ khóa bởi NieDzejkob

: | dup 1 > if dup 1 - recurse then . ;

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

Röda , 40 byte

f x,a=1,b=2{[a];f x-1,a=b,b=a+b if[x>1]}

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

Hàm này đưa ra chuỗi hữu hạn sau (90 số Fibonacci đầu tiên):

1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765
10946
17711
28657
46368
75025
121393
196418
317811
514229
832040
1346269
2178309
3524578
5702887
9227465
14930352
24157817
39088169
63245986
102334155
165580141
267914296
433494437
701408733
1134903170
1836311903
2971215073
4807526976
7778742049
12586269025
20365011074
32951280099
53316291173
86267571272
139583862445
225851433717
365435296162
591286729879
956722026041
1548008755920
2504730781961
4052739537881
6557470319842
10610209857723
17167680177565
27777890035288
44945570212853
72723460248141
117669030460994
190392490709135
308061521170129
498454011879264
806515533049393
1304969544928657
2111485077978050
3416454622906707
5527939700884757
8944394323791464
14472334024676221
23416728348467685
37889062373143906
61305790721611591
99194853094755497
160500643816367088
259695496911122585
420196140727489673
679891637638612258
1100087778366101931
1779979416004714189
2880067194370816120
4660046610375530309

Tôi biết nó có thể tạo ra nhiều số Fibonacci hơn, nhưng với mục đích của thách thức này, nó đủ để tạo ra những con số này.

JavaScript (Node.js) , 91 byte, bị bẻ khóa bởi l4m2

f=x=>[w=~-x&&(g=(n,y=2)=>~-n&&(n<y?1:n%y?g(n,y+1):1+g(n/y,y)))(x)+f(x-1),console.log(w)][0]

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

In n điều khoản đầu tiên của chuỗi OEIS A022559 (bắt đầu từ i = 1).

l4m2 vừa với 3 vòng lặp thành 74 72 byte và bẻ khóa bài đăng của tôi:

n=>{for(i=s=0;j=i++<n;console.log(s))for(x=i;j++<i;)for(;x%j<1;x/=j)s++}

Tuy nhiên, câu trả lời dự định của tôi thực sự chỉ có 2 vòng lặp:

n=>{for(i=c=0;i++<n;console.log(c))for(p=2,z=i;p<=z;z%p?p++:(z/=p,c++));}

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

Hàm x86 .COM, 12 byte, bị bẻ khóa bởi NieDzejkob

0000 52                     push dx
0001 4A                     dec dx
0002 7403                   je 0007
0004 E8F9FF                 call 0000
0007 58                     pop ax
0008 F7E0                   mul ax
000A AB                     stosw


000B C3                     ret

Đầu vào DX, Đầu ra [DI] ~ [DI + 2 * DX-1]

Giải pháp của Cracker:

0: 31 C0    xor ax, ax
2: BF 01 00 mov di, 1
5: 01 F8    add ax, di
7: AB       stosw
8: E2 FB    loop 5
A: C3       ret

Giải pháp dự định:

  xor bx,bx
c:inc bx
  mov ax,bx
  mul ax
  stosw
  loop c
  ret

Python 3 , 62 byte, Cracked bởi mwchase

def f(x):
 if(x<1):return[1]
 return f(x-1)+[sum(f(x-1)[-2:])]

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

Tôi cảm thấy việc này sẽ quá dễ dàng ...

Chuỗi này là chuỗi Fibonacci f(n) = f(n-1) + f(n-2)vớif(0) = f(1) = 1

Gol> <> , 15 byte, bị bẻ khóa bởi mbomb007

I1AZZ;
M:K:?ZNB

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

Bộ này là 0,1,2,3,4,5 nhưng mỗi phần tử được theo sau bởi nhiều 0.

Ví dụ: một vài giá trị đầu tiên là:

 1: 0  First element, followed by 0 zeroes
 2: 1  Followed by 1 zero
 3: 0
 4: 2  Followed by 2 zeroes
 5: 0
 6: 0
 7: 3  Followed by 3 zeroes
 8: 0
 9: 0
10: 0
    etc.

JavaScript, 63 byte, đã bẻ khóa

f=x=>(x?[f(x-1)[0]&&1?3*f(x-1)[0]+1:f(x-1)[0]/2,...f(x-1)]:[7])

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

Trả về n phần tử đầu tiên trong một mảng đảo ngược

Windows .BAT, 80 byte

@set /a n=%1-1
@echo 8%3
@if 0 neq %n% @call %0 %n% 2%3 6%2%3

Sử dụng:

CD <PATH>
<FILENAME> <N_1>
<FILENAME> <N_2>
<FILENAME> <N_3>

Phiên bản vòng lặp có thể giả sử trong từ điển hiện tại, nhưng phải khởi tạo hoặc đặt lại

Python, 82 byte; nứt

Đây là một triển khai Python đệ quy của chuỗi OEIS A004001 với 82 byte. Thông tin thêm về loạt bài này có thể được tìm thấy trên Mathram của Wolfram .

def A(n):
 if n in[1,2]:return[1]*n
 S=A(n-1);return S+[S[S[n-2]-1]+S[n-S[n-2]-1]]

30 số đầu tiên trong chuỗi này là:

1, 1, 2, 2, 3, 4, 4, 4, 5, 6, 7, 7, 8, 8, 8, 8, 9, 10, 11, 12, 12, 13, 14, 14, 15, 15, 15, 16, 16, 16