In un incidente molto insolito che coinvolge un piccolo campione di radio, una balena fulminata e tre orsetti gommosi, alcuni dei codici sorgente di The Management ™ sono stati mutati. Il padrone di The Management ™ non lo sa, in realtà erano i poliziotti a essere responsabili, nel tentativo di contrastare i piani "malvagi" di The Management ™. Quindi i Robbers® sono stati assunti nel tentativo di recuperare il codice originale, perché a volte a chi non piace essere cattivo?

nota: questa sfida è stata fortemente ispirata da Decodificare il codice sorgente .

Descrizione

Questa è una sfida per poliziotti e ladri .

• I poliziotti scriveranno un programma (il codice mutato) che esegue l'attività n. 1 (e scriverà anche un programma che esegue l'attività n. 2, ma è tenuto segreto).
• I ladri tenteranno di invertire la "mutazione" e di modificare questo codice originale in codice che esegue l'attività n. 2.

In questa sfida, il compito n. 1 sarà quello di produrre il nnumero primo , e il compito n. 2 sarà quello di produrre il nnumero di Fibonacci (che è in qualche modo malvagio, secondo comunque i poliziotti). La sequenza di Fibonacci è definita come ( n=1→ 1; n=2→ 1; n=3→ 2; ...), mentre i numeri primi sono definiti come ( n=1→ 2; n=2→ 3; n=3→ 5; ...).

L'obiettivo dei poliziotti è ridurre al minimo la differenza tra i programmi che completano l'attività n. 1 e l'attività n. 2, impedendo ai ladri di ricreare il codice che completa l'attività n. 2.

Regole della polizia

I poliziotti scriveranno due programmi (uno che completa l'attività n. 1 e uno che completa l'attività n. 2) e renderanno pubbliche le seguenti informazioni:

• Il primo programma (che genera il nprimo numero primo)
• Il Levenshtein modifica la distanza tra il primo programma e il secondo programma
• Il linguaggio di programmazione in cui sono scritti entrambi i programmi (deve essere la stessa lingua per entrambi i programmi)

Le seguenti restrizioni si applicano ad entrambi i programmi:

• Devono contenere almeno 128 caratteri.
• Devono utilizzare solo ASCII stampabile (oltre a nuove righe, che sono anche consentite).
• Devono richiedere meno di 10 secondi per essere eseguiti n=45e non sono tenuti a produrre l'output corretto per nessuno n>45.
• Non devono utilizzare alcuna funzione di hashing o crittografia.

Regole rapinatore

Il ladro tenterà di cambiare il programma del poliziotto (che completa l'attività n. 1) in un programma che completa l'attività n. 2 (non necessariamente il programma originale scritto dal poliziotto) nella distanza di modifica specificata dal poliziotto.

Una sottomissione già decifrata non può essere nuovamente decifrata (solo il primo ladro che rompe una sottomissione ottiene credito).

Dopo aver infranto una richiesta, procedi come segue:

• Pubblica una risposta alla domanda di accompagnamento di questa sfida (link) , fornendo la lingua, la tua soluzione e un link alla risposta originale.
• Lascia un commento con il testo "Cracked" che rimanda alla tua risposta postata.
• Modifica la risposta del poliziotto se hai i privilegi di modifica (in caso contrario, aspetta fino a quando qualcun altro con i privilegi richiesti lo fa per te o suggerisci una modifica).

punteggio

Se il programma di un poliziotto rimane senza crack per 1 settimana, il poliziotto può pubblicare il codice originale che completa l'attività n. 2 (nella distanza di modifica specificata) e l'invio da quel momento in poi è considerato "sicuro". Vincerà l'invio sicuro con la minima distanza di modifica. In caso di pareggio, vince il programma più breve (l'originale che completa l'attività n. 1). Se due invii sono ancora in parità, vince quello pubblicato in precedenza.

Se un ladro rompe con successo l'invio di un poliziotto, il punteggio del ladro aumenta della distanza di modifica di tale invio. Ad esempio, un ladro che rompe un invio con una distanza di modifica di 3 e uno con una distanza di 5 guadagna 8 punti. Vince il ladro con il punteggio più alto. In caso di pareggio, vince il ladro che ha guadagnato il punteggio.

Classifica

1. Ruby, 6 (istocratico)

Un piccolo strumento per calcolare la distanza di 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 [ cracking ]

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]

Finalmente ho ottenuto questo sotto il limite di caratteri. Non dovrebbe essere troppo difficile, ma ho pensato che l'idea fosse interessante.

Soluzione prevista:

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'idea era di usarlo F(n+2) = 1 + (sum over F(k) from k = 1 to n)e il fatto che i numeri consecutivi di Fibonacci sono coprimi. L' 1argomento nel ridurre doveva fornire il+1 .

Sembra che Feersum abbia trovato una diversa linea di attacco!

J, distanza = 5 [ Cracked ]

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

Uso:

> f 45
197

Rubino, distanza 6 [sicuro]

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

Presentare coppie di formule con brevi distanze di modifica è divertente, ma sembra che questo approccio potrebbe essere più efficace / fastidioso. Puoi capire esattamente cosa ho fatto, ma ciò non significa che puoi invertirlo.

Soluzione:

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

Spiegazione:

Il codice genera il rapporto aureo con 11 cifre decimali e lo utilizza per calcolare direttamente la sequenza di Fibbonaci. È sufficiente la precisione per ottenere correttamente il numero di termini richiesto. Quella parte non era affatto offuscata, se ti capita di conoscere la formula. Per rendere più difficile invertire la forza delle mie mutazioni e recuperare la costante, ho usato la notazione ottale (il primo 0) e la notazione scientifica (4e10). La divisione per 4e10 anziché 1e11 fa sembrare che stia dividendo qualcosa .0per forzare la divisione float, quando in realtà qualsiasi cosa in notazione scientifica è per qualche motivo sempre Float in Ruby, anche quando un Bignum potrebbe sembrare più sensato. Pensavo di essere intelligente con le p=cose, ma il modo in cui le ho scritte puoi semplicemente eliminare p. Potrei'p=usandop&& invece di# sulla seconda riga, ma non ci ho pensato.

Python 2 - LD = 13 Incrinato

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 bello, facile (speriamo non troppo facile) per iniziare le cose :)

Sembra che sia stato troppo facile;) Mi sento piuttosto sciocco che ho dimenticato che potresti usare i commenti: /

Haskell, distanza = 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

Questo potrebbe essere più leggibile, ma importho mangiato troppi byte, quindi ho dovuto giocare un po 'a golf.

Rubino, distanza 14 ( Cracked )

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

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

Basta mettere nsu STDIN. Provalo qui.

Per riferimento, la soluzione originale utilizzava il raro j .

Originale:

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

J, distanza = 4 [sicuro]

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

Soluzione:

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

Metodo:

Denominatore {. 2(x:)della frazione continua (+%)1 + 1 / (... (1 + 1 / (1 + 1 / (1 + 1 / (1))))).

Python 3, distance = 14 [ cracking ]

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)

Avevo dei caratteri di riserva quindi ho messo degli spazi bianchi per chiarezza :)

JAGL Alpha 1.2 - Distance = 16 [ Cracked ]

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

Non dovrebbe essere troppo difficile, vedremo cosa succede ...

TI-BASIC , distanza 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

>rappresenta la STO→chiave e $rappresenta il simbolo della radice quadrata.

Python 2 - distance = 12 [ Cracked ]

Sono abbastanza contento di come sia andata a finire.

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

Vediamo quanto ci vorrà ... Presumo che sarà ancora rotto.

Modificare: accorcia un po 'il codice, nessun effetto sul funzionamento / distanza.

Soluzione prevista

Ho provato a non fare commenti o modifiche a newline.

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

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)

Vedremo quanto dura questo ...