Per la sfida dei poliziotti principali, clicca qui

AVVISO - Questa sfida è ora chiusa. Eventuali crepe che vengono pubblicate ora non verranno conteggiate nella classifica e la risposta accettata non cambierà.

Sfida

Dato il programma originale, il suo output e l'output del programma modificato, è necessario scoprire quali caratteri devono essere modificati, rimossi o aggiunti per ottenere l'output previsto.

Quando decifri il codice di qualcuno, lascia un commento con un link al tuo crack sulla sua risposta.

Formattazione

# [<language>, <username of program owner>](<link to answer>)

## Description

<description of change and how you found it>

## Code

<changed code>

vincente

Vince la persona che ha risolto il maggior numero di soluzioni.

Classifica

13 crepe:

• Dennis

8 crepe:

• Alex Van Liew

5 crepe:

• SP3000
• isaacg

3 crepe:

• Luis Mendo
• jimmy23013
• Dom Hastings

2 crepe:

• mbomb007
• Sluck49

1 crack:

• Il numero uno
• Jakube
• ProudHaskeller
• David Zhang
• samgak
• paul.oderso
• rayryeng
• mgibsonbr
• n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
• Stewie Griffin
• abligh

CJam, di Mauris

Descrizione

Il codice originale di Mauris prevede quanto segue:

"f~"     e# Push that string on the stack.
    :i   e# Cast each to integer. Pushes [102 126].
      :# e# Reduce by exponentiation. Pushes 102^126.

Nessun altro operatore matematico di CJam produrrebbe un numero così grande per input piccoli, quindi :#non può essere modificato. Poiché #, quando utilizzato per l'espiazione, accetta solo numeri interi come input, :inon può essere rimosso. Questo lascia solo un posto per modificare l'input: la stringa "f~".

Indipendentemente dal numero di caratteri contenuti nella stringa, il risultato sarà una torre di potere associativa di sinistra. CJam supporta caratteri nell'intervallo da 0 a 65535 (ad eccezione dei surrogati), quindi dobbiamo esprimere l'output come b ^{n × k × j} , dove b , n , k e j sono numeri interi in quell'intervallo.

Il logaritmo decimale dell'intero che risulta dal codice modificato è leggermente più piccolo del log ₁₀ (2.44 × 10 ²⁴²⁵⁴⁵ ) = log ₁₀ (2.44) + 242545 , quindi possiamo dividere questo valore per i logaritmi di tutte le possibili basi per trovare i valori corretti per n × k × j .

Infatti:

$ cjam <(echo '65536,2>{2.44AmL242545+1$AmL/i:I#s8<"24399707"=}=SIN')
5 347004

Il confronto delle prime 8 cifre si è rivelato sufficiente.

Ciò significa che possiamo esprimere l'output come 5 ^347.004 = 15625 ^57.834 = 125 ^{9 × 102 × 126} , quindi è sufficiente sostituirlo "f~"con "㴉"o"} f~" .

Codice

"㴉":i:#

o

"}  f~":i:#

Si noti che gli spazi nel codice ASCII dovrebbero effettivamente essere un tabulatore.

Tentare di eseguire questo codice nell'interprete online è probabilmente una cattiva idea, ma ecco come è possibile verificare i risultati dalla riga di comando:

$ wget -q https://bpaste.net/raw/f449928d9870
$ cjam <(echo '[15625 57834]:c`":i:#") > mauris.cjam
$ cat mauris.cjam; echo
"㴉":i:#
$ cjam mauris.cjam | diff -s - f449928d9870
Files - and f449928d9870 are identical
$ echo -en '"}\tf~":i:#' > mauris-ascii.cjam
$ cat mauris.cjam; echo
"}  f~":i:#
$ cjam mauris-ascii.cjam | diff -s - f449928d9870
Files - and f449928d9870 are identical

Rubino, istocratico

Descrizione

Modificato x per essere un array anziché scalare aggiungendo *

Modificato l'ultimo 9per essere una stringa anziché un numero aggiungendo?

Il risultato è costituito da un array con un singolo elemento ( [9]) moltiplicato per 9 volte, quindi imploso "9"come separatore.

Codice

x=*9;puts x*9*?9

Python 2, pesce fangoso

Descrizione

Attraverso prove e tribolazioni che coinvolgono la fattorizzazione di un gran numero e la ricerca di fattori consecutivi, mi sono reso conto che cambiare da 87654 a 58116 sarebbe stato sufficiente. Quindi, ho fattorizzato 58116 come 87 * 668. Poi ho capito che 01234 = 668, quindi dovevo solo cambiare 87654 in 87 e rimuovere completamente 01234. Questo si ottiene con un commento.

Codice

print (sum(range(054321)*9876)*87)#654)/01234

Shakespeare, AboveFire

Nella scena III, si deve cambiare Claudio in Claudio nel seguente frammento:

[Enter Claudio]

Claudius:
 Thou art as stupid as the sum of thee and the product of the 
 product of me and Helen and Helena

[Exeunt]

Codice modificato:

The Hidden Change.

Helen, a young woman with a remarkable patience.
Helena, a likewise young woman of remarkable grace.
Claudio, a remarkable man much in dispute with Claudius.
Claudius, the flatterer.
The Archbishop of Canterbury, the useless.


          Act I: Claudius's insults and flattery.

          Scene I: The insulting of Helen.

[Enter Claudius and Helen]

Claudius:
 Thou art as hairy as the sum of a disgusting horrible fatherless 
 dusty old rotten fat-kidneyed cat and a big dirty cursed war.
 Thou art as stupid as the product of thee and a fat smelly 
 half-witted dirty miserable vile weak son.

[Exeunt]

          Scene II: The complimenting of Helena.

[Enter Claudio and Helena]

Claudio:
 Thou art the sunny amazing proud healthy peaceful sweet joy.
 Thou art as amazing as the product of thee and the pretty
 lovely young gentle handsome rich Hero. Thou art as great 
 as the sum of thee and the product of a fair golden prompt good honest 
 charming loving noble king and a embroidered rich smooth golden angel.

[Exeunt]

          Scene III: The insulting of Claudio

[Enter Claudius and Helen]

Helen:
 Thou art as stupid as the sum of the sum of thee and a cat and me.
[Exit Helen]

[Enter Claudio]

Claudio:
 Thou art as stupid as the sum of thee and the product of the 
 product of me and Helen and Helena

[Exeunt]

          Scene IV: The Final Countdown

[Enter The Archbishop of Canterbury and Claudius]

Claudius:
 Thou art the sum of you and a cat.

The Archbishop of Canterbury:
 Am I better than a fine road?

Claudius:
 If not, let us return to the insulting of Claudio.

[Exit The Archbishop of Canterbury]

[Enter Claudio]

Claudius:
 Open your heart!
 Open your heart!
[Exeunt]

Usando il compilatore collegato da @AboveFire, questo stampa 11.

Prolog, Fatalizza

Descrizione

Aggiungi due \s. \è negazione bit per bit ed \/è bit per bit o.

Codice

X is \1\/42.

MATLAB / OCTAVE, Stewie Griffin

Un po 'di aritmetica complessa.

acos(i)

C, LambdaBeta

Descrizione

Trasforma main(a,_)in main(_). Il primo argomento di main è argcche è inizializzato come1 .

Codice

main(_){puts(_*_-1||_*_*_-1||_*_*_*_-1?"Expected Output":"?");}

Python 2, rp.belrann

Cambia la comprensione dell'elenco più esterno in una comprensione impostata. Credito parziale a @ mbomb007, che ha eliminato tutte le soluzioni "noiose" (scambio xey intorno, ottimizzazione degli operatori, modifica della gamma).

'~'*sum({(x,y)[x%2] for x in[y for y in range(8)]})

Spiegazione:

Nell'originale, [(x,y)[x%2]for x in[y for y in range(8)]]genera il seguente elenco:

[0, 7, 2, 7, 4, 7, 6, 7]

Ciò è dovuto al fatto che in Python 2.7, la ycomprensione nell'elenco interno perde nell'ambito che lo racchiude all'ultimo valore noto (che, alla fine di un intervallo, è 7). Quindi, nella tupla, yè sempre 7.x , tuttavia, passa attraverso l'elenco come normale, compreso tra 0 e 7. Quando xè pari, sceglie il valore di x, quando è dispari, sceglie y(che è sempre 7). Ho notato che se includessi esattamente un 7 e tutto il resto dei valori dix , avrei ottenuto 19; poi ho capito che avrei potuto trasformare la comprensione esteriore in una comprensione stabilita, che avrebbe eliminato tutti i valori duplicati e mi avrebbe lasciato esattamente 19.

Questo è stato abbastanza intelligente, non credo di aver mai usato una comprensione set prima. Complimenti.

Jonas, Matlab / Octave

Descrizione

Ho notato che la risposta era i^pi, quindi ho dovuto giraresin in un nop.

Codice

0i+(i^pi)

s-> 0, n->+

Bash, Dennis

Codice originale:

echo {{{1..9}}}

Uscita originale:

{{1}} {{2}} {{3}} {{4}} {{5}} {{6}} {{7}} {{8}} {{9}}

Codice modificato:

echo {,{1..9},}

Uscita modificata:

1 2 3 4 5 6 7 8 9

Spiegazione:

In Bash puoi generare un elenco separato da virgole di elementi all'interno di una coppia di parentesi graffe, in questo modo:

echo {a,b,c}

stampe

a b c

Quindi il codice modificato stampa un elenco di niente, i numeri 1..9, niente.

MATLAB, Luis Mendo

Codice originale:

-sin(2:.5:3)    
ans =    
   -0.9093   -0.5985   -0.1411

Nuova risposta:

psi(2:.5:3)
ans =
    0.4228    0.7032    0.9228

Descrizione:

Modificata -sinin psi, la funzione poligamma in MATLAB. Il -segno viene sostituito da pe nrimosso.

C, LambdaBeta

Descrizione

Cambia -1in *0modo che il risultato della moltiplicazione sia 0(un valore errato).

Codice

main(a,_){puts(_*_*_*_*_*0?"Expected Output":"?");}

Brainfuck, Kurousagi

Descrizione

Rimuovi il primo >e cambia il primo <in.

Testato su brainfuck.tk . Si noti che l'output non corrisponde post di kurousagi esattamente , a causa di SE divorando caratteri non stampabili.

Codice

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[>.+<-]

Fantom, Caino

La sicurezza attraverso l'oscurità è una pessima forma di sicurezza (specialmente quando i due metodi sono uno accanto all'altro nei documenti Fantom e chiunque sappia che aspetto ha un galleggiante saprà immediatamente cosa fare).

Float.makeBits32(1123581321)

CJam, di Basset Hound

25me

Calcola e ²⁵ . Provalo online.

L'interprete online dà un risultato leggermente diverso nel mio browser, che sembra essere un problema di arrotondamento.

L'interprete Java stampa 7.200489933738588E10, che è l'output desiderato, ma in un formato diverso.

Python 2, Sp3000

Descrizione

Modificato 01234in 0x1234e minin9in .

Il fatto 4669 = (01234-1)*sum(m<<m in R for m in R)è fuorviante.

Codice

R=range(0x1234);print sum(m<<9in(m,n)for m in R for n in R)

MATLAB / Octave, Stewie Griffin

Descrizione

Ciò ha richiesto la negazione dell'input nella funzione anonima g, nonché la modifica del fattore di ridimensionamento della gfunzione su 2 anziché su 7:

Codice

>> f=@(x)x^.7;g=@(x)2/f(x);g(-7)

ans =

  -0.3011 - 0.4144i

Perl, abligh

Descrizione

Aggiungi l'operatore di ripetizione stringa xe inserisci una cifra aggiuntiva!

Codice

print sin 95x7

Java, TheNumberOne

Descrizione

Il programma è un'implementazione unica di Random.next()con un seme iniziale di Integer.MAX_INTe tutti i numeri esadecimali convertiti in decimali. La modifica del seme nel complemento di MAX_INTgenera l'output:

class T{public static void main(String[]a){System.out.print(((~Integer.MAX_VALUE^25214903917L)&281474976710655L)*25214903917L+11L&281474976710655L);}}

(poiché devono esserci esattamente due modifiche, scegli qualsiasi tipo di modifica no-op: aggiunta di uno spazio da qualche parte, un punto e virgola aggiuntivo, ecc.)

Brainfuck, AboveFire

questo programma è una modifica di questo codice e una risposta cookie. quella risposta funziona prima pre-calcolando una tabella di utili codici ASCII di caratteri utili, e quindi ha tre istruzioni condizionali composte da tre cicli a cui si accede avendo una 1posizione corretta.

l'inizio di come ho infranto il codice è che il modello ripetitivo nell'output modificato è principalmente ciò che viene stampato se si accede al terzo ciclo con la tabella spostata a sinistra.

++++++++++[->++++++++<]>>++++++[-<---------->]<-------[----------->>>-<<+<[->->+<<]]>>>+<<>>>+++[->++++++++++<]>(<)++ .<+++++++++[->>>>>>>++++++++++<+++++<++++++++++++++<++++++++++<+++++<++++++++++<<]++++++++++>>+++++...>++>++>-->+>(>)++++<<<<<<<.<<<[->>>>>>.<<>>>>>.<<<<<.>>>>>.<<<<<>>>.<<<<.>>>>>.<<<<.>>>>>.<<<<<.>>>>.<<<<<.>>>>.<<...>.<<<<<<]>[->>>>>.<<...>>>.<<<<.>>>>>.<<<<...>>>>.<<<<<.>>>>.<<...>.<<<<<]>[->>>>.<<>>>>>>.<<<<<<..>>>.<<<<.>>>>>.<<<<>>>>>>.<<<<<<.>>>>>>.<<<<<<>>>>.<<<<<.>>>>.<<...>.<<<<]

(i caratteri aggiuntivi sono indicati tra parentesi)

Python 2, pesce fangoso

Descrizione

Passare <<a <>(versione obsoleta di !=) e 0x156a 0156, il punto di codice per "n"(che appare 3 volte nella stringa di lunghezza 23'<built-in function sum>' ).

Codice

print sum((ord(i)<>0156 for i in `sum`))

JavaScript, di Razvan

Descrizione

L'output modificato è chiaramente il numero naturale di Euler, a cui è possibile accedere come Math['E'].

Passando ''a '3'e 32a 36, String.fromCharCodegenera il E.

Codice

a=1,b=a*2,c=a+b,d=[a+b];while(c>b)c-=a;for(i=1;i<=c;i++)d.push(i);i='3'+c*d['length']*d['length'];alert(Math[String.fromCharCode(i.charCodeAt(0) * i.charCodeAt(1) / 36)])

Fantom, Caino

Descrizione

L'indicizzazione dell'array è già impostata, quindi devo solo creare un 55. Onestamente, la parte più difficile è stata scaricare la lingua.

Codice

[7115432d/9,219.or(64),37,55,55][3]

(Inserita una virgola, 0-> 3)

Shakespeare, AboveFire

NON CORRETTO - scusa :(

Lo esaminerò ulteriormente quando torno a casa dal lavoro Nell'originale il valore di Claudio è 1132462081 e il valore di Claudio è 1

Nella scena finale il valore di Claudio viene stampato due volte,

[Enter Claudio]

Claudius:
 Open your heart!
 Open your heart!

apri il tuo cuore x2 = stampa il valore dell'altra persona sul palco (Claudio). Quindi se cambi Claudio a Claudio (2 caratteri) - verrà stampato il valore di Claudio - che è 1 - due volte

The Hidden Change.

Helen, a young woman with a remarkable patience.
Helena, a likewise young woman of remarkable grace.
Claudio, a remarkable man much in dispute with Claudius.
Claudius, the flatterer.
The Archbishop of Canterbury, the useless.


          Act I: Claudius's insults and flattery.

          Scene I: The insulting of Helen.

[Enter Claudius and Helen]

Claudius:
 Thou art as hairy as the sum of a disgusting horrible fatherless 
 dusty old rotten fat-kidneyed cat and a big dirty cursed war.
 Thou art as stupid as the product of thee and a fat smelly 
 half-witted dirty miserable vile weak son.

[Exeunt]

          Scene II: The complimenting of Helena.

[Enter Claudio and Helena]

Claudio:
 Thou art the sunny amazing proud healthy peaceful sweet joy.
 Thou art as amazing as the product of thee and the pretty
 lovely young gentle handsome rich Hero. Thou art as great 
 as the sum of thee and the product of a fair golden prompt good honest 
 charming loving noble king and a embroidered rich smooth golden angel.

[Exeunt]

          Scene III: The insulting of Claudio

[Enter Claudius and Helen]

Helen:
 Thou art as stupid as the sum of the sum of thee and a cat and me.
[Exit Helen]

[Enter Claudio]

Claudius:
 Thou art as stupid as the sum of thee and the product of the 
 product of me and Helen and Helena

[Exeunt]

          Scene IV: The Final Countdown

[Enter The Archbishop of Canterbury and Claudius]

Claudius:
 Thou art the sum of you and a cat.

The Archbishop of Canterbury:
 Am I better than a fine road?

Claudius:
 If not, let us return to the insulting of Claudio.

[Exit The Archbishop of Canterbury]

[Enter Claudio]

Claudio: << changed Claudius to Claudio
 Open your heart!
 Open your heart!
[Exeunt]

VBA di JimmyJazzx

Modificato IRRin MIRRe modificato 5in a, quindi ci sono 3 parametri.

Ho trovato questo mentre cercavo come IRRfunziona la funzione di Excel . C'era un articolo: Come la funzione MIRR di Excel può correggere la funzione IRR . Mi ha dato una soffiata. Tentativo intelligente, però. Non avevo mai usato VBA prima, quindi anche quello era interessante.

Sub q()
Dim a(2) As Double
a(0)=-5
a(1)=10
msgBox MIRR(a,0.2,3)
End Sub

Matlab / Octave, Jonas

Descrizione

Nell'ultima riga, aggiungi 'per trasformare arg'in stringa 'arg', che verrà quindi interpretata come numeri ASCII. E quindi aggiungine un altro 'alla fine per mantenere il formato della colonna.

Il quasi inutile 'nel codice originale era l'indizio principale. Inoltre, a posteriori, il fatto che sia argstato definito separatamente (anziché direttamente all'interno della sinlinea) avrebbe dovuto apparire sospetto.

Codice

format long
arg = [.1 .2 .3];
sin('arg'*exp(9))'

bc, abligh

Inseriti semplicemente gli operatori matematici. Ci sono voluti circa 1 minuto per risolvere una volta che ho cercato cosa fosse bc e quali operazioni matematiche avesse. La prima cosa che ho pensato è stata la divisione, ma non c'erano fattori comuni che sembravano belli. Quindi sono andato subito per esponenziazione e modulo. Erano necessarie almeno 15 cifre per il modulo b / c dell'uscita prevista. Dopo ciò, ho indovinato due volte e l'ho trovato.

4518^574%615489737231532

Lua, TreFox

Descrizione

"_G" è la tabella globale, facendo "_G.load" fare riferimento alla funzione globale "load". La conversione di una funzione in una stringa comporta la restituzione dell'indirizzo della funzione, che viene quindi trasformato nella lunghezza della stringa dall'operatore lunghezza "#".

Codice

G={load="lfkjgGsHjkU83fy6dtrg"}
print(#tostring(_G.load))

Inoltre, poiché questo è il mio primo post qui, non posso fare un commento sulla risposta originale.

Python, rp.beltran

Descrizione

Ho notato che le lettere necessarie erano sempre 2 davanti a una cifra. cambiando il terzo \wper \dottenere tutte le lettere giuste tranne gli spazi. \Dera l'unico\ gruppo che riuscivo a trovare che consentiva lettere e spazi.

Codice

import re;''.join(re.findall('\D(?=\w\d)','t74q joh7 jv f9dfij9j bfjtf0e nnjen3j nnjrb6fgam3gtm5tem3hj s3eim7djsd3ye d5dfhg5un7ljmm8nan3nn6n k m2ftm5bsof5bf r5arm4ken8 adcm3nub0 nfrn6sn3jfeb6n d m6jda5 gdif5vh6 gij7fnb2eb0g '))

w-> D, w-> dnella regex.

Pyth, isaacg

Descrizione

Il codice originale procede come segue:

 CG      Convert "abcdefghijklmnopqrstuvwxyz" from base 256 to integer, yielding
         156490583352162063278528710879425690470022892627113539022649722.
   ^3y21 Compute 3^(2 * 21).
%        Calculate the modulus.

Poiché 156490583352162063278528710879425690470022892627113539022649722 - 58.227.066 dà 156490583352162063278528710879425690470022892627113538964422656 , che equivale a 2 ²⁶ × 3 × 7 × 7477 × 381.524.422.711 × 17007550201751761 × 2288745700077000184147 , l'uscita desiderata può essere ottenuto sostituendo ^3y21con qualcosa che restituisce un divisore di questo prodotto ed è più grande 58.227.066 .

Il ^nel codice originale suggerisce che potremmo usarlo per calcolare una potenza di 2 , il 3 che potremmo calcolare un divisore adatto della forma 3 × 2 ⁿ .

Entrambi sono fuorvianti. Soluzioni con una distanza Levenshtein di 3 ( %CG^2 26, %CG^y2 13, %CG^4y13) o 4 (%CG.<3y13 ) sono facilmente trovato, ma la soluzione a distanza 2 richiede un approccio diverso.

L'alfabeto minuscolo ( G) ha 26 lettere, quindi il suo set di potenze (l'insieme di tutte le sequenze di lettere minuscole strettamente crescenti) ha 2 ²⁶ elementi. Con la sostituzione y2conyG , calcoliamo questo set di potenza.

Possiamo recuperare la lunghezza dell'insieme sostituendoli 3conl , il che ci lascia con ^lyG1, cioè, 2 ²⁶ innalzati alla prima potenza.

Codice

%CG^lyG1

Si noti che questo funzionerà solo su un computer con sufficiente memoria disponibile (circa 6,43 GiB, secondo time ), quindi non funzionerà con l'interprete online.

Ecco come è possibile verificare i risultati dalla riga di comando:

$ \time -v pyth -c '%CG^lyG1'
58227066
        Command being timed: "pyth/pyth.py -c %CG^lyG1"
        User time (seconds): 30.73
        System time (seconds): 2.12
        Percent of CPU this job got: 100%
        Elapsed (wall clock) time (h:mm:ss or m:ss): 0:32.85
        Average shared text size (kbytes): 0
        Average unshared data size (kbytes): 0
        Average stack size (kbytes): 0
        Average total size (kbytes): 0
        Maximum resident set size (kbytes): 6742564
        Average resident set size (kbytes): 0
        Major (requiring I/O) page faults: 0
        Minor (reclaiming a frame) page faults: 2269338
        Voluntary context switches: 1
        Involuntary context switches: 58
        Swaps: 0
        File system inputs: 0
        File system outputs: 0
        Socket messages sent: 0
        Socket messages received: 0
        Signals delivered: 0
        Page size (bytes): 4096
        Exit status: 0