Il s'agit d'un défi pour les flics et les voleurs. Ceci est le fil du voleur. Le fil du flic est ici .

Les flics choisiront n'importe quelle séquence de l' OEIS et écriront un programme p qui imprime le premier entier de cette séquence. Ils trouveront aussi quelques cordes s . Si vous insérez s quelque part dans p , ce programme doit imprimer le deuxième entier de la séquence. Si vous insérez s + s au même emplacement dans p , ce programme doit imprimer le troisième entier de la séquence. s + s + s au même emplacement imprimera le quatrième, et ainsi de suite. Voici un exemple:

Python 3, séquence A000027

print(1)

La chaîne masquée fait deux octets .

La chaîne est +1, car le programme print(1+1)imprimera le deuxième entier dans A000027, le programme print(1+1+1)imprimera le troisième entier, etc.

Les flics doivent révéler la séquence, le programme original p et la longueur de la chaîne cachée s . Les voleurs déchirent une soumission en trouvant n'importe quelle chaîne jusqu'à cette longueur et l'emplacement pour l'insérer pour créer la séquence. La chaîne n'a pas besoin de correspondre à la solution prévue pour être une fissure valide, pas plus que l'emplacement où elle est insérée.

Si vous déchiffrez l'une des réponses des flics, postez votre solution (avec la chaîne et l'emplacement cachés révélés) et un lien vers la réponse. Ensuite, commentez la réponse des flics avec un lien vers votre crack ici.

Règles

• Votre solution doit fonctionner pour n'importe quel nombre dans la séquence, ou au moins jusqu'à une limite raisonnable où elle échoue en raison de restrictions de mémoire, de débordement d'entier / de pile, etc.

• Le voleur gagnant est l'utilisateur qui fissure le plus de soumissions, le bris d'égalité étant celui qui a atteint ce nombre de fissures en premier.

• Le flic gagnant est le flic avec la plus courte chaîne s qui ne sont pas fissurés. Tiebreaker est le plus court p . S'il n'y a pas de soumissions non fissurées, le flic qui avait une solution non fissurée pour les plus longues victoires.

• Pour être déclarée sûre, votre solution doit rester non fissurée pendant 1 semaine, puis révéler la chaîne cachée (et l'emplacement pour l'insérer).

• s ne peuvent pas être imbriqués, ils doivent être enchaînés de bout en bout. Par exemple, si s était 10, chaque itération irait 10, 1010, 101010, 10101010...plutôt que10, 1100, 111000, 11110000...

• Toutes les solutions cryptographiques (par exemple, vérifier le hachage de la sous-chaîne) sont interdites.

• Si s contient des caractères non ASCII, vous devez également spécifier le codage utilisé.

Python 2 , séquence A138147 par xnor

Original:

print 10

Fissuré:

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

Essayez-le en ligne!

Brain-Flak , A000984 par Nitrodon

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

Ce n'est que 30 octets, je ne sais pas ce que Nitrodon avait en tête.

Essayez-le en ligne!

Explication

J'ai essayé beaucoup de choses mais voici ce qui a fonctionné. Les termes de A000984 sont les éléments centraux du triangle de Pascal.

Maintenant, j'ai compris que je pouvais les obtenir en additionnant les diagonales au-dessus d'eux:

Par exemple:

$1+3+6+10 = 20$

Et puisque la dernière action dans le programme de Nitrodon est de résumer tout cela, ils semblaient être un bon candidat (plus comme j'ai essayé un tas de choses mais celui-ci a fini par fonctionner).

Nous voulons donc un programme qui prend une somme partielle et produit la suivante. Heureusement, il existe un moyen assez soigné de passer de l'un à l'autre. Chaque ligne correspond aux deltas de la ligne suivante. C'est le $n$ ème terme dans une rangée, c'est la différence entre les $n$ ème et $n-1$ ème termes dans la ligne suivante.

Le seul problème est que nous n'avons pas tout à fait assez de la dernière ligne pour calculer la ligne que nous voulons. Étant donné que chaque ligne est plus longue que la dernière si nous avons une ligne, nous ne pouvons pas obtenir le dernier membre de la ligne suivante avec cette méthode. Cependant, nous avons ici une autre astuce, le dernier membre de chaque ligne est égal à tous les membres précédents de cette ligne!

$1+3+6=10$

Et si vous connaissez Brain-Flak, cela devrait vous sembler très facile à faire.

Maintenant pour le code:

Pour commencer, nous faisons le calcul de la ligne suivante où chaque nouveau membre est la somme de deux anciens membres adjacents. Cela peut se faire avec:

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

Ce qui déplace fondamentalement un élément et ajoute (sans suppression) ce qui a déjà été dessus. Cependant, cela inverse tout, donc pour la prochaine fois que nous aurons une rangée, nous devons la remettre.

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

Maintenant, nous devons calculer le dernier membre de la ligne. Comme je l'ai déjà dit, c'est super facile. Comme nous avions une boucle sur tous les éléments de la ligne, nous pouvons simplement prendre cette somme et la pousser. Nous le poussons avant la deuxième boucle pour qu'il se retrouve en bas.

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

Et c'est tout.

Brain-Flak, A000290 , par Sriotchilism O'Zaic

Original:

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

Fissuré:

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

Essayez-le en ligne!

Alternativement:

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

Essayez-le en ligne!

MATL , séquence A005206 de Luis Mendo

Original:

voOdoO

Essayez-le en ligne!

Fissuré:

voOdoOdNq17L/k
      ^^^^^^^^

Je ne suis pas un expert MATL, mais d'après ce que je comprends, l'original voOdoOcrée deux tableaux vides et un tableau [0]sur la pile. c'est [0]ce qui s'imprime sans crochets comme premier élément de la séquence. La fissure / solution fait alors ce qui suit:

• dprend un élément de la pile et (en supposant qu'il s'agit d'un nombre ou d'un tableau de taille 1) le transforme en un tableau vide. Ces tableaux vides ne sont pas imprimés, mais contribuent à la taille de la pile
• Nqcompte la taille de la pile et en soustrait une. C'est le n+1terme lors de l'évaluation de la fonction (car elle commence à 2 et augmente d'une unité à chaque itération en raison de l' dajout de choses invisibles à la pile)
• 17L c'est la constante Phi = (1+sqrt(5))/2
• /kce floor((n+1)/Phi)qui est l'une des formules qui calcule les éléments de la séquence. Cette formule est répertoriée sur OEIS, a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2sauf que nous utilisons l'identité(sqrt(5)-1)/2 = 1/Phi

Python 3 - A__

print(100+-1)

Essayez-le en ligne!

100 bouteilles de bière, ajoutez -1pour obtenir le numéro suivant 99, etc.

Keg , séquence A000045 , par A__

Original:

0.

Fissuré:

01":&+.
 ^^^^^

Notez que le défi consistait à trouver une sous-chaîne de longueur <= 6, mais la chaîne trouvée a une longueur de 5.

Définition des commandes pour ceux qui sont trop paresseux pour rechercher la spécification Keg: 0et 1poussez le numéro respectif dans la pile; "déplace le haut de la pile vers le bas de la pile (rouleau); &ouvre le haut de la pile dans le registre s'il est vide, sinon vide le registre sur la pile; +ajoute les deux premières valeurs de pile.

L'initiale 1"insère juste un 1 au bas de la pile. Cette liste croissante de 1 ne joue un rôle que dans la première itération, où elle nous permet de supposer que la pile commence 1 0plutôt que juste 0. En effet, le programme10:&+. , où la :&+pièce est répétée, a exactement le même comportement que la solution ci-dessus, sauf qu'il n'a pas de liste croissante de 1 en bas.

Étant donné qu'il &n'est utilisé qu'une seule fois dans la partie répétitive et a un comportement alternatif, le comportement de1":&+ dépend de la parité de l'itération.

Maintenant, ce programme n'imprime pas vraiment la séquence de Fibonacci commençant par 0, 1 depuis le début; il imprime en fait la séquence 1, 0 de Fibonacci à partir de la deuxième place, c'est-à-dire à partir du 0. (Il en résulte la même séquence.) Sachant cela, le programme est facilement analysé:

• Dans la première, troisième, ... itération, l'état commence comme [a, b]et se termine comme a+b (&=b).
• Dans la deuxième, quatrième, ... itération, l'état commence comme [b] (&=a)et se termine comme [b, b+a].

Cela calcule en effet la séquence comme requis.

Java 8+, séquence A010686 par Benjamin Urquhart

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

Brain-Flak, A000578 par Sriotchilism O'Zaic

Original:

((())<>)

Essayez-le en ligne!

Fissuré:

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

Essayez-le en ligne!

Pyret , séquence A083420 , par MLavrentyev

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

Vous pouvez l'exécuter ici, mais je n'ai pas compris comment créer un lien vers le code. Vous devrez copier-coller.

La fonction fournie ignore son deuxième argument. Il double son premier et en ajoute un, ce qui générera la 2^n - 1séquence nécessaire nécessaire ici - tout ce que je dois faire est de lui dire combien de fois effectuer cette opération, en changeant la longueur de la liste pliée. Heureusement, Pyret ne se plaint pas de cette virgule de fin.

Python 3 , séquence A268575 par NieDzejkob

Original:

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

Cracké (100 octets):

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

Essayez-le en ligne!

D'après ce que je peux rassembler, le code d'origine définit des définitions pour rendre la chaîne cachée aussi abrégée que possible, puis définit le modèle initial de Game of Life. La chaîne cachée équivaut alors à écrire une itération de Game of Life de Conway en 102 octets.

Aux fins de cette fissure, Sest une fonction qui additionne les éléments dans ses arguments (qui sont des itérables) et Fapplique une fonction renvoyant un itérable à chaque élément d'une liste et écrase tous les résultats ensemble.

• ;A=-1,1,0;termine l'instruction précédente et abrège le tuple (-1,1,0) par A, qui est utilisé comme product(A,A)ce qui donne tous les voisins par rapport à une cellule donnée ainsi que la cellule elle-même.
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);crée une nouvelle liste Xcontenant tous les voisins des cellules Wet les cellules en Welles-mêmes en ajoutant les positions relatives des voisins à chaque cellule et en les brisant ensemble dans une liste.
• W={p for p in X if 2<X.count(p)<4+({p}<W)}parcourt cette liste Xet détermine si chaque cellule dans Xappartient à l'ensemble de cellules dans la prochaine itération. Cela a été tiré presque mot pour mot de ce golf Game of Life .

Haskell, A014675 par Khuldraeseth na'Barya

Code d'origine

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

Avec sous-chaîne

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

Essayez-le en ligne!

Calculatrice de bureau, A006125 , par A__

Original:

1n

Fissuré:

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

Essayez-le en ligne!

Mise en œuvre simple.

cQuents , séquence A003617 par Stephen

=10#2:pZ
  ^

Essayez-le en ligne!

Commencez par le plus petit nombre à n + 1 chiffres, un suivi de n zéros. Le #2spécifie que seul le deuxième terme de la séquence, qui est la définition de séquence appliquée une fois à la graine, sera imprimé; cette définition de séquence trouve simplement et renvoie le premier nombre premier.

Python 3 - agtoever

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)

Essayez-le en ligne!

MATL , séquence A000796 de Luis Mendo

Original:

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

Essayez-le en ligne!

Fissuré:

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

L'auteur original a créé sournoisement le tableau [-7:-1] , puis extrait et annulé le premier élément à obtenir 7. Il a ensuite utilisé cela pour obtenir le 7ème chiffre arrondi de pi (qui est 3) et l'a présenté comme le premier chiffre de pi. L'ajout |SQrend le tableau d'origine tout positif, le trie et en ajoute un à tout. Cela signifie qu'après tout, au lieu d'obtenir l'index, 7il obtient l'index -2après une application, -3après deux applications, etc. Le -est important car il indique à la Y$fonction de ne pas arrondir les chiffres.

Forth (gforth) , A000042 , par NieDzejkob

.( 1)1 .
^^^^^

Essayez-le en ligne!

Le 1 octet trivial étend simplement le littéral. Le problème est que celui-ci déborde de 64 bits dès le dix-neuvième chiffre. La solution facile consiste à imprimer le chiffre unique à plusieurs reprises, non? Oui, mais ce n'est pas si simple. Bien virer1 . à la fin imprimera en effet les chiffres supplémentaires dont nous avons besoin, ils seront séparés par des espaces. Ça ne marchera pas.

Maintenant, selon Wikipedia, " .((point-paren) est un mot immédiat qui analyse une chaîne délimitée par des parenthèses et l'affiche." Heureusement, cet affichage n'a pas d'autres caractères étranges, donc utiliser .(pour imprimer un seul 1 devrait suffire. Et c'est le cas. Aucun espace n'est nécessaire après la parenthèse rapprochée, de sorte que ces cinq caractères (il y a un espace après la parenthèse ouverte) peuvent être répétés à notre guise. Pour démontrer, j'ai inclus dans TIO un exemple qui aurait débordé plusieurs fois un entier 64 bits. Fonctionne comme un charme.

Unefunge-98 (PyFunge) , séquence A000108 , par NieDzejkob

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

Essayez-le en ligne!

Répété six fois

Deux octets de rechange sur les dix-neuf autorisés! Ce qui semble être un espace, il y a en fait un caractère de début d'en-tête 0x01.

Explication:

Ce défi consiste à générer à a(n)partir de a(n-1)et peut-être n. OEIS fournit la formule explicite a(n) = (2n)!/(n!(n+1)!), qui est assez facilement convertie ena(n) = a(n-1) * (4n-6) / n . Maintenant, pour implémenter cela dans Funge.

Je dois insérer du code entre le 1et le .. C'est déjà la moitié du puzzle déjà fait. Tout ce qui reste est quel code insérer? Funge manque notamment d'outils de manipulation de pile, donc le bas de la pile est hors limites; J'ai besoin de suivre les deux neta(n) sans augmenter la pile. Et comment faire mieux qu'avec l'espace Funge?

Ce caractère 0x01 est mon compteur n. Je garde a(n)la pile, car elle doit l'être sur la pile une fois que mon bit a fini de s'exécuter.

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 par tsh

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

Essayez-le en ligne!

V, A000290 , par DJMcMayhem

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

renvoie les carrés à partir de 1.

Essayez-le en ligne!

La base é*insère *et Ø.compte le nombre de caractères non-retour à la ligne dans le tampon entier. L'insertion Äduplique la ligne supérieure sur sa propre ligne, sur laquelle 2é*s'insère **. Les concaténations des insertions produisent des nombres impairs successifs avec le plus grand en haut. La finale Ø.additionne en fait les n premiers nombres impairs, ce qui donne le n-ième carré.

AsciiDots , séquence A019523 par Alion

\ +++ /
// \ / \

Une fois que!

Deux fois!

Dix fois!

Tout en essayant de comprendre comment fonctionne le code / langage, j'ai appris que les deux premières lignes du code existant font tout le travail de sortie de la séquence de Fibonacci à l'infini. Le code se termine lorsque n'importe quel point atteint le &, j'ai donc simplement eu besoin d'ajouter un délai supplémentaire dans les lignes restantes pour permettre le nombre approprié d'entrées à produire.

Après quelques essais, erreurs et observations, j'ai découvert que l'intervalle de retard correct était de 16 unités de temps par nombre. Monter suffisamment de caractères sur une seule ligne semblait irréalisable, donc je devrais mettre le retard sur 2 lignes, laissant 10 caractères pour le retard réel. Pour que le motif corresponde à lui-même, les deux lignes devaient avoir 5 caractères, et comme les trois caractères du milieu d'une ligne peuvent être parcourus deux fois, cela donne 16 unités de temps comme souhaité.

L'obligation de faire correspondre cela &à la huitième colonne semblait rendre cela impossible, jusqu'à ce que je réalise que je pouvais commencer avec une nouvelle ligne à l'intérieur de la troisième rangée. Cela rend l'avant-dernière ligne de la bonne longueur et supprime l'extrémité désormais redondante de la troisième ligne.

Brachylog , séquence A114018 par Unrelated String

Programme original:

≜ṗ↔ṗb&w

Chaîne à insérer:

≜ṗ↔ṗẹbb&w
    ^^

Essayez-le en ligne!

Explication

Voici d'abord l'explication du programme d'origine (sachant que la séquence utilisée est "le moins premier nombre à n chiffres dont l'inversion du chiffre est aussi premier")

≜         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

Comme vous pouvez le voir, le programme est assez simple, sauf pour une chose: il existe un b - beheadappel de prédicat complètement inutile , qui supprime le premier élément de l'inverse de notre numéro, avec lequel nous ne faisons rien.

Ceci est un indice précis sur la façon dont nous pouvons trouver la chaîne. L'idée est que, puisque nous voulons augmenter la longueur du nombre de 1 chiffre chaque fois que nous ajoutons la chaîne, nous avons besoin d'une chaîne qui "évalue" la longueur de ce nombre d'une manière ou d'une autre, en utilisant celle-ci inutile b.

La solution consiste à utiliser ẹb: premièrement, ẹ - elementstransformera le numéro en une liste de chiffres; puis, b - beheadsupprimera son premier élément. L'astuce est que bcela échouera si la liste des chiffres est vide. Ainsi, chaque fois que nous ajoutons un b, nous augmenterons la longueur du nombre requis de 1 (car il échouera jusqu'à ce que la valeur assignée de ?soit suffisamment élevée pour contenir suffisamment de chiffres pour que le dernier bsoit appliqué sur une liste à un chiffre).

Réappliquer à ẹchaque fois n'a aucun effet car c'est déjà une liste de chiffres. Nous n'en avons besoin qu'une seule fois au début car si nous décapitons un nombre comme 9001au lieu de la liste de ses chiffres, nous obtiendrons 001 = 1qui perdra des informations sur le nombre de chiffres.

VDM-SL , A000312 , par données expirées

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

Étant donné que les expressions de VDM-SL letpeuvent relier des variables qui sont déjà liées dans une étendue englobante, x**xpeuvent être évaluées de manière arbitrairement profondément imbriquée dans des étendues dans lesquelles xest une de plus que dans l'étendue précédente, tandis que l'original xest toujours inférieur à la cardinalité de m(1).

Haskell, A083318 par xnor

f=length     [2]
        $show

Essayez-le en ligne!

Haskell , A000045 (Fibonacci) , par transformée de Fourier de Rin

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

Essayez-le en ligne!

23 octets exactement.

Celui-ci était amusant et un peu délicat. Le 0 et le 1 inversés m'ont un peu déstabilisé avant de réaliser que ce n'était pas un problème. L'absence de $l'original m'a obligé à essayer des trucs sommaires comme $...$id(un octet de trop) avant qu'il ne me vienne à l'esprit que je pouvais tout emballer entre parenthèses. Dans l'ensemble, un joli petit puzzle.

H.PWiz souligne que la correspondance de modèles aurait pu me faire économiser au moins cinq octets:$(\[x,y]->[y,x+y]) . Ce sacré défi sans point m'a fait penser sans point partout.