Due fa la differenza: la polizia


60

AVVISO - Questa sfida è ora chiusa. Eventuali nuove risposte verranno ignorate e la risposta accettata non cambierà

Sfida

Scrivi un programma valido che, quando vengono cambiati, rimossi o aggiunti solo due caratteri nel programma, cambia completamente l'output.

L'output modificato deve avere una distanza di Levenshtein pari o superiore a 15 rispetto all'output originale.

L'output deve essere non vuoto e finito. Pertanto, il programma deve terminare entro 1 minuto.

Il tuo output deve essere deterministico, producendo la stessa cosa ogni volta che esegui il programma. Inoltre, non deve dipendere dalla piattaforma.

Le funzioni hash non sono consentite , così come sono integrate nei PRNG. Allo stesso modo, non è consentito il seeding di un RNG.

Dopo un periodo di tre giorni, un invio non crackato diventerà sicuro. Al fine di rivendicare questa sicurezza, è necessario modificare la risposta per mostrare la risposta corretta. (Chiarimento: fino a quando non rivelerai la risposta, non sei al sicuro e puoi ancora essere crackato.)

formattazione

La tua risposta dovrebbe essere nel seguente formato:

# <Language name>, <Program length>

## Code

<code goes here>

## Original Output

<output goes here>

## Changed output

<changed output goes here>

Robbers

La sfida dei ladri è scoprire quali due personaggi hai cambiato. Se un ladro ha decifrato la tua soluzione, lascerà un commento sulla tua risposta.

Puoi trovare il thread dei ladri qui .

vincente

Vince la persona con la soluzione non crackata più corta.

Classifica

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script>site = 'meta.codegolf';postID = 5686;isAnswer = false;QUESTION_ID = 54464;var safe_list=[];var uncracked_list=[];var n=0;var bycreation=function(x,y){return (x[0][0]<y[0][0])-(x[0][0]>y[0][0]);};var bylength=function(x,y){return (x[0][1]>y[0][1])-(x[0][1]<y[0][1]);};function u(l,o){ jQuery(l[1]).empty(); l[0].sort(o); for(var i=0;i<l[0].length;i++) l[0][i][1].appendTo(l[1]); if(l[0].length==0) jQuery('<tr><td colspan="3" class="message">none yet.</td></tr>').appendTo(l[1]);}function g(p) { jQuery.getJSON('//api.stackexchange.com/2.2/questions/' + QUESTION_ID + '/answers?page=' + p + '&pagesize=100&order=desc&sort=creation&site=codegolf&filter=!.Fjs-H6J36w0DtV5A_ZMzR7bRqt1e', function(s) { s.items.map(function(a) { var he = jQuery('<div/>').html(a.body).children().first(); he.find('strike').text(''); var h = he.text(); if (!/cracked/i.test(h) && (typeof a.comments == 'undefined' || a.comments.filter(function(b) { var c = jQuery('<div/>').html(b.body); return /^cracked/i.test(c.text()) || c.find('a').filter(function() { return /cracked/i.test(jQuery(this).text()) }).length > 0 }).length == 0)) { var m = /^\s*((?:[^,;(\s]|\s+[^-,;(\s])+)\s*(?:[,;(]|\s-).*?([0-9]+)/.exec(h); var e = [[n++, m ? parseInt(m[2]) : null], jQuery('<tr/>').append( jQuery('<td/>').append( jQuery('<a/>').text(m ? m[1] : h).attr('href', a.link)), jQuery('<td class="score"/>').text(m ? m[2] : '?'), jQuery('<td/>').append( jQuery('<a/>').text(a.owner.display_name).attr('href', a.owner.link)) )]; if(/safe/i.test(h)) safe_list.push(e); else uncracked_list.push(e); } }); if (s.length == 100) g(p + 1); else { var s=[[uncracked_list, '#uncracked'], [safe_list, '#safe']]; for(var p=0;p<2;p++) u(s[p],bylength); jQuery('#uncracked_by_length').bind('click',function(){u(s[0],bylength);return false}); jQuery('#uncracked_by_creation').bind('click',function(){u(s[0],bycreation);return false}); } });}g(1);</script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><style>table th,table td { padding: 5px;}th { text-align: left;}.score { text-align: right;}table a { display: block;}.main { float: left; margin-right: 30px;}.main h3,.main div { margin: 5px;}.message { font-style: italic;}</style><div class="main"><h3>Uncracked submissions</h3><table> <tr> <th>Language</th> <th class="score">Length</th> <th>User</th> </tr> <tbody id="uncracked"></tbody></table><div>Sort by: <a href="#" id="uncracked_by_length">length</a> <a href="#" id="uncracked_by_creation">creation</a></div></div><div class="main"><h3>Safe submissions</h3><table> <tr> <th>Language</th> <th class="score">Length</th> <th>User</th> </tr> <tbody id="safe"></tbody></table></div>


@BetaDecay Come si definisce una funzione hash?
Isaacg,

1
@xnor Teoricamente, ma il numero di possibilità aumenta enormemente all'aumentare della durata del programma e quindi potrebbe richiedere molto tempo
Decadimento beta

1
@RedPanda Sì, la penso così
Decadimento beta

5
@isaacg Ho deciso di cambiare la data di sicurezza in tre giorni
Decadimento beta

4
Sarebbe possibile mettere il codice della classifica su meno righe in modo da occupare meno spazio visivo?
isaacg,

Risposte:


6

CJam, 13 byte (sicuro)

J{m!_)mQ%2b}/

Provalo online.

Uscita originale

000010010101001010001101111000111011100110100100001011101101010100011111110010010010001111111111010000010011001110001010011111000010001001110111100000010110000010000111011011110101110010000011100111100

Uscita modificata

11101101100011110001011010000100111011000010011101100000001010100111011010011011010111101000000011101111100000000110001000111110110110101111110100101110000101110100110011110000010101110

Soluzione

J{m!_)ci%2b}/

Provalo online.

Come funziona

Questo sfrutta il modo in cui CJam stampa implicitamente l'intero stack dopo aver eseguito il programma.

Semplicemente scaricando le rappresentazioni di base 2 di alcuni numeri interi nella pila, si fa in modo che vengano stampate senza alcun separatore, quindi dovrebbe essere difficile capire dove inizia una di esse e un'altra finisce.

Il codice originale procede come segue:

J{   e# For each I from 0 to 18, do the following:
  m! e#   Calculate the factorial of I.
  _) e#   Push a copy and add 1.
  mQ e#   Compute the result's integer square root.
  %  e#   Calculate the residue of the factorial divided by the square root.
  2b e#   Push the array of base 2-digits of the resulting integer.
}/   e#

Come osserva @AndreaBiondo nei commenti, le rappresentazioni binarie di 0! alle 8! può essere trovato all'inizio dell'output (spazi aggiunti per maggiore chiarezza):

1 1 10 110 11000 1111000 1011010000 1001110110000 1001110110000000

La modifica voluta era sostituire mQcon ci, che accetta l'intero modulo 65536, usando l'aritmetica dei caratteri a 16 bit (passando a un carattere a 16 bit senza segno, quindi di nuovo all'intero).

Speravo che l'idea di utilizzare cper sostituire un operatore matematico fosse abbastanza oscura.


Wow. Come ti viene in mente?
The_Basset_Hound il

Ho provato a risolverlo per un bel po '. Ho capito parte del modello modificato, ma mi mancava qualcosa. Adesso è sicuro, suppongo.
Andrea Biondo,

@AndreaBiondo È adesso. Grazie per avermi ricordato.
Dennis,

@Dennis Avevo capito che _)mQbisognava cambiarlo in un f(x!)tale che f(x!) > x!per x <= 8e f(x!) < x!per x >= 9, perché x!ovviamente era stato modellato da un numero che lasciava intatti i fattoriali da 0 a 8 nell'output. Non ho notato che 9!il primo fattoriale era più grande di 2^16. Sfida molto bella comunque.
Andrea Biondo,

39

screpolato

Shakespeare, 1721 byte

Ho provato una risposta di Shakespeare. Non è breve e ho avuto difficoltà a cambiare l'output con solo 2 caratteri, ma penso di esserci riuscito abbastanza bene. Buona fortuna a tutti. Come nota a margine, ho usato il "compilatore" disponibile a questo indirizzo e potrebbe non funzionare con un altro. (non funziona con l'interprete online) L'output non contiene caratteri non stampabili.

Codice

Il cambiamento nascosto.

Helen, una giovane donna con una notevole pazienza.
Helena, anche una giovane donna di straordinaria grazia.
Claudio, un uomo straordinario molto in conflitto con Claudio.
Claudio, l'adulatore.
L'arcivescovo di Canterbury, l'inutile.


          Atto I: insulti e adulazione di Claudio.

          Scena I: L'offesa di Elena.

[Entra in Claudio ed Elena]

Claudio:
 Sei peloso come la somma di un disgustoso orribile senza padre 
 vecchio gatto polveroso e grasso di rene grasso e una grande e sporca guerra maledetta.
 Sei stupido come il prodotto di te e un grasso puzzolente 
 figlio debole, miserabile, miserabile, mezzo arguto.

[Escono]

          Scena II: i complimenti di Helena.

[Entra in Claudio ed Helena]

Claudio:
 Tu sei l'incredibile gioia serena, dolce, serena, dolce gioia.
 Sei incredibile come il prodotto di te e del bello
 adorabile giovane gentile bello ricco ricco Eroe. Sei eccezionale
 come la somma di te e il prodotto di un giusto richiamo d'oro onesto 
 affascinante nobile re amorevole e un ricco angelo dorato liscio ricamato.

[Escono]

          Scena III: l'insulto di Claudio

[Entra in Claudio ed Elena]

Helen:
 Sei stupido quanto la somma della somma di te, di un gatto e di me.
[Esci da Helen]

[Entra in Claudio]

Claudio:
 Sei stupido quanto la somma di te e il prodotto del 
 prodotto da me e Helen ed Helena

[Escono]

          Scena IV: il conto alla rovescia finale

[Entra nell'arcivescovo di Canterbury e Claudio]

Claudio:
 Sei la somma di te e di un gatto.

L'arcivescovo di Canterbury:
 Sono meglio di una bella strada?

Claudio:
 Altrimenti, torniamo all'insulto di Claudio.

[Esci dall'arcivescovo di Canterbury]

[Entra in Claudio]

Claudio:
 Apri il tuo cuore!
 Apri il tuo cuore!
[Escono]

Uscita originale

11324620811132462081

Uscita modificata

11

9
Davvero meraviglioso. Questa storia mi ha fatto venire le lacrime agli occhi.
Alex Van Liew,

6
@AlexVanLiew Mi ci è voluto molto tempo per scrivere. È il mio capolavoro!
AboveFire


Risposta molto bella
orgoglioso haskeller il

24

J, 76 byte (sicuro)

Codice

,:|.,.<,:>><|.,:>,.<|.>,:<<|.>|.,:,.<,.<,:,.<,:>|.<,:>,.|.<,:,.|.<<,:>126$a.

Uscita originale

┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐│
││┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐││
│││┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐│││
││││┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐││││
│││││     ┌┬┐├┼┤└┴┘│─ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}│││││
││││└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘││││
│││└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘│││
││└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘││
│└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘│
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

Uscita modificata

┌──────────────────────┐
│┌────────────────────┐│
││┌──────────────────┐││
│││┌────────────────┐│││
││││┌──────────────┐││││
│││││┌───────────┬┐│││││
││││││0 0 0 0 0 0│││││││
│││││└───────────┴┘│││││
││││└──────────────┘││││
│││└────────────────┘│││
││└──────────────────┘││
│└────────────────────┘│
└──────────────────────┘

EDIT: soluzione {:aggiunta (mostrata tra ###)

,:|.,.<,:>><|.,:>,.<|.>,:<<|.>|.,:,.<,.<,:,.<,###{:###:>|.<,:>,.|.<,:,.|.<<,:>126$a.

Utilizza la {::mappa della monade . Gran parte del resto del codice è inutile immondizia.


Nota che potrei certamente estendere il codice di una quantità ridicola di personaggi per rendere più difficile trovare i punti in cui i due personaggi devono essere aggiunti / rimossi / cambiati
Fatalizza l'

Penso che siano passati 3 giorni per questo, quindi se pubblichi la risposta, sei al sicuro.
isaacg,

@isaacg Corretto, modificato la risposta
Fatalizza il

12

screpolato

Ruby, 14

Codice

x=9;puts x*9*9

Uscita originale

729

Uscita modificata

99999999999999999

4
Sembra così innocente. Ci ho provato e ci ho provato, ma non so da dove prendere il 17 ...
Dennis l'

1
Ho pensato che fossero i 18 9, quindi stavo cercando qualcosa di simile '99'*2. wc, mi hai tradito!
Alex Van Liew,

@AlexVanLiew 18 sarebbe facile. Dai la colpa alla shell per aver aggiunto un avanzamento riga.
Dennis,

@Dennis Come faresti con 18? Non sono riuscito a capirlo (ma non conosco neanche Ruby).
Alex Van Liew,


12

screpolato

Bash, 15 byte

echo {{{1..9}}}

Uscita originale

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

Uscita modificata

1 2 3 4 5 6 7 8 9


2
Molto bene. Questo è durato più a lungo di quanto pensassi.
Dennis,

10

screpolato

Prolog, 10 byte

Codice

X is 1/42.

Uscita originale

X = 0.023809523809523808.

Uscita modificata

X = -2.


2
Per qualche ragione ho completamente ignorato il fatto che anche questo può essere risolto in questo modo: X is 1//4-2.che è molto più facile da vedere rispetto alla mia soluzione originale che @ sp3000 ha rotto ...
Fatalizza il

10

screpolato

Python 2, 43 byte

Codice

print (sum(range(054321)*9876)*87654)/01234

Uscita originale

334960491355406

Uscita modificata

222084148077792

La distanza Levenshtein è esattamente 15. Sia l'originale che il cambio vengono eseguiti in meno di 1 minuto sul mio computer.


1
Ho modificato il tuo post per riflettere che si tratta di un invio specifico per Python 2, a causa delle parentesi mancanti printe della moltiplicazione di rangeper un numero intero. Tuttavia, mi sembra che stia ottenendo messaggi MemoryErrordalla grande lista ...
Sp3000,

1
Dal momento che questo non è il golf del codice, potresti ridurre il carico di memoria usando xrangeinvece di rangee credo che itertoolsabbia un generatore-generatore che si ripete un xnumero di volte ripetuto .
Alex Van Liew,

1
@AlexVanLiew Ma il punteggio è code-golf in un certo senso, il più breve senza crack. Detto questo, però, c'è uno spazio non necessario e una coppia di genitori ... o sono necessari? ;)
Sp3000,

2
IMO questa risposta sembra in qualche modo non interessante se questo si basa solo sulla modifica dei numeri coinvolti (non sappiamo se questo è il caso), perché in quel caso probabilmente puoi fare più breve e l'unico modo in cui verrà mai rotto è solo con la forza bruta, non con intelligenza.
Fatalizza l'

3
Cracked. È stato divertente!
isaacg,

8

screpolato

BrainFuck, 504 byte

Nessuno dovrebbe mai aver bisogno di analizzare un codice Brainfuck. Questa è una versione modificata di un codice precedente, ma qualsiasi modifica in un codice Brainfuck fa una grande differenza nell'output. Uso l'interprete su http://esoteric.sange.fi/brainfuck/impl/interp/i.html per testare il mio codice. In bocca al lupo !

Codice

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

Uscita originale

 ___
/   \
|   |
\___/

Uscita modificata

}}}\}}}|.}}}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\

Nota: l'uscita modificata contiene diversi caratteri STX (ASCII 2) ed EOT (ASCII 4)

Ecco la versione con i codici ASCII tra parentesi anziché caratteri non stampabili:

(2)}}}(2)\}}}|(2).}}}.(2)|///\\(4)}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)///\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|/(4)/\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|///\

3
Tu sei il male. Ma lo troverò!
RedPanda,

@RedPanda Il mio codice ha una struttura. Almeno non è casuale! In bocca al lupo!
AboveFire

ci sono non stampabili nell'output?
orgoglioso haskeller l'

@proudhaskeller Sì, mi dispiace, modificherò il post, c'è un sacco di personaggi STX (ASCII 2) ed EOT (ASCII 4)
AboveFire


8

screpolato

Wolfram Language (Mathematica o WolframAlpha), 3 byte

Codice

8.!

Uscita originale

40320.

Uscita modificata

2.67182 - 0.891969 I

Per coloro che lo provano su WolframAlpha il risultato appare come

Grafica Mathematica

Ho cancellato la mia risposta precedente perché funzionava solo su Mathematica e non su WolframAlpha . Ciò ha messo i ladri dietro un paywall (invece dei meritati bar), il che non era giusto.



@abligh Nice! :)
Dr. belisarius,

1
Qual è stata la risposta dell'altro? Sono molto curioso.
Brain Guider,

7

screpolato

MATLAB / OCTAVE, 7 byte

Codice:

cos(pi)

Uscita originale:

ans =

     -1

Uscita modificata:

ans =

   1.5708 - 0.8814i

Questo dà una distanza di Levenshtein di esattamente 15.



3
Il grande suggerimento per me è stato notare che la parte reale del tuo output modificato è pi / 2. Da lì, non è stato difficile indovinare la soluzione.
David Zhang,

7

screpolato

CJam, 8 caratteri

Codice

"~f":i:#

Uscita originale

17290024234092933295664461412112060373713158853249678427974319674060504032816100667656743434803884485234668769970047274563123327020396104330878852891146011372048615474145637592955298601510765168228550988848615653376

Uscita modificata

L'output dopo la modifica è qui . Entrambi impiegano meno di un minuto sul mio laptop 2GHz.

Spiegazione

Le persone sembrano stupite di come funziona. Il codice funziona in questo modo:

"~f"       Push a string
    :i     Convert to a list of bytes [126 102]
      :#   Fold with # (power)

Questo calcola 126 ^ 102. La soluzione era:

"}\t~f"
       :i     Convert to a list of bytes [125 9 126 102]
         :#   Fold with # (power)

Questo calcola ((125 ^ 9) ^ 126) ^ 102, che è lungo centinaia di migliaia di cifre.


6
Questo è criminale.
Alex Van Liew,

Cosa ... Voglio davvero sapere come funziona! ;)
Beta Decay


@BetaDecay Potrei spiegare come funziona l'originale ma non la versione di Dennis. Mi chiedo come Mauris intendesse che fosse risolto ...
Alex Van Liew,

Banane sante! WTF!
Brain Guider,

7

screpolato

Pyth, 8 byte

Codice:

%CG^3y21

Uscita iniziale:

51230235128920219893

Uscita modificata:

58227066

1
L'output modificato è uguale CG mod (2^21 * 28). Non conosco Pyth, quindi non vedo come trasformarmi (3 ^ (2 * 21))in questo ...
Lynn,

1
Inoltre, è CGuguale sum(256**n * (122-n) for n in range(26)).
Lynn,

1
Anche l'output modificato è uguale a CG mod (2^21 * 28 * 2*n), dove 1 <= n <= 4, oltre a n=6e n=12. Inoltre, CGè solo l'alfabeto minuscolo interpretato come un numero di base 256. Mi chiedo se c'è un altro modulo con base 3?
Alex Van Liew,

%CG^2 26oppure %CG^4y13, ma entrambi hanno una distanza di 3 ...
Jakube,


6

screpolato

Python 2, 58 byte

Codice

R=range(01234);print sum(m<<min(m,n)for m in R for n in R)

Uscita originale

2444542772018013876036977350299418162656593659528311114655474359757543862791958572561591492595632222632192542272836836649846934427359810217936317967768095940470375690509652583392001888886352103127515963142

Uscita modificata

4669

Quella regola delle 15 distanze ha sicuramente reso le cose difficili. Spero che vada bene.


Il fatto che 4669 = 667 * 7 e che l'ultimo elemento dell'intervallo (01234) sia 667 è sospetto per me ...
Fatalizza il

Se stampi [m<<min(m,n)for m in R for n in R]nell'interprete, otterrai alcuni modelli esque davvero inquietanti di rumore bianco.
Alex Van Liew,


6

screpolato

Python 2, 50 byte

Codice originale:

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

Uscita originale:

'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'

Uscita modificata:

'~~~~~~~~~~~~~~~~~~~'

Non troppo corto, e forse non troppo difficile, non lo so davvero. Proverò a trovare qualcosa di meglio presto.


Sono 40 tilde e poi 19 tilde? E suppongo che questo sia eseguito nell'interprete?
Alex Van Liew,


2
Un riassunto di ciò che ho trovato finora: nessuna combinazione di sostituzione xcon y, ycon xo modifica della cifra nel rangerisultato in 19 tilde. Ho anche sperimentato con l'inserimento di una -prima xo y, e con la modifica %in una delle + - / *, senza alcun risultato. Sono abbastanza certo ora che sono richiesti 1 o 2 inserti.
mbomb007,

1
Bene, il mio primo link ora lo rompe correttamente.
Alex Van Liew,

2
Ho aggiunto una piccola spiegazione, in realtà penso che questa sia stata davvero intelligente. Non so nemmeno di aver mai visto una comprensione prestabilita, e anche fare affidamento sul fatto che Python sia trapelato ynel campo di applicazione racchiuso è stato un bel tocco.
Alex Van Liew,

6

screpolato

PHP, 164 byte

Codice

$S_U_M_M_E_R = 1;
$A_U_T_U_M_N = 2;
$T_I_M_E = 1;

if ($T_I_M_E == $S_U_M_M_E_R) {
    $A_C_=$T_I_=$O_N= 'SWIM' ? 'TAN' : 'DRINK';
}

print $T_I_M_E * $A_U_T_U_M_N;

Uscita originale

2

Uscita modificata

-1.1306063769532


Molto bene! Non pensavo che sarebbe stato così facile essere violati.
Razvan,

6

GolfScript, 15 byte (sicuro)

Codice

10,{1+3?}%{*}*]

Codice modificato

107,{1+3?}%{^}*]

Uscita originale

47784725839872000000

Uscita modificata

557154

spiegazioni:

10,             # numbers from 0 to 10
   {1+3?}%      # add one and raise to the cube. (%=for each)
          {*}*] # take the product and place it in a list(useless)`

Codice modificato

107,             # numbers from 0 to 107
    {1+3?}%      # add one and raise to the cube. (%=for each)
           {^}*] # xor them and place it in a list(useless)

Credo che ora sia sicuro, quindi se desideri modificare il tuo post
Decadimento beta,

@BetaDecay I am!
Baconaro,


4

screpolato

C, 53 byte

Codice

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

Uscita originale

Expected Output

Uscita modificata

?

Probabilmente troppo facile, ma chi lo sa. (Nota: è tecnicamente dipendente dal sistema ma il tipo di sistema su cui fallisce fallirebbe anche con tutte le altre osservazioni qui, quindi ho pensato che fosse un punto controverso).

screpolato

modificare

Ho fatto un errore. Nuovo codice che è più sicuro dell'ovvio attacco:

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

stesse uscite. Nuova dimensione di 65 byte. Speriamo che sia più difficile ... anche se probabilmente è ancora troppo facile.




2
(nota a
margine

@ Sp3000 Forse hai ragione, anche se l'obiettivo dell'originale era avere la stessa soluzione, mi sono solo concentrato troppo sul problema del conteggio dispari * (dove puoi trasformare quello medio in un /) e non ho considerato il cambio più facile * 0.
LambdaBeta,

4

Craccato da issacg

MATLAB, 20 byte

Codice

format long
sin(i^pi)

Uscita originale

0.331393418243797 - 1.109981778186163i

Uscita modificata

0.220584040749698 - 0.975367972083631i

Ho provato un sacco di idee nell'interprete Octave online. Ancora niente. Ho provato cose come l'utilizzo sinh, asin, tan, pi^i, ecc ...
mbomb007

@ mbomb007 - Anche qui sono in perdita ... e sono il 5 ° più alto su StackOverflow in MATLAB nel complesso!
rayryeng - Ripristina Monica il



4

CJam, 28 byte (sicuro)

"jK=\~"5*)ib257b~{G$5$+}*]Jb

Provalo online .

Uscita originale

7705397905065379035618588652533563996660018265606606763127193120855297133322151462150247488267491212817218321670720380456985476811737021068519164822984561148339610474891720342171053455881107227302663880445203851079295537592154028123394687360216561235621729967011148112746984677807932995700334185726563970223018774

Uscita modificata

16650180159137697345989048346412185774444335111603430666402604460993564226370500963166158223117360250140073061887053326627468495236957122711656527124216908303912850181595147494475577084810653496778801228980874902968634143062

Soluzione

"jK=\~"5*Wcib257b~{G$5$+}*]Jb

Provalo online.

Come funziona

Sono andato un po 'fuori bordo con questo ...

Il codice originale procede come segue:

"jK=\~"5* e# Push "jK=\~jK=\~jK=\~jK=\~jK=\~".
)i        e# Pop the last character and cast it to integer.
b257b     e# Convert the remainder of the string from that base to base 257.
~         e# Dump all resulting base-257 digits on the stack:
          e# 137 72 124 88 81 145 85 32 28 251 118 230 53 13 245 147 256 116 187 22 224
{         e# Do the following 224 times:
  G$5$+   e#   Add copies of the 5th and 17th topmost integers on the stack
          e#   (recurrence of a lagged Fibonacci sequence).
}*        e#
]         e# Wrap the entire stack in an array.
Jb        e# Convert from base 19 to integer.
          e# The resulting integer is printed implicitly.

La modifica prevista viene sostituita (ida Wci.

Questo lascia intatta la stringa ripetuta e spinge 65535 ( eseguendo il casting su un carattere a 16 bit senza segno, quindi di nuovo sull'intero), in modo che i primi elementi della sequenza di Fibonacci ritardata diventino

87 225 162 210 73 196 142 219 175 61 40 147 0 93 75 55 103 116 237 188 108 122 176 133 135 240 251 155 224 82 181 75 23 87 139 49 148 169 84 109 110 166 52 103 83 185 78 73

e il loop viene ripetuto 126 volte.


Questo è sicuro adesso, no?
Decadimento beta

@BetaDecay Ho praticamente usato lo stesso trucco in entrambe le risposte di CJam, quindi ho dovuto aspettare di pubblicare entrambe le soluzioni contemporaneamente. Adesso è al sicuro.
Dennis,

Una volta capito cosa fosse, mi sono reso conto che c'erano così tante cose che potevano essere modificate che non mi sono nemmeno preoccupato di provare a forzare questa forza ... bel lavoro :)
Sp3000,

4

Javascript, 47 (sicuro)

Codice

for(var i=64460,x=773;i>=1324;)x=i--/x;alert(x)

Uscita originale

11.948938595656971

Uscita modificata

3.679331284911481

La distanza è esattamente 15.

Testato in Chrome e IE.

Soluzione

for(var i=64460,x=773;i>>=1<324;)x=i--/x;alert(x)

Questo utilizza l'operatore di assegnazione di spostamento dei bit i>>=1per rendere l'intervallo di loop non lineare. Anche questo ha la proprietà divertente che qualcuno che cerca di forzare una soluzione si imbatterà in diverse varianti che funzionano all'infinito.


3

screpolato

Fantom , 26

Codice

Float.makeBits(1123581321)

Uscita originale

5.55122931E-315

Uscita modificata

124.24518585205078

Sicurezza attraverso l'oscurità, se nessuno conosce la lingua, nessuno può decifrarla. Levenshtein Distanza di 15. Eseguilo in fanh.


Immagino di dover imparare Fantom ...
AboveFire


3

screpolato

CJam, 6 caratteri

25mse7

Uscita originale

-1323517.5009777304

Uscita modificata

72004899337.38588

Questo potrebbe essere troppo facile. : P


Cracked? L'output è leggermente diverso nel mio browser (e completamente diverso con l'interprete Java).
Dennis,

@Dennis Non sono del tutto sicuro del perché, ma le modifiche sono corrette.
The_Basset_Hound l'

3

screpolato

Java, 149 personaggi

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

Uscita originale

174542852132661

Uscita modificata

106906909674100

Suggerimento:

Random.java



3

Brainfuck, 100 byte

Codice

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

Uscita originale

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Uscita modificata

[
  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ

Nota: possibilmente facile da decifrare. Ma poi, niente è facile in Brainfuck.


2
Ci sono caratteri non stampabili nell'output?
Sp3000,

Sembra che alcuni siano stati mangiati ma ci sono ancora molti non stampabili quando provo a copiare e incollare, quindi presumo che sia così
Sp3000,

@ Sp3000 Er- no, non dovrebbero esserci stampabili. Quale interprete stai usando?
Kurousagi,

Il metodo non è uguale al mio, continua a provare.
Kurousagi,

5
Se riesci a pubblicare i codici ASCII effettivi dell'output sarebbe fantastico.
Alex Van Liew,

3

screpolato

moderno Perl 5, 70

Codice

@array = (qw smiles) x 11;
s/.*// foreach @array;
print "@array\n";

Uscita originale

Una sola nuova riga.

Uscita modificata

 mile mile mile mile mile mile mile mile mile mile

L'output inizia con uno spazio e termina con una nuova riga.


@AlexVanLiew Nota che c'è uno spazio prima del primo m!
Dennis,

@Dennis Oh no! Sapevo che non poteva essere così semplice.
Alex Van Liew,

Non ne sono sicuro, ma penso di averlo ...
Dom Hastings,

@DomHastings Yep! Ben risolto Come qualcuno ha commentato la tua soluzione, il personaggio aggiuntivo può essere uno spazio extra ovunque. Ho detto Perl 5 "moderno" perché si eachapplica a un array solo da qualche versione.
msh210,

2
Se non l'avesse rotto, avresti detto "perso per un miglio"? : D
mbomb007,


3

perl, 12 byte

screpolato

Codice

print sin 97

Uscita originale

0.379607739027522

Uscita desiderata

-0.64618863474386

1
Posso confermare che è quasi certamente non print sin xx, print sin xx97o print sin 97xxdove xxè due numeri.
Alex Van Liew,


@DomHastings davvero - ben fatto. Per interesse, come hai fatto?
circa

3
Dopo aver letto il commento di @ AlexVanLiew, ho provato un numero simile 9.?7, 9.7?ecc, ma si rese conto che doveva essere un operatore. Ho provato tutto ciò che riuscivo a pensare in frammenti come perl -e 'print map{sin((+"9${_}")x7).$/}1..9'alla fine ho ottenuto la giusta combinazione!
Dom Hastings,

@DomHastings ha tardato +1 per il tuo crack allora.
circa

3

screpolato

SWI-Prolog, 54 byte

Codice

assert(d(E,F):-(print(E),print(F))). d(123456,123456).

Uscita originale

true.

123456123456
true.

Uscita modificata

true.

false.

Ho provato a far funzionare un interprete SWI-Prolog l'altro giorno, ma non ci sono riuscito, quindi mi prenderò una pugnalata nel buio; se rimuovi il Ee Fnelle printdichiarazioni ottieni quello che vuoi?
Alex Van Liew,

@AlexVanLiew Ricevo errori di sintassi da questo
Sp3000,

@AlexVanLiew errato
Fatalizza il

Ah bene. Vale un tentativo.
Alex Van Liew,

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.