Deux fait toute la différence - Cops

60

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>

Beta Decay
la source
@BetaDecay Comment définissez-vous une fonction de hachage?
isaacg
1
@xnor Théoriquement, mais le nombre de possibilités augmente énormément à mesure que la durée du programme augmente et risque donc de prendre beaucoup de temps
Beta Decay
1
@RedPanda Oui, je pense bien
Beta Decay
5
@isaacg J'ai décidé de changer la date du coffre-fort à trois jours
Beta Decay
4
Serait-il possible de mettre le code de classement sur moins de lignes pour qu'il prenne moins de place visuelle?
isaacg

Réponses:

6

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.

Dennis
la source
Sensationnel. Comment trouvez-vous cela?
The_Basset_Hound
J'ai essayé de résoudre ce problème pendant un bon moment. Je compris une partie du motif modifié, mais il me manquait quelque chose. C'est sûr maintenant je suppose.
Andrea Biondo
@AndreaBiondo C'est maintenant. Merci de me le rappeler.
Dennis
@Dennis j'avais compris que _)mQdevait être changé à une f(x!)telle que f(x!) > x!pour x <= 8et f(x!) < x!pour x >= 9, parce x!était évidemment d' être modulo'ed par un nombre qui a quitté les factorielles de 0 à 8 intact dans la sortie. Je n'ai pas remarqué que 9!le premier facteur était plus gros que 2^16. Très beau défi quand même.
Andrea Biondo
39

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
Au-dessus du feu
la source
9
Vraiment merveilleux. Cette histoire m'a fait pleurer.
Alex Van Liew
6
@AlexVanLiew Il m'a fallu beaucoup de temps pour écrire. C'est mon chef d'oeuvre!
AboveFire
1
Fissuré !
Plannapus
Très belle réponse
fier haskeller
24

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.

Fataliser
la source
Notez que je pourrais certainement prolonger le code d'un nombre ridicule de caractères pour rendre plus difficile la recherche du ou des emplacements où les deux caractères doivent être ajoutés / supprimés / modifiés
Fatalize
Je pense que cela fait 3 jours pour celui-ci, donc si vous postez la réponse, vous êtes en sécurité.
isaacg
@isaacg Corrigez, modifiez la réponse
Fatalisez
12

Fissuré

Ruby, 14 ans

Code

x=9;puts x*9*9

Sortie d'origine

729

Sortie modifiée

99999999999999999
histocrate
la source
4
Cela a l'air si innocent. J'ai essayé et j'ai essayé, mais je ne sais pas où obtenir le 17 ...
Dennis
1
Je pensais que c'était 18 9s, alors je voulais quelque chose comme '99'*2. wc, tu m'as trahi!
Alex Van Liew
@ AlexVanLiew 18 serait facile. Blâmez votre shell pour avoir ajouté un saut de ligne.
Dennis
@ Dennis Comment le feriez-vous avec 18 ans? Je ne pouvais pas le comprendre (mais je ne connais pas non plus Ruby).
Alex Van Liew
6
Craqué
Razvan
12

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
Dennis
la source
Cracked
samgak
2
Bien joué. Cela dura plus longtemps que je ne le pensais.
Dennis
10

Fissuré

Prolog, 10 octets

Code

X is 1/42.

Sortie d'origine

X = 0.023809523809523808.

Sortie modifiée

X = -2.
Fataliser
la source
Cracked
Sp3000
2
Pour une raison quelconque, j'ai totalement négligé le fait que cela peut également être résolu comme ceci X is 1//4-2.:, ce qui est beaucoup plus facile à voir que ma solution d'origine que @ sp3000 a craqué ...
Fatalize
10

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.

Bleu
la source
1
J'ai modifié votre message pour indiquer qu'il s'agit d'une soumission spécifique à Python 2, en raison des parenthèses manquantes printet de la multiplication rangepar un entier. Cependant, il semble que je sois en train MemoryErrorde
tirer un sort
1
Puisque ce n'est pas du code golf, vous pouvez réduire la charge de mémoire en utilisant à la xrangeplace de rangeet je pense itertoolsavoir un générateur-générateur qui répète un xnombre de séquence de fois.
Alex Van Liew
1
@AlexVanLiew Mais la notation est un code-golf dans un sens, le plus court non fissuré. Cela dit, il y a un espace inutile et une paire de parens ... ou sont-ils nécessaires? ;)
Sp3000
2
OMI, cette réponse ne semble pas très intéressante si elle ne repose que sur une modification des chiffres (nous ne savons pas si c'est le cas), car dans ce cas, vous pouvez probablement faire plus court et le seul moyen de faire craquer par force brute, pas d'esprit.
Fataliser
3
Fissuré. C'était amusant!
isaacg
8

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)|///\
Au-dessus du feu
la source
3
Tu es cruel. Mais je vais le trouver!
RedPanda
@RedPanda Mon code a une structure. Au moins ce n'est pas aléatoire! Bonne chance!
AboveFire
y a-t-il des non imprimables dans la sortie?
fier haskeller
@proudhaskeller Oui, désolé, je vais éditer le post, il y a un tas de caractères STX (ASCII 2) et EOT (ASCII 4)
AboveFire
1
cracked codegolf.stackexchange.com/a/54515/20370
fier haskeller
8

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:

Mathematica graphiques

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.

Dr. belisarius
la source
@abligh Nice! :)
Dr. belisarius
1
Quelle était la réponse de l'autre? Je suis très curieux.
Brain Guider
7

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.

Stewie Griffin
la source
Fissuré.
David Zhang
3
Le gros conseil pour moi était de constater que la partie réelle de votre production modifiée est pi / 2. À partir de là, il n’était pas difficile de deviner la solution.
David Zhang
7

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.

Lynn
la source
6
C'est criminel.
Alex Van Liew
Qu'est-ce que ... je veux vraiment savoir comment cela fonctionne! ;)
Beta Decay
Fissuré.
Dennis
@BetaDecay Je pourrais expliquer comment l'original fonctionne mais pas la version de Dennis. Je me demande comment Mauris voulait le résoudre ...
Alex Van Liew
Bananes sacrées! WTF!
Brain Guider
7

Fissuré

Pyth, 8 octets

Code:

%CG^3y21

Sortie initiale:

51230235128920219893

Sortie modifiée:

58227066
isaacg
la source
1
La sortie modifiée est égale CG mod (2^21 * 28). Je ne connais pas Pyth, donc je ne vois pas comment changer (3 ^ (2 * 21))cela ...
Lynn
1
Aussi, CGégal sum(256**n * (122-n) for n in range(26)).
Lynn
1
La sortie modifiée est égale à CG mod (2^21 * 28 * 2*n), où 1 <= n <= 4, ainsi que pour n=6et n=12. En outre, CGl'alphabet minuscule est simplement interprété comme un nombre de base 256. Je me demande s'il y a un autre modulo avec la base 3?
Alex Van Liew
%CG^2 26ou %CG^4y13, mais les deux ont une distance de 3 ...
Jakube
Fissuré?
Dennis
6

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.

Sp3000
la source
Le fait que 4669 = 667 * 7 et que le dernier élément de la plage (01234) soit 667 m'est suspect ...
Fatalize
Si vous imprimez [m<<min(m,n)for m in R for n in R]dans l'interprète, vous obtenez des motifs très fantasmagoriques de bruit blanc.
Alex Van Liew
3
Fissuré.
jimmy23013
6

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.

rp.beltran
la source
Est-ce que 40 tildes et ensuite 19 tildes? Et je suppose que cela se passe dans l'interprète?
Alex Van Liew
Craqué , je pense
Alex Van Liew
2
Un résumé de ce que j’ai trouvé jusqu’à présent: aucune combinaison de remplacement xpar y, yde xou de modification du chiffre dans le rangerésultat dans 19 tildes. J'ai également essayé d'insérer un -avant xou y, et de passer %à l'un des + - / *, en vain. Je suis à peu près certain qu’un ou deux inserts sont nécessaires.
mbomb007
1
Ok, mon premier lien le déchire maintenant correctement.
Alex Van Liew
2
J'ai ajouté une petite explication, je pense en fait que celle-ci était vraiment intelligente. Je ne sais pas si j'ai jamais vu une compréhension d'ensemble, et me fier également à la fuite de Python ydans le champ d'application ci-joint était une délicate attention.
Alex Van Liew
6

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
Razvan
la source
Cracked
Dennis
Bien joué! Je ne pensais pas que ce serait si facile d'être craqué.
Razvan
6

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)
Baconaro
la source
Je crois que c'est sûr maintenant, donc si vous souhaitez modifier votre post
Beta Decay
@BetaDecay je suis!
Baconaro
5

Fissuré

APL , 7 octets

Code

-/3⍴157

Sortie originale

157

Sortie modifiée

0.11479360684269167J0.37526348448410907
Lynn
la source
Est-ce que Jla preuve de sortie indique qu'il s'agit d'un nombre complexe?
mbomb007
@ mbomb007 Oui, aJbfait référence au nombre complexe a + bi.
Dennis
Cracked
Dennis
4

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.

LambdaBeta
la source
Cracked
Jakube
Cracked
TheNumberOne
2
(note latérale - cela aurait probablement dû être deux réponses)
Sp3000
@ Sp3000 Vous avez peut-être raison, bien que l'objectif de l'original soit d'avoir la même solution, je me suis trop concentré sur le problème de l'intrus * compte (où vous pouvez transformer celui du milieu en /) et je n'ai pas considéré le plus facile * 0 changement.
LambdaBeta
4

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
Jonas
la source
J'ai essayé un tas d'idées dans l'interprète Octave en ligne. Toujours rien. J'ai essayé des choses comme l' utilisation sinh, asin, tan, pi^i, etc ...
mbomb007
@ mbomb007 - Je suis perdu ici aussi ... et je suis le 5ème meilleur sur StackOverflow dans MATLAB en général!
rayryeng - Réintégrer Monica
Cracked
isaacg
4

Fissuré

Octave, 20 octets

format long;
cos(1)*1

Sortie:

0.540302305868140

Sortie modifiée:

111
Daniel
la source
1
Cracked
Dennis
Note: Ceci est seulement : Octave, pas "Octave / MATLAB", ce qui est souvent le cas.
Stewie Griffin
4

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.

Dennis
la source
C'est sûr maintenant, n'est-ce pas?
Beta Decay
@ BetaDecay J'ai utilisé à peu près la même astuce dans les deux réponses de CJam, j'ai donc dû attendre pour pouvoir poster les deux solutions en même temps. C'est sûr maintenant.
Dennis
Une fois que j'ai trouvé ce que c'était, j'ai réalisé qu'il y avait tellement de choses qui pourraient être modifiées que je ne me suis même pas donné la peine d'essayer de forcer
brutalement
4

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.

SLuck49
la source
3

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.

Caïn
la source
Je suppose que j'ai besoin d'apprendre Fantom ...
AboveFire
2
Fissuré.
Alex Van Liew
3

Fissuré

CJam, 6 personnages

25mse7

Sortie originale

-1323517.5009777304

Sortie modifiée

72004899337.38588

Cela pourrait être trop facile. : P

The_Basset_Hound
la source
Fissuré? La sortie est légèrement différente dans mon navigateur (et totalement différente avec l'interpréteur Java).
Dennis
@ Dennis Pas tout à fait sûr pourquoi, mais les changements sont corrects.
The_Basset_Hound
3

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

Le numéro un
la source
Fissuré.
Alex Van Liew
3

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.

Kurousagi
la source
2
Y at-il des caractères non imprimables dans la sortie?
Sp3000
On dirait que quelques-uns ont été mangés, mais il reste encore beaucoup de choses non imprimables lorsque j'essaie de copier / coller, alors je suppose que c'est comme ça
Sp3000
@ Sp3000 Euh non, il ne devrait pas y avoir de non imprimables. Quel interprète utilisez-vous?
Kurousagi
La méthode n'est pas égale à la mienne, soit, continue d'essayer.
Kurousagi
5
Si vous pouvez poster les codes ASCII réels de la sortie, ce serait génial.
Alex Van Liew
3

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.

msh210
la source
@AlexVanLiew Notez qu'il y a un espace avant le premier m!
Dennis
@ Dennis Oh non! Je savais que ça ne pouvait pas être aussi simple.
Alex Van Liew
Je ne suis pas sûr, mais je pense l'avoir ...
Dom Hastings
@DomHastings Oui! Bien résolu. Comme quelqu'un a commenté votre solution, le personnage supplémentaire peut constituer un espace supplémentaire n'importe où. J'ai dit "moderne" Perl 5 car ne eachs'applique à un tableau qu'à partir d'une version.
msh210
2
S'il ne l'avait pas craqué, auriez-vous dit "raté le coup par mille"? : D
mbomb007
3

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
Luis Mendo
la source
Fissuré !
Stewie Griffin
@StewieGriffin Hé, bravo!
Luis Mendo
3

perl, 12 octets

fissuré

Code

print sin 97

Sortie originale

0.379607739027522

Sortie désirée

-0.64618863474386
abligh
la source
1
Je peux confirmer qu'il est presque certainement pas print sin xx, print sin xx97ou print sin 97xxxxest deux nombres.
Alex Van Liew
Fissuré!
Dom Hastings
@DomHastings en effet - bien fait. Par intérêt, comment as-tu fait ça?
abligh
3
Après avoir lu @ commentaire de AlexVanLiew, je l' ai testé un nombre similaire 9.?7, 9.7?, etc, mais réalisé qu'il devait être un opérateur. J'ai essayé tout ce à quoi je pouvais penser dans des extraits comme si j'avais perl -e 'print map{sin((+"9${_}")x7).$/}1..9'finalement la bonne combinaison!
Dom Hastings
@DomHastings tardif +1 pour votre fissure alors.
abligh
3

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.
Fataliser
la source
J'ai essayé de faire travailler un interprète SWI-Prolog l'autre jour mais je n'ai pas pu, alors je vais me lancer dans le noir; si vous supprimez le Eet Fdans les printdéclarations obtenez-vous ce que vous voulez?
Alex Van Liew
@AlexVanLiew J'obtiens des erreurs de syntaxe
Sp3000
@AlexVanLiew Incorrect
Fatalize
Et bien. Ça vaut le coup.
Alex Van Liew
Cracked
mgibsonbr