Discussione della polizia

In questo thread, il tuo compito è creare un programma / funzione basato sulla ricorsione per generare qualsiasi serie di numeri interi. I ladri cercheranno di trovare una soluzione non ricorsiva più corta nel thread dei ladri .

Sinossi della sfida

In molte lingue, le funzioni ricorsive possono semplificare in modo significativo un'attività di programmazione. Tuttavia, il sovraccarico della sintassi per una corretta ricorsione può limitare la sua usabilità nel code-golf.

I poliziotti creeranno un programma o una funzione prendendo un singolo intero n, che genererà le prime nvoci di una serie di numeri interi, usando solo la ricorsione ¹ . Dovrebbero anche assicurarsi che esista un modo più breve e non ricorsivo per generare la sequenza al fine di contrassegnare la loro voce come sicura.

I ladri proveranno a trovare un programma o una funzione più brevi nella stessa lingua, generando le stesse serie di numeri interi, senza ricorrere alla ricorsione ² .

Se la presentazione dei poliziotti non viene decifrata entro dieci giorni (240 ore), il poliziotto dimostrerà che era effettivamente possibile avere un approccio non ricorsivo più breve rivelando la propria soluzione. Possono quindi contrassegnare la loro presentazione come sicura .

Il vincitore della sfida degli sbirri sarà l' invio più breve (secondo code-golf ) basato sulla ricorsione contrassegnato come sicuro.

Il vincitore della sfida dei ladri sarà il ladro che ha decifrato il maggior numero di soluzioni.

^{1: deve solo essere ricorsivo nella sintassi; non devi preoccuparti, ad esempio, dell'ottimizzazione delle chiamate di coda.}

^{2: Ancora una volta, non ricorsivo nella sintassi; quindi non puoi pubblicare una soluzione ricorsiva e rivendicarne la compilazione in un ciclo grazie all'ottimizzazione delle chiamate di coda.}

Requisiti per la presentazione

Ogni invio prenderà un singolo numero intero n(zero o basato su uno). L'invio quindi produrrà o restituirà le prime nvoci di una serie intera di scelta. (nota che questa serie di numeri interi non deve dipendere da n). Il metodo di input e output può differire tra l'approccio ricorsivo e non ricorsivo. Le serie intere possono essere qualsiasi serie deterministica con una lunghezza di almeno 5. Le serie devono essere spiegate correttamente.

Il tuo invio non deve funzionare per arbitrari di grandi dimensioni n, ma dovrebbe funzionare almeno per n=5. L'approccio non ricorsivo deve essere in grado di funzionare almeno allo stesso nmodo dell'approccio ricorsivo o n=2^15-1, a seconda di, quale sia il più piccolo.

ricorsione

Per il bene di questa sfida, la ricorsione è definita come la creazione della sequenza desiderata usando una funzione (o un costrutto simile a una funzione ) che chiama se stessa (o chiama una sequenza di funzioni che finisce per chiamarsi; questo include costrutti come il combinatore Y). La profondità di ricorsione dovrebbe andare all'infinito così come nall'infinito. L'approccio non ricorsivo è tutto ciò che non è ricorsivo.

Python 3 , 65 byte (sicuro)

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)

Provalo online!

Un altro tentativo in Python.

La sequenza è "il numero di modi per riempire una tavola 2 per n con domino in tre colori, in modo che nessun domino dello stesso colore si tocchi". Non su OEIS.

Diciamo di Let n=6. La scheda è simile a:

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

e questi sono soffitti domino validi in tre colori ( 1-3rappresentano un colore ciascuno):

123123 122331 212332 212121 113311
123123 133221 212112 212121 331133

ma questi non lo sono (due domino dello stesso colore si toccano):

112323 332333 211113
112323 112311 233223

La sequenza conta tutti i possibili domini di domino che soddisfano le regole per ciascuno n.

Soluzione prevista, 58 byte

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

Provalo online!

Sfortunatamente sembra che nessuno si sia preoccupato di semplificare la relazione di ricorrenza, che è stata chiaramente mostrata nel codice ricorsivo. Fare un programma con la doppia ricorrenza data com'è non funziona poiché è Python 3.

Ottava , 47 byte, incrinata da l4m2

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

Provalo online!

Ad esempio, ecco una voce di Ottava che genera i primi nnumeri interi positivi, https://oeis.org/A000027 .

Python 3 , 75 byte, crackato da 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}))

Provalo online!

I famosi numeri di Hamming, noti anche come numeri a 5 caratteri ( A051037 ).

Soluzione rotta, 51 byte

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

Provalo online!

Soluzione prevista, 74 byte

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

Provalo online!

Forth (gforth) , 39 byte, rotto da NieDzejkob

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

Provalo online!

Röda , 40 byte

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

Provalo online!

Questa funzione fornisce la seguente sequenza finita (i primi 90 numeri di Fibonacci):

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

So che può generare più numeri di Fibonacci, ma ai fini di questa sfida è sufficiente produrre questi numeri.

JavaScript (Node.js) , 91 byte, rotto da 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]

Provalo online!

Stampa i primi n termini della sequenza OEIS A022559 (a partire da i = 1).

l4m2 misura 3 per loop in 74 72 byte e ha rotto il mio post di polizia:

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

Tuttavia, la mia risposta prevista in realtà ha solo 2 per i loop:

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

Provalo online!

x86. Funzione COM, 12 byte, Cracked by 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

Ingresso DX, Uscita [DI] ~ [DI + 2 * DX-1]

Soluzione di 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

Soluzione prevista:

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

Python 3 , 62 byte, Cracking di mwchase

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

Provalo online!

Sento che questo sarà troppo facile ...

La sequenza è la sequenza di Fibonacci f(n) = f(n-1) + f(n-2)conf(0) = f(1) = 1

Gol> <> , 15 byte, crackato da mbomb007

I1AZZ;
M:K:?ZNB

Provalo online!

La serie è 0,1,2,3,4,5ma ogni elemento è seguito da tanti 0.

Ad esempio, i primi valori sono:

 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, Cracked

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

Provalo online!

Restituisce i primi n elementi in un array invertito

Windows .BAT, 80 byte

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

Uso:

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

La versione del ciclo può assumere nel dizionario corrente, ma deve essere inizializzata o ripristinata

Python, 82 byte; Cracked

Questa è un'implementazione ricorsiva di Python della sequenza OEIS A004001 in 82 byte. Ulteriori informazioni su questa serie sono disponibili su Mathworld di 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]]

I primi 30 numeri in questa sequenza sono:

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