Dans un accident très inhabituel impliquant un petit échantillon de radium, une baleine électrocutée et trois oursons gommeux, une partie du code source de The Management ™ a été mutée. Le patron de The Management ™ ne sait pas grand chose, ce sont en fait les Cops © qui étaient responsables, dans une tentative de déjouer les plans "diaboliques" de The Management ™. Les Robbers® ont donc été embauchés pour tenter de récupérer le code d'origine, car qui n'aime pas être méchant parfois?

note: Ce défi a été fortement inspiré par Déchiffrer le code source .

La description

C'est un défi de flics et de voleurs .

• Les flics écriront un programme (le code muté) qui exécute la tâche # 1 (et écrit également un programme qui exécute la tâche # 2, mais qui est gardé secret).
• Les voleurs tenteront d'inverser la "mutation" et de changer ce code d'origine en code qui exécute la tâche n ° 2.

Dans ce défi, la tâche n ° 1 consistera à sortir le ne nombre premier , et la tâche n ° 2 à sortir le nth nombre de Fibonacci (ce qui est en quelque sorte mauvais, selon les Cops © de toute façon). La séquence de Fibonacci est définie comme ( n=1→ 1; n=2→ 1; n=3→ 2; ...), et les nombres premiers sont définis comme ( n=1→ 2; n=2→ 3; n=3→ 5; ...).

Le but des flics est de minimiser la différence entre les programmes qui terminent la tâche # 1 et la tâche # 2, tout en empêchant les voleurs de recréer le code qui termine la tâche # 2.

Règles de la police

Les flics écriront deux programmes (l'un qui termine la tâche n ° 1 et l'autre qui termine la tâche n ° 2) et rendront publiques les informations suivantes:

• Le premier programme (qui sort le ne nombre premier)
• La distance d'édition de Levenshtein entre le premier programme et le deuxième programme
• Le langage de programmation dans lequel les deux programmes sont écrits (doit être le même langage pour les deux programmes)

Les restrictions suivantes s'appliquent aux deux programmes:

• Ils doivent comporter 128 caractères au maximum.
• Ils doivent uniquement utiliser ASCII imprimable (plus les retours à la ligne, qui sont également autorisés).
• Ils doivent prendre moins de 10 secondes pour fonctionner n=45, et ils ne sont pas tenus de produire la sortie correcte pour tout n>45.
• Ils ne doivent utiliser aucune fonction de hachage ou de cryptographie.

Règles de voleur

Le voleur tentera de changer le programme du flic (qui termine la tâche n ° 1) en un programme qui termine la tâche n ° 2 (pas nécessairement le programme d'origine écrit par le flic) dans la distance d'édition spécifiée par le flic.

Une soumission déjà craquée ne peut plus être craquée (seul le premier voleur qui déchire une soumission obtient un crédit).

Après avoir craqué une soumission, procédez comme suit:

• Publiez une réponse à la question d'accompagnement de ce défi (lien) , en fournissant la langue, votre solution et un lien vers la réponse d'origine.
• Laissez un commentaire avec le texte "Cracked" qui renvoie à votre réponse publiée.
• Modifiez la réponse du policier si vous disposez de privilèges de modification (sinon, attendez que quelqu'un d'autre disposant des privilèges requis le fasse pour vous ou suggérez une modification).

Notation

Si le programme d'un flic reste non fissuré pendant 1 semaine, le flic peut publier le code d'origine qui termine la tâche n ° 2 (dans la distance de modification spécifiée), et la soumission est désormais considérée comme "sûre". La soumission sûre qui a la plus petite distance d'édition gagnera. En cas d'égalité, le programme le plus court (l'original qui termine la tâche n ° 1) l'emporte. Si deux soumissions sont toujours à égalité, celle publiée plus tôt l'emporte.

Si un voleur réussit à déchiffrer la soumission d'un flic, le score du voleur augmente de la distance d'édition de cette soumission. Par exemple, un voleur qui déchiffre une soumission avec une distance d'édition de 3 et un avec une distance de 5 gagne 8 points. Le voleur avec le score le plus élevé gagne. En cas d'égalité, le voleur qui a obtenu le premier score l'emporte.

Classement

1. Ruby, 6 (histocrate)

Un petit outil pour calculer la distance Levenshtein

var f=document.getElementById("f"),g=document.getElementById("s"); function h(){var a=f.value,e=g.value;if(128<a.length)a="<span style='color:red'>First program is too long!</span>";else if(128<e.length)a="<span style='color:red'>Second program is too long!</span>";else{if(0===a.length)a=e.length;else if(0===e.length)a=a.length;else{var d=[],b;for(b=0;b<=e.length;b++)d[b]=[b];var c;for(c=0;c<=a.length;c++)d[0][c]=c;for(b=1;b<=e.length;b++)for(c=1;c<=a.length;c++)d[b][c]=e.charAt(b-1)===a.charAt(c-1)?d[b-1][c-1]:Math.min(d[b-1][c-1]+1,Math.min(d[b][c-1]+1,d[b-1][c]+ 1));a=d[e.length][a.length]}a="Distance = <strong>"+a+"</strong>"}document.getElementById("d").innerHTML=a}f.onkeyup=h;g.onkeyup=h;

<h3 id=ft>First program</h3>
<textarea id=f rows=7 cols=80 style="width:100%"></textarea>
<h3 id=st>Second program</h3>
<textarea id=s rows=7 cols=80 style="width:100%"></textarea>
<p id=d></p>

Python 2, distance = 8 [ fissuré ]

from fractions import*
n=input()
k,=P=[2]
while n>len(P):k+=1;z=reduce(lambda x,y:x*y,P,1);P+=[k]*(gcd(z,k)<2)
print P[-1]

A finalement obtenu celui-ci sous la limite de char. Ça ne devrait pas être trop dur, mais j'ai trouvé l'idée intéressante.

Solution envisagée:

from fractions import* n=input() k,=P=[1] while n>len(P):k+=1;z=reduce(lambda x,y:x+y,P[:-1],1);P+=[z]*(gcd(z,k)<2) print P[-1]

L'idée était d'utiliser cela F(n+2) = 1 + (sum over F(k) from k = 1 to n), et le fait que les nombres de Fibonacci consécutifs soient coprimes. L' 1argument de réduction était censé fournir le +1.

On dirait que feersum a trouvé une ligne d'attaque différente!

J, distance = 5 [ fissuré ]

f=:3 :'{.p:|.i.y'

Usage:

> f 45
197

Rubis, distance 6 [sûr]

require'prime';p Prime.take(n=gets.to_i)[-1]
#p (((807462154311276410)**n/(5**0.5)).round)

Trouver des paires de formules avec de courtes distances d'édition est amusant, mais il semble que cette approche pourrait être plus efficace / ennuyeuse. Vous pouvez comprendre exactement ce que j'ai fait, mais cela ne signifie pas que vous pouvez l'inverser.

Solution:

require'prime';p=Prime.take(n=gets.to_i)[-1] p (((0742154311276/4e10)**n/(5**0.5)).round)

Explication:

Le code génère le Golden Ratio à 11 décimales et l'utilise pour calculer directement la séquence de Fibbonaci. C'est juste assez de précision pour obtenir le bon nombre de termes requis. Cette partie n'a pas été obscurcie du tout, si vous connaissez la formule. Pour rendre plus difficile la force brute d'inverser mes mutations et récupérer la constante, j'ai utilisé la notation octale (le 0 en tête) et la notation scientifique (4e10). Diviser par 4e10 plutôt que 1e11 donne l'impression que je divise par quelque chose .0pour forcer la division flottante, alors qu'en réalité, tout ce qui est en notation scientifique est toujours pour une raison quelconque un flotteur en rubis, même lorsqu'un Bignum peut sembler plus logique. Je pensais que j'étais intelligent avec ce p=truc, mais la façon dont je l'ai écrit, vous pouvez simplement le supprimer p. Je pourrais'p=solution en utilisant p&&au lieu de #sur la deuxième ligne, mais je n'y ai pas pensé.

Python 2 - LD = 13 fissuré

n=1;j=input();
while j>0:
    n+=1;j-=1;
    while~-all(n%i for i in range(2,n)):n+=1;
print n

Un bon, facile (si tout va bien pas trop facile) pour commencer les choses :)

On dirait que c'était trop facile;) Je me sens plutôt idiot d'avoir oublié que vous pouviez utiliser les commentaires: /

Haskell, distance = 13

import Data.List
x=id=<<snd(mapAccumL(\m n->(,)=<<(++m)$[n|and[n`mod`m1/=0|m1<-m]])[1+1][3..])
main=print.(!!)(0:2:x)=<<readLn

Cela pourrait être plus lisible, mais importmangeait trop d'octets, donc j'ai dû jouer un peu au golf.

Rubis, distance 14 ( fissuré )

p [x=2,y=1,*(1..200).map{|i|y==(y*x**(i-1)+x%2).divmod(i)[x-1]?i:1}].-([x-1])[gets.to_i-1]

CJam, distance 10 (fissuré)

1l~{{)_mp!}g}*

Mettez simplement nSTDIN. Testez-le ici.

Pour référence, la solution originale utilisait le rare j.

Original:

T1]l~\{(_j\(j+}j

J, distance = 4 [sûr]

f =: 3 :  '{. (p:) (+) / 0 , y - 1x'

Solution:

f =: 3: «{. 2 (x :) (+%) / 0, y $ 1x '

Méthode:

Dénominateur {. 2(x:)de la fraction continue (+%)1 + 1 / (... (1 + 1 / (1 + 1 / (1 + 1 / (1)))))).

Python 3, distance = 14 [ fissuré ]

n = int(input())
P = [2]
k = 2
while n > len(P):
 k += 1
 for x in P:
  if k%x == 0: break
 else: P += [k]
print(k)

J'avais quelques caractères de rechange donc j'ai mis des espaces pour plus de clarté :)

JAGL Alpha 1.2 - Distance = 16 [ fissuré ]

T~2S]{]S1{D[dmn}wDS}wSP

Ça ne devrait pas être trop dur, nous verrons ce qui se passe ...

TI-BASIC , distance 38

Input N:{2>L1:For(A,3,E99:If min(1=gcd(A,seq(A,A,2,$(A:A>L1(1+dim(L1:End:L1(N

>représente la STO→clé et $représente le symbole de la racine carrée.

Python 2 - distance = 12 [ fissuré ]

Je suis plutôt satisfait de la tournure que cela a pris.

f=lambda p,i:p if p[45:]else f(p+[i]if all(i%q for q in p[1:])else p,-~i)
print f([1,2,3],2)[input()]

Voyons voir combien de temps cela prend ... Je suppose que ce sera toujours fissuré.

Edit: code raccourci un peu, aucun effet sur le fonctionnement / la distance.

Solution envisagée

J'ai essayé de ne demander aucun commentaire ni changement de nouvelle ligne.

f=lambda p,i:p if p[45:]else f(p+[p[i]+p[-2]]if all(i|q for q in p[1:])else p,-~i) print f([1,1,1],2)[input()]

Python 3 - Distance = 14 [ fissuré ]

a,c,n=1,2,int(input())
while n-1:
 c+=1
 while 1!=list(map(c.__mod__,range(2,46))).count(0):
  c,a=a+c,a
 n-=1
print(c)

Nous verrons combien de temps cela dure ...