AVIS - Ce défi est maintenant fermé. Toute nouvelle réponse sera ignorée et la réponse acceptée ne changera pas

Défi

Ecrivez un programme valide qui, lorsque seulement deux caractères du programme sont modifiés, supprimés ou ajoutés, modifie complètement la sortie.

La sortie modifiée doit avoir une distance de Levenshtein de 15 ou plus par rapport à votre sortie d'origine.

La sortie doit être non vide et finie. Votre programme doit donc se terminer dans la minute qui suit.

Votre sortie doit être déterministe, en produisant la même chose chaque fois que vous exécutez le programme. Il ne doit pas non plus dépendre de la plate-forme.

Toutes les fonctions de hachage sont interdites , comme cela est construit dans les PRNG. De même, l'ensemencement d'un RNG n'est pas autorisé.

Après une période de trois jours, une soumission non fissurée sera sécurisée. Afin de réclamer cette sécurité, vous devez modifier votre réponse pour indiquer la réponse correcte. (Précision: jusqu'à ce que vous révéliez la réponse, vous n'êtes pas en sécurité et vous pouvez toujours être fissuré.)

Mise en page

Votre réponse devrait être dans le format suivant:

# <Language name>, <Program length>

## Code

<code goes here>

## Original Output

<output goes here>

## Changed output

<changed output goes here>

Voleurs

Le défi des voleurs est de savoir quels sont les deux personnages que vous avez changés. Si un voleur a craqué votre solution, ils laisseront un commentaire sur votre réponse.

Vous pouvez trouver le fil des voleurs ici .

Gagnant

La personne avec la solution la plus courte non fissurée gagne.

Classement

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

CJam, 13 octets (sûr)

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

Essayez-le en ligne.

Sortie originale

000010010101001010001101111000111011100110100100001011101101010100011111110010010010001111111111010000010011001110001010011111000010001001110111100000010110000010000111011011110101110010000011100111100

Sortie modifiée

11101101100011110001011010000100111011000010011101100000001010100111011010011011010111101000000011101111100000000110001000111110110110101111110100101110000101110100110011110000010101110

Solution

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

Essayez-le en ligne.

Comment ça fonctionne

Ceci profite de la façon dont CJam imprime implicitement la pile entière après l'exécution du programme.

Le simple fait de vider les représentations en base 2 de quelques entiers de la pile entraîne leur impression sans séparateur. Il devrait donc être difficile de savoir où commence l’une d’entre elles et où se termine l’autre.

Le code original fait ce qui suit:

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#

Comme @AndreaBiondo le note dans les commentaires, les représentations binaires de 0! à 8! peut être trouvé au début de la sortie (espaces ajoutés pour plus de clarté):

1 1 10 110 11000 1111000 1011010000 1001110110000 1001110110000000

La modification envisagée consistait à remplacer mQpar ci, qui prend l'entier modulo 65536, en utilisant une arithmétique de 16 bits (transtypage en un caractère de 16 bits non signé, puis en un entier).

J'espérais que l'idée d'utiliser cpour remplacer un opérateur mathématique serait assez obscure.

Fissuré

Shakespeare, 1721 octets

J'ai essayé une réponse de Shakespeare. Ce n’est pas court et j’ai eu du mal à changer la sortie avec seulement 2 caractères, mais je pense que j’ai assez bien réussi. Bonne chance à tous. En remarque, j’ai utilisé le "compilateur" disponible à cette adresse et il se peut que cela ne fonctionne pas avec un autre. (cela ne fonctionne pas avec l'interpréteur en ligne) La sortie ne contient aucun caractère non imprimable.

Code

Le changement caché.

Helen, une jeune femme avec une patience remarquable.
Helena, également jeune femme d'une grâce remarquable.
Claudio, un homme remarquable beaucoup en conflit avec Claudius.
Claudius, le flatteur.
L'archevêque de Canterbury, l'inutile.


          Acte I: Les injures et les flatteries de Claude.

          Scène I: Les insultes de Helen.

[Entre Claude et Hélène]

Claudius:
 Tu es aussi velue que la somme d'un horrible horrible dégoûtant 
 vieux chat pourri gras recouvert de poussière et une grosse guerre maudite sale.
 Tu es aussi stupide que le produit de toi et une graisse malodorante 
 fils faible, misérable et vilain

[Exeunt]

          Scène II: Les compliments d'Helena.

[Entrez Claudio et Helena]

Claudio:
 Tu es l'incroyable ensoleillement fier fier sain paix paisible.
 Tu es aussi incroyable que le produit de toi et la jolie
 belle jeune belle belle riche riche. Tu es aussi grand
 comme la somme de toi et le produit d'un prompt doré juste bon honnête 
 charmant roi noble aimant et un ange doré lisse et riche brodé.

[Exeunt]

          Scène III: Les insultes de Claudio

[Entre Claude et Hélène]

Helen:
 Tu es aussi stupide que la somme de la somme de toi, d'un chat et de moi.
[Sortie Helen]

[Entrez Claudio]

Claudius:
 Tu es aussi stupide que la somme de toi et le produit du 
 produit de moi et Helen et Helena

[Exeunt]

          Scène IV: Le compte à rebours final

[Entrer l'archevêque de Cantorbéry et Claude]

Claudius:
 Tu es la somme de toi et d'un chat.

L'archevêque de Cantorbéry:
 Suis-je meilleur qu'une belle route?

Claudius:
 Sinon, revenons à l'insulte de Claudio.

[Sortir l'archevêque de Cantorbéry]

[Entrez Claudio]

Claudius:
 Ouvrir votre cœur!
 Ouvrir votre cœur!
[Exeunt]

Sortie d'origine

11324620811132462081

Sortie modifiée

11

J, 76 octets (sûr)

Code

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

Sortie d'origine

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

Sortie modifiée

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

EDIT: Solution {:ajoutée (affichée entre ###)

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

Utilise la {::carte de la monade . La majeure partie du reste du code est une foutaise inutile.

Fissuré

Ruby, 14 ans

Code

x=9;puts x*9*9

Sortie d'origine

729

Sortie modifiée

99999999999999999

Fissuré

Bash, 15 octets

echo {{{1..9}}}

Sortie originale

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

Sortie modifiée

1 2 3 4 5 6 7 8 9

Fissuré

Prolog, 10 octets

Code

X is 1/42.

Sortie d'origine

X = 0.023809523809523808.

Sortie modifiée

X = -2.

Fissuré

Python 2, 43 octets

Code

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

Sortie d'origine

334960491355406

Sortie modifiée

222084148077792

La distance de Levenshtein est de 15 exactement. L'original et le fichier modifié durent moins d'une minute sur mon ordinateur.

Fissuré

BrainFuck, 504 octets

Personne ne devrait jamais avoir besoin d'analyser un code brainfuck. Il s'agit d'une version modifiée d'un code antérieur, mais toute modification apportée à un code Brainfuck fait une grande différence dans la sortie. J'utilise l'interpréteur à l' adresse http://esoteric.sange.fi/brainfuck/impl/interp/i.html pour tester mon code. Bonne chance !

Code

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

Sortie d'origine

 ___
/   \
|   |
\___/

Sortie modifiée

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

Remarque: La sortie modifiée contient plusieurs caractères STX (ASCII 2) et EOT (ASCII 4).

Voici la version avec des codes ASCII entre parenthèses au lieu de caractères non imprimables:

(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)|///\

fissuré

Wolfram Language (Mathematica ou WolframAlpha), 3 octets

Code

8.!

Sortie d'origine

40320.

Sortie modifiée

2.67182 - 0.891969 I

Pour ceux qui l’essaient sur WolframAlpha, le résultat est le suivant:

J'ai supprimé ma réponse précédente car cela ne fonctionnait que sur Mathematica et non sur WolframAlpha . Cela a mis les voleurs derrière un paywall (au lieu des bars mérités), ce qui n’était pas juste.

Fissuré

MATLAB / OCTAVE, 7 octets

Code:

cos(pi)

Sortie originale:

ans =

     -1

Sortie modifiée:

ans =

   1.5708 - 0.8814i

Cela donne une distance de Levenshtein d’exactement 15.

Fissuré

CJam, 8 personnages

Code

"~f":i:#

Sortie originale

17290024234092933295664461412112060373713158853249678427974319674060504032816100667656743434803884485234668769970047274563123327020396104330878852891146011372048615474145637592955298601510765168228550988848615653376

Sortie modifiée

La sortie après modification est ici . Les deux prennent moins d'une minute sur mon ordinateur portable 2GHz.

Explication

Les gens semblent étonnés de voir comment cela fonctionne. Le code fonctionne comme ceci:

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

Ceci calcule 126 ^ 102. La solution était:

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

Ceci calcule ((125 ^ 9) ^ 126) ^ 102, ce qui correspond à des centaines de milliers de chiffres.

Fissuré

Pyth, 8 octets

Code:

%CG^3y21

Sortie initiale:

51230235128920219893

Sortie modifiée:

58227066

Fissuré

Python 2, 58 octets

Code

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

Sortie d'origine

2444542772018013876036977350299418162656593659528311114655474359757543862791958572561591492595632222632192542272836836649846934427359810217936317967768095940470375690509652583392001888886352103127515963142

Sortie modifiée

4669

Cette règle de distance rendait les choses difficiles. J'espère que ça va bien.

Fissuré

Python 2, 50 octets

Code d'origine:

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

Sortie d'origine:

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

Sortie modifiée:

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

Pas trop court, et peut-être pas trop dur, je ne sais pas vraiment. Je vais essayer de trouver quelque chose de mieux bientôt.

Fissuré

PHP, 164 octets

Code

$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;

Sortie d'origine

2

Sortie modifiée

-1.1306063769532

GolfScript, 15 octets (sûr)

Code

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

Code modifié

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

Sortie d'origine

47784725839872000000

Sortie modifiée

557154

Explications:

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

Code modifié

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)

Fissuré

APL , 7 octets

Code

-/3⍴157

Sortie originale

157

Sortie modifiée

0.11479360684269167J0.37526348448410907

Fissuré

C, 53 octets

Code

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

Sortie d'origine

Expected Output

Sortie modifiée

?

Probablement trop facile, mais qui sait. (Remarque: cela dépend techniquement du système, mais le type de système sur lequel il échoue échouerait également pour toutes les autres soumissions présentées ici, alors j’ai pensé que c’était un point discutable).

Fissuré

Modifier

J'ai fait une erreur. Nouveau code qui est plus sécurisé à l'attaque évidente:

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

mêmes sorties. Nouvelle taille de 65 octets. Espérons que ce sera plus difficile ... mais probablement encore trop facile.

Fissuré par issacg

MATLAB, 20 octets

Code

format long
sin(i^pi)

Sortie d'origine

0.331393418243797 - 1.109981778186163i

Sortie modifiée

0.220584040749698 - 0.975367972083631i

Fissuré

Octave, 20 octets

format long;
cos(1)*1

Sortie:

0.540302305868140

Sortie modifiée:

111

CJam, 28 octets (sûr)

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

Essayez-le en ligne .

Sortie originale

7705397905065379035618588652533563996660018265606606763127193120855297133322151462150247488267491212817218321670720380456985476811737021068519164822984561148339610474891720342171053455881107227302663880445203851079295537592154028123394687360216561235621729967011148112746984677807932995700334185726563970223018774

Sortie modifiée

16650180159137697345989048346412185774444335111603430666402604460993564226370500963166158223117360250140073061887053326627468495236957122711656527124216908303912850181595147494475577084810653496778801228980874902968634143062

Solution

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

Essayez-le en ligne.

Comment ça fonctionne

Je suis allé un peu à la mer avec celui-ci ...

Le code original fait ce qui suit:

"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.

Le changement prévu remplace (ipar Wci.

Cela laisse la chaîne répétée intacte et pousse 65535 (en convertissant en un caractère de 16 bits non signé, puis de nouveau en entier), de sorte que les premiers éléments de la séquence de Fibonacci en retard deviennent

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

et la boucle est répétée 126 fois.

Javascript, 47 (sûr)

Code

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

Sortie d'origine

11.948938595656971

Sortie modifiée

3.679331284911481

La distance est exactement 15.

Testé dans Chrome et IE.

Solution

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

Ceci utilise l'opérateur d'assignation de décalage de bits i>>=1pour rendre l'intervalle de boucle non linéaire. De plus, cela a la propriété amusante que quelqu'un qui essaie de forcer brutalement une solution rencontrera plusieurs variations infinies.

Fissuré

Fantom , 26 ans

Code

Float.makeBits(1123581321)

Sortie d'origine

5.55122931E-315

Sortie modifiée

124.24518585205078

La sécurité par l'obscurité, si personne ne connaît la langue, personne ne peut la déchiffrer. Levenshtein Distance de 15. Exécutez-le dans fansh.

Fissuré

CJam, 6 personnages

25mse7

Sortie originale

-1323517.5009777304

Sortie modifiée

72004899337.38588

Cela pourrait être trop facile. : P

Fissuré

Java, 149 caractères

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

Sortie d'origine

174542852132661

Sortie modifiée

106906909674100

Allusion:

Random.java

Brainfuck, 100 octets

Code

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

Sortie originale

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Sortie modifiée

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

Remarque: Peut-être facile à craquer. Mais alors, rien n'est facile dans Brainfuck.

fissuré

Perl moderne 5, 70

Code

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

Sortie d'origine

Une nouvelle ligne.

Sortie modifiée

 mile mile mile mile mile mile mile mile mile mile

La sortie commence par un espace et se termine par une nouvelle ligne.

Fissuré

Matlab, 12 octets

Code

-sin(2:.5:3)

Sortie originale

-0.9093   -0.5985   -0.1411

Sortie modifiée

0.4228    0.7032    0.9228

perl, 12 octets

fissuré

Code

print sin 97

Sortie originale

0.379607739027522

Sortie désirée

-0.64618863474386

Fissuré

SWI-Prolog, 54 octets

Code

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

Sortie d'origine

true.

123456123456
true.

Sortie modifiée

true.

false.