Fil de flics

Dans ce fil, votre tâche consiste à créer un programme / fonction basé sur la récursivité pour générer une série entière. Les voleurs essaieront de trouver une solution non récursive plus courte dans le fil des voleurs .

Synopsis du défi

Dans de nombreux langages, les fonctions récursives peuvent simplifier considérablement une tâche de programmation. Cependant, la surcharge de syntaxe pour une récursivité appropriée peut limiter son utilisation dans le code-golf.

Les flics créeront un programme ou une fonction prenant un seul entier n, qui générera les premières nentrées d'une série entière, en utilisant uniquement la récursivité ¹ . Ils doivent également s'assurer qu'il existe un moyen non récursif plus court de générer la séquence afin de marquer leur entrée comme sûre.

Les voleurs essaieront de trouver un programme ou une fonction plus courte dans le même langage, générant la même série d'entiers, sans récurrence ² .

Si la soumission des flics n'est pas fissurée dans les dix jours (240 heures), le flic prouvera qu'il était en fait possible d'avoir une approche non récursive plus courte en révélant leur propre solution. Ils peuvent ensuite marquer leur soumission comme sûre .

Le gagnant du défi des flics sera la soumission basée sur la récursivité la plus courte (selon le code-golf ) marquée comme sûre.

Le vainqueur du défi des voleurs sera le voleur qui a trouvé le plus de solutions.

^{1: Il doit seulement être récursif dans sa syntaxe; vous n'avez pas à vous soucier par exemple de l'optimisation des appels de queue.}

^{2: Encore une fois, non récursif dans la syntaxe; vous ne pouvez donc pas publier une solution récursive et revendiquer sa compilation dans une boucle grâce à l'optimisation des appels de queue.}

Conditions de soumission

Chaque soumission prendra un seul entier n(zéro ou basé sur un). La soumission affichera ou renverra alors les premières nentrées d'une série entière de choix. (notez que cette série entière ne doit pas dépendre n). La méthode d'entrée et de sortie peut différer entre l'approche récursive et non récursive. La série entière peut être toute série déterministe d'une longueur d'au moins 5. La série doit être expliquée correctement.

Votre soumission ne doit pas nécessairement fonctionner pour une taille arbitraire n, mais devrait fonctionner au moins n=5. L'approche non récursive doit pouvoir fonctionner au moins au même niveau nque l'approche récursive, ou jusqu'à la n=2^15-1plus petite des deux.

Récursivité

Pour relever ce défi, la récursivité est définie comme la création de la séquence souhaitée à l'aide d'une fonction (ou d'une construction de type fonction) qui s'appelle elle-même (ou appelle une séquence de fonctions qui finit par s'appeler elle-même; cela inclut des constructions comme le combinateur Y). La profondeur de récursivité doit aller à l'infini comme nà l'infini. L'approche non récursive est tout ce qui n'est pas récursif.

code-golf sequence cops-and-robbers

— Sanchises
source

Pour le thym où forse fait par récursif derrière, est forrécursif ou en boucle?

— l4m2

Puis-je dire qu'un code fonctionne pour une taille arbitraire ns'il est théoriquement correct, mais qu'il ne peut pas être exécuté en raison de contraintes de temps ou de mémoire?

— Bubbler

@Bubbler Certainement, mais au moins n=5doit être calculé

— Sanchises

@ l4m2 Toutes les langues ne peuvent pas rivaliser. Il semble que cette langue n'ait pas une manière native de ne pas utiliser la récursivité (à moins qu'elle ne xforsoit disponible via une sorte d'importation?) Donc peut-être que cette langue ne peut pas rivaliser.

— Sanchises

Un récursif qui ne va pas beaucoup quand n va grand, est-ce un récursif?

— l4m2

4

Python 3 , 65 octets (sûr)

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)

Essayez-le en ligne!

Un autre essai en Python.

La séquence est "le nombre de façons de remplir un tableau 2 par n avec des dominos en trois couleurs, de sorte qu'il n'y ait pas deux dominos de même couleur qui se touchent". Pas sur OEIS.

Disons n=6. Le tableau ressemble à:

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

et ce sont des carrelages domino valides en trois couleurs ( 1-3représentent une couleur chacun):

123123 122331 212332 212121 113311
123123 133221 212112 212121 331133

mais ce n'est pas le cas (deux dominos de même couleur se touchent):

112323 332333 211113
112323 112311 233223

La séquence compte tous les pavages de dominos possibles qui satisfont aux règles de chacun n.

Solution prévue, 58 octets

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

Essayez-le en ligne!

Malheureusement, personne ne semble avoir pris la peine de simplifier la relation de récurrence, ce qui était clairement indiqué dans le code récursif. Faire un programme avec la double récurrence telle quelle ne fonctionne pas car c'est Python 3.

— Bubbler
source

1

Pourriez-vous nous expliquer plus en détail la séquence s'il vous plaît.

— tsh

@tsh Ajout d'une explication. Est-ce que ça a l'air mieux?

— Bubbler

2

Octave , 47 octets, fissuré par l4m2

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

Essayez-le en ligne!

À titre d'exemple, voici une entrée Octave qui génère les premiers nentiers positifs, https://oeis.org/A000027 .

— Sanchises
source

Fissuré . +1 pour avoir créé une fonction anonyme récursive ... Pas souvent, celles-ci sont utilisées :)

— Stewie Griffin

@StewieGriffin J'adore le golf avec les fonctions anonymes récursives dans Octave, bien qu'elles ne soient jamais plus courtes que leur version basée sur les boucles. L'inverse de ce défi serait certainement un défi dans Octave pour les flics.

— Sanchises

@StewieGriffin Je ne sais pas si le ping dans le chat a fonctionné, au fait, mais l4m2vous a battu.

— Sanchises

2

Python 3 , 75 octets, craqué par 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}))

Essayez-le en ligne!

Les fameux numéros de Hamming, alias numéros à 5 lisses ( A051037 ).

Solution fissurée, 51 octets

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

Essayez-le en ligne!

Solution prévue, 74 octets

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

Essayez-le en ligne!

— Bubbler
source

Fissuré?

— xnor

2

Forth (gforth) , 39 octets, craqué par NieDzejkob

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

Essayez-le en ligne!

— jmarkmurphy
source

1

Vous êtes autorisé à utiliser des séries entières différentes de celles que [1,2,...,n]vous connaissez, n'est-ce pas?

— Sanchises

Cracked

— NieDzejkob

J'y ai pensé parce que la fissure n'est qu'à une recherche google pour les boucles comptées à l'aide de. Mais vraiment, tout ce qui se trouve à l'intérieur de la fonction peut être facilement recréé à l'intérieur de la boucle.

— jmarkmurphy

2

Röda , 40 octets

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

Essayez-le en ligne!

Cette fonction donne la séquence finie suivante (les 90 premiers nombres 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

Je sais que cela peut générer plus de nombres de Fibonacci, mais aux fins de ce défi, il suffit de produire ces nombres.

— fergusq
source

1

JavaScript (Node.js) , 91 octets, fissuré par 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]

Essayez-le en ligne!

Imprime les n premiers termes de la séquence OEIS A022559 (à partir de i = 1).

l4m2 fit 3 pour les boucles dans 74 72 octets et a craqué mon poste de flic:

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

Cependant, ma réponse prévue n'a en fait que 2 pour les boucles:

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

Essayez-le en ligne!

— Shieru Asakoto
source

piraté

— l4m2

@ l4m2 En fait, j'en ai un de 73 octets;) Bref bravo

— Shieru Asakoto

Allez jouer au golf C'est maintenant 72 @ user71546

— l4m2

1

Fonction x86 .COM, 12 octets, fissurée par 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

Entrée DX, sortie [DI] ~ [DI + 2 * DX-1]

Solution de 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

Solution envisagée:

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

— l4m2
source

Cracked

— NieDzejkob

J'ai changé la méthode de sortie. Pouvez-vous regarder?

— NieDzejkob

1

Python 3 , 62 octets, fissuré par mwchase

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

Essayez-le en ligne!

J'ai l'impression que celui-ci va être trop facile ...

La séquence est la séquence de Fibonacci f(n) = f(n-1) + f(n-2)avecf(0) = f(1) = 1

— PunPun1000
source

Vous pouvez passer à une instruction ternaire en ligne composée d'opérateurs booléens, ce qui la place dans une instruction, qui peut ensuite aller directement après les deux-points. Enregistre au moins huit octets.

— mwchase

Passer à lambda en économise deux (EDIT: quatre) de plus.

— mwchase

2

@mwchase, bien que j'apprécie vos suggestions et que je les garde à l'esprit pour les futures soumissions de golf en code python, je ne jouerai pas une soumission de flics et de voleurs pour deux raisons. Tout d'abord, si je continue à jouer au golf, il fixe une cible mobile pour le voleur, ce qui n'est pas souhaité dans ce type de poste. Deuxième golf, cela signifierait que je devrais également jouer à ma version itérative, ce que je ne pourrais peut-être pas faire dans la même mesure

— PunPun1000

cracké

— mwchase

1

Gol> <> , 15 octets, craqué par mbomb007

I1AZZ;
M:K:?ZNB

Essayez-le en ligne!

La série est 0,1,2,3,4,5mais chaque élément est suivi par autant de 0.

Par exemple, les premières valeurs sont:

 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.

— Jo King
source

Cracked

— mbomb007

0

JavaScript, 63 octets, fissuré

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

Essayez-le en ligne!

Renvoie les n premiers éléments d'un tableau inversé

— fəˈnɛtɪk
source

Cracked

— l4m2

Le retour de tableau inversé semble actuellement non autorisé

— l4m2

0

Windows .BAT, 80 octets

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

Usage:

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

La version de la boucle peut supposer dans le dictionnaire actuel, mais doit initialiser ou réinitialiser

— l4m2
source

0

Python, 82 octets; fissuré

Il s'agit d'une implémentation Python récursive de la séquence OEIS A004001 en 82 octets. Vous trouverez plus d'informations sur cette série sur Mathworld de 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]]

Les 30 premiers nombres de cette séquence sont:

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

— toujours
source

Cracked

— l4m2

Ce défi concerne la récursivité (fil des flics)

Fil de flics

Synopsis du défi

Conditions de soumission

Récursivité

Python 3 , 65 octets (sûr)

Solution prévue, 58 octets

Octave , 47 octets, fissuré par l4m2

Python 3 , 75 octets, craqué par xnor

Solution fissurée, 51 octets

Solution prévue, 74 octets

Forth (gforth) , 39 octets, craqué par NieDzejkob

Röda , 40 octets

JavaScript (Node.js) , 91 octets, fissuré par l4m2

Fonction x86 .COM, 12 octets, fissurée par NieDzejkob

Python 3 , 62 octets, fissuré par mwchase

Gol> <> , 15 octets, craqué par mbomb007

JavaScript, 63 octets, fissuré

Windows .BAT, 80 octets

Python, 82 octets; fissuré