Hilo de policías

En este hilo, su tarea es crear un programa / función basado en recursividad para generar cualquier serie entera. Los ladrones intentarán encontrar una solución no recursiva más corta en el hilo de los ladrones .

Sinopsis del desafío

En muchos idiomas, las funciones recursivas pueden simplificar significativamente una tarea de programación. Sin embargo, la sobrecarga de sintaxis para una recursión adecuada puede limitar su usabilidad en code-golf.

Los policías crearán un programa o función tomando un solo entero n, que generará las primeras nentradas de una serie de enteros, utilizando solo la recursividad ¹ . También deben asegurarse de que haya una forma más corta y no recursiva de generar la secuencia para marcar su entrada como segura.

Los ladrones intentarán encontrar un programa o función más cortos en el mismo idioma, generando la misma serie entera, sin recurrencia ² .

Si la presentación de la policía no se resuelve en diez días (240 horas), el policía demostrará que, de hecho, era posible tener un enfoque no recursivo más corto al revelar su propia solución. Luego pueden marcar su presentación como segura .

El ganador del desafío de policías será la presentación basada en recursión más corta (según el código de golf ) marcada como segura.

El ganador del desafío de los ladrones será el ladrón que descubrió la mayor cantidad de soluciones.

^{1: solo necesita ser recursivo en sintaxis; no necesita preocuparse, por ejemplo, por la optimización de llamadas de cola.}

^{2: De nuevo, no recursivo en sintaxis; por lo que no puede publicar una solución recursiva y reclamar que está compilada en un bucle gracias a la optimización de la cola de llamadas.}

Requerimientos de la sumisión

Cada envío tendrá un solo entero n(cero o uno). La presentación generará o devolverá las primeras nentradas de una serie entera de elección. (tenga en cuenta que esta serie entera no debe depender de n). El método de entrada y salida puede diferir entre el enfoque recursivo y el no recursivo. La serie entera puede ser cualquier serie determinista con una longitud de al menos 5. La serie debe explicarse correctamente.

Su envío no tiene que funcionar para arbitrariamente grande n, pero debería funcionar por lo menos n=5. El enfoque no recursivo debe ser capaz de funcionar hasta al menos lo mismo nque el enfoque recursivo, o hasta n=2^15-1, lo que sea menor.

Recursividad

En aras de este desafío, la recursión se define como la creación de la secuencia deseada utilizando una función (o construcción similar a una función ) que se llama a sí misma (o llama a una secuencia de funciones que termina llamándose a sí misma; esto incluye construcciones como el combinador Y). La profundidad de recursión debe ir al infinito como nva al infinito. El enfoque no recursivo es cualquier cosa que no sea recursiva.

Python 3 , 65 bytes (Seguro)

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)

Pruébalo en línea!

Otro intento en Python.

La secuencia es "la cantidad de formas de llenar un tablero de 2 por n con fichas de dominó en tres colores, de modo que no se toquen dos fichas de dominó del mismo color". No en OEIS.

Digamos Vamos n=6. El tablero se ve así:

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

y estos son tiros de dominó válidos en tres colores ( 1-3representan un color cada uno):

123123 122331 212332 212121 113311
123123 133221 212112 212121 331133

pero estos no lo son (dos fichas de dominó del mismo color se tocan entre sí):

112323 332333 211113
112323 112311 233223

La secuencia cuenta todas las posibles inclinaciones de dominó que satisfacen las reglas para cada una n.

Solución prevista, 58 bytes

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

Pruébalo en línea!

Desafortunadamente, parece que nadie se molestó en simplificar la relación de recurrencia, que se mostró claramente en el código recursivo. Hacer un programa con la doble recurrencia dada tal cual no funciona ya que es Python 3.

Octava , 47 bytes, agrietada por l4m2

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

Pruébalo en línea!

Como ejemplo, aquí hay una entrada de octava que genera los primeros nenteros positivos, https://oeis.org/A000027 .

Python 3 , 75 bytes, descifrado por 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}))

Pruébalo en línea!

Los famosos números de Hamming, también conocidos como 5 números lisos ( A051037 ).

Solución agrietada, 51 bytes

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

Pruébalo en línea!

Solución prevista, 74 bytes

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

Pruébalo en línea!

Adelante (gforth) , 39 bytes, descifrado por NieDzejkob

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

Pruébalo en línea!

Röda , 40 bytes

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

Pruébalo en línea!

Esta función proporciona la siguiente secuencia finita (los 90 primeros números de 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

Sé que puede generar más números de Fibonacci, pero para los propósitos de este desafío es suficiente producir estos números.

JavaScript (Node.js) , 91 bytes, descifrado por 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]

Pruébalo en línea!

Imprime los primeros n términos de la secuencia OEIS A022559 (comenzando desde i = 1).

l4m2 encajó 3 para bucles en 74 72 bytes y descifró mi publicación de policía:

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

Sin embargo, mi respuesta prevista en realidad solo tiene 2 para bucles:

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

Pruébalo en línea!

Función x86 .COM, 12 bytes, Agrietada por 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

Entrada DX, Salida [DI] ~ [DI + 2 * DX-1]

La solución del 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

Solución prevista:

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

Python 3 , 62 bytes, agrietado por mwchase

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

Pruébalo en línea!

Siento que este será demasiado fácil ...

La secuencia es la secuencia de Fibonacci f(n) = f(n-1) + f(n-2)conf(0) = f(1) = 1

Gol> <> , 15 bytes, descifrado por mbomb007

I1AZZ;
M:K:?ZNB

Pruébalo en línea!

La serie es 0,1,2,3,4,5pero cada elemento es seguido por esa cantidad de ceros.

Por ejemplo, los primeros valores son:

 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 bytes, agrietado

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

Pruébalo en línea!

Devuelve los primeros n elementos en una matriz invertida

Windows .BAT, 80 bytes

@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 versión de bucle puede asumir en el diccionario actual, pero debe iniciar o restablecer

Python, 82 bytes; agrietado

Esta es una implementación recursiva de Python de la secuencia OEIS A004001 en 82 bytes. Se puede encontrar más información sobre esta serie en Wolfram's Mathworld .

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]]

Los primeros 30 números en esta secuencia son:

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