HINWEIS - Diese Herausforderung ist jetzt geschlossen. Alle neuen Antworten werden ignoriert und die akzeptierte Antwort wird nicht geändert

Herausforderung

Schreiben Sie ein gültiges Programm, das die Ausgabe vollständig ändert, wenn nur zwei Zeichen im Programm geändert, entfernt oder hinzugefügt werden.

Die geänderte Ausgabe muss einen Levenshtein-Abstand von 15 oder mehr von Ihrer ursprünglichen Ausgabe haben.

Die Ausgabe darf nicht leer und endlich sein. Ihr Programm muss daher innerhalb von 1 Minute beendet sein.

Ihre Ausgabe muss deterministisch sein und bei jeder Ausführung des Programms dasselbe ausgeben. Es darf auch nicht plattformabhängig sein.

Alle Hash-Funktionen sind nicht zulässig , wie sie in PRNGs enthalten sind. Ebenso ist das Aussäen eines RNG nicht erlaubt.

Nach einem Zeitraum von drei Tagen wird eine ungerissene Vorlage sicher. Um diese Sicherheit zu beanspruchen, sollten Sie Ihre Antwort bearbeiten, um die richtige Antwort anzuzeigen. (Klarstellung: Bis Sie die Antwort enthüllen, sind Sie nicht sicher und können immer noch geknackt werden.)

Formatierung

Ihre Antwort sollte in folgendem Format vorliegen:

# <Language name>, <Program length>

## Code

<code goes here>

## Original Output

<output goes here>

## Changed output

<changed output goes here>

Räuber

Die Räuber müssen herausfinden, welche beiden Charaktere Sie geändert haben. Wenn ein Räuber Ihre Lösung geknackt hat, hinterlässt er einen Kommentar zu Ihrer Antwort.

Den Räuberfaden finden Sie hier .

Gewinnen

Die Person mit der kürzesten ungerissenen Lösung gewinnt.

Bestenliste

<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 Bytes (sicher)

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

Probieren Sie es online aus.

Originalausgabe

000010010101001010001101111000111011100110100100001011101101010100011111110010010010001111111111010000010011001110001010011111000010001001110111100000010110000010000111011011110101110010000011100111100

Geänderte Ausgabe

11101101100011110001011010000100111011000010011101100000001010100111011010011011010111101000000011101111100000000110001000111110110110101111110100101110000101110100110011110000010101110

Lösung

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

Probieren Sie es online aus.

Wie es funktioniert

Dadurch wird ausgenutzt, wie CJam nach Ausführung des Programms implizit den gesamten Stapel druckt.

Durch einfaches Ablegen der Basis-2-Darstellungen einiger ganzer Zahlen auf dem Stapel werden sie ohne Trennzeichen gedruckt. Daher sollte es schwierig sein, herauszufinden, wo eine von ihnen beginnt und eine andere endet.

Der ursprüngliche Code führt Folgendes aus:

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#

Wie @AndreaBiondo in den Kommentaren festhält, sind die binären Darstellungen von 0! bis 8! finden Sie am Anfang der Ausgabe (Leerzeichen zur Verdeutlichung hinzugefügt):

1 1 10 110 11000 1111000 1011010000 1001110110000 1001110110000000

Die beabsichtigte Änderung war zu ersetzen , mQmit ci, der die ganze Zahl modulo 65536 nimmt, 16-Bit - Zeichen - Arithmetik (Gießen auf ein vorzeichenlose 16-Bit - Zeichen, dann zurück zu integer).

Ich hoffte, dass die Idee c, einen mathematischen Operator zu ersetzen, undurchsichtig genug wäre.

Geknackt

Shakespeare, 1721 Bytes

Ich versuchte es mit einer Shakespeare-Antwort. Es ist nicht kurz und ich hatte Schwierigkeiten, die Ausgabe mit nur 2 Zeichen zu ändern, aber ich denke, es ist mir ganz gut gelungen. Viel Glück euch allen. Als Randnotiz habe ich den "Compiler" verwendet, der unter dieser Adresse verfügbar ist, und er funktioniert möglicherweise nicht mit einem anderen. (Funktioniert nicht mit dem Online-Interpreter.) Die Ausgabe enthält keine nicht druckbaren Zeichen.

Code

Die versteckte Veränderung.

Helen, eine junge Frau mit einer bemerkenswerten Geduld.
Helena, eine ebenfalls junge Frau von bemerkenswerter Anmut.
Claudio, ein bemerkenswerter Mann, der mit Claudius viel zu tun hat.
Claudius, der Schmeichler.
Der Erzbischof von Canterbury, der Nutzlose.


          Akt I: Claudius Beleidigungen und Schmeichelei.

          Szene I: Die Beleidigung von Helen.

[Claudius und Helen treten auf]

Claudius:
 Du bist so haarig wie die Summe eines ekelhaften schrecklichen Waisen 
 staubige alte faule fettnierige Katze und ein großer schmutziger verfluchter Krieg.
 Du bist so dumm wie das Produkt von dir und stinkst fett 
 halbwitziger schmutziger elender gemeiner schwacher Sohn.

[Exeunt]

          Szene II: Das Kompliment von Helena.

[Claudio und Helena treten auf]

Claudio:
 Du bist die sonnige, erstaunliche, stolze, gesunde, friedliche, süße Freude.
 Du bist so erstaunlich wie das Produkt von dir und dem Hübschen
 reizender junger sanfter stattlicher reicher Held. Du bist so großartig
 als die Summe von dir und dem Produkt eines gerechten goldenen Triebes gut ehrlich 
 charmanter liebevoller edler König und ein gestickter reich glatter goldener Engel.

[Exeunt]

          Szene III: Die Beleidigung von Claudio

[Claudius und Helen treten auf]

Helen:
 Du bist so dumm wie die Summe der Summe von dir und einer Katze und mir.
[Ausfahrt Helen]

[Claudio kommt herein]

Claudius:
 Du bist so dumm wie die Summe von dir und dem Produkt von 
 Produkt von mir und Helen und Helena

[Exeunt]

          Szene IV: Der letzte Countdown

[Betreten Sie den Erzbischof von Canterbury und Claudius]

Claudius:
 Du bist die Summe von dir und einer Katze.

Der Erzbischof von Canterbury:
 Bin ich besser als eine gute Straße?

Claudius:
 Wenn nicht, kehren wir zur Beleidigung Claudios zurück.

[Verlassen Sie den Erzbischof von Canterbury]

[Claudio kommt herein]

Claudius:
 Öffne dein Herz!
 Öffne dein Herz!
[Exeunt]

Originalausgabe

11324620811132462081

Ausgabe geändert

11

J, 76 Bytes (sicher)

Code

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

Originalausgabe

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

Ausgabe geändert

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

EDIT: Lösung {:hinzugefügt (angezeigt zwischen ###)

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

Nutzt die Monade {::Karte . Der Rest des Codes ist größtenteils unnützer Müll.

Geknackt

Rubin, 14

Code

x=9;puts x*9*9

Originalausgabe

729

Ausgabe geändert

99999999999999999

Geknackt

Bash, 15 Bytes

echo {{{1..9}}}

Originalausgabe

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

Geänderte Ausgabe

1 2 3 4 5 6 7 8 9

Geknackt

Prolog, 10 Bytes

Code

X is 1/42.

Originalausgabe

X = 0.023809523809523808.

Ausgabe geändert

X = -2.

Geknackt

Python 2, 43 Bytes

Code

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

Originalausgabe

334960491355406

Ausgabe geändert

222084148077792

Die Levenshtein Entfernung beträgt genau 15. Sowohl das Original als auch das Geänderte laufen auf meinem Computer unter 1 Minute.

Geknackt

BrainFuck, 504 Bytes

Niemand sollte jemals einen Brainfuck-Code analysieren müssen. Dies ist eine modifizierte Version eines früheren Codes, aber jede Änderung an einem Brainfuck-Code hat einen großen Einfluss auf die Ausgabe. Ich benutze den Interpreter unter http://esoteric.sange.fi/brainfuck/impl/interp/i.html , um meinen Code zu testen. Viel Glück !

Code

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

Originalausgabe

 ___
/   \
|   |
\___/

Ausgabe geändert

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

Hinweis: Die geänderte Ausgabe enthält mehrere STX- (ASCII 2) und EOT- (ASCII 4) Zeichen

Hier ist die Version mit ASCII-Codes in Klammern anstelle von nicht druckbaren Zeichen:

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

geknackt

Wolfram Language (Mathematica oder WolframAlpha), 3 Bytes

Code

8.!

Originalausgabe

40320.

Ausgabe geändert

2.67182 - 0.891969 I

Für diejenigen, die es auf WolframAlpha ausprobieren, wird das Ergebnis als angezeigt

Ich habe meine vorherige Antwort gelöscht, da sie nur in Mathematica und nicht in WolframAlpha funktioniert hat . Das brachte Räuber hinter eine Paywall (anstelle der verdienten Bars), was nicht fair war.

Geknackt

MATLAB / OCTAVE, 7 Bytes

Code:

cos(pi)

Originalausgabe:

ans =

     -1

Geänderte Ausgabe:

ans =

   1.5708 - 0.8814i

Dies ergibt einen Levenshtein-Abstand von genau 15.

Geknackt

Jam, 8 Zeichen

Code

"~f":i:#

Originalausgabe

17290024234092933295664461412112060373713158853249678427974319674060504032816100667656743434803884485234668769970047274563123327020396104330878852891146011372048615474145637592955298601510765168228550988848615653376

Ausgabe geändert

Die Ausgabe nach Änderung erfolgt hier . Beides dauert auf meinem 2-GHz-Laptop weniger als eine Minute.

Erläuterung

Die Leute scheinen erstaunt zu sein, wie das funktioniert. Der Code funktioniert so:

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

Dies berechnet 126 ^ 102. Die Lösung war:

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

Dies berechnet ((125 ^ 9) ^ 126) ^ 102, was Hunderttausenden von Ziffern entspricht.

Geknackt

Pyth, 8 Bytes

Code:

%CG^3y21

Ausgangsleistung:

51230235128920219893

Geänderte Ausgabe:

58227066

Geknackt

Python 2, 58 Bytes

Code

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

Originalausgabe

2444542772018013876036977350299418162656593659528311114655474359757543862791958572561591492595632222632192542272836836649846934427359810217936317967768095940470375690509652583392001888886352103127515963142

Ausgabe geändert

4669

Diese 15-Distanz-Regel machte die Sache sicher schwierig. Ich hoffe das geht gut.

Geknackt

Python 2, 50 Bytes

Ursprünglicher Code:

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

Originalausgabe:

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

Geänderte Ausgabe:

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

Nicht allzu kurz und vielleicht auch nicht zu hart, ich weiß es nicht wirklich. Ich werde versuchen, bald etwas Besseres zu finden.

Geknackt

PHP, 164 Bytes

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;

Originalausgabe

2

Ausgabe geändert

-1.1306063769532

GolfScript, 15 Bytes (sicher)

Code

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

Code geändert

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

Originalausgabe

47784725839872000000

Ausgabe geändert

557154

Erklärungen:

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 geändert

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)

Geknackt

APL , 7 Bytes

Code

-/3⍴157

Originalausgabe

157

Ausgabe geändert

0.11479360684269167J0.37526348448410907

Geknackt

C 53 Bytes

Code

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

Originalausgabe

Expected Output

Ausgabe geändert

?

Wahrscheinlich zu einfach, aber wer weiß. (Hinweis: Es ist technisch systemabhängig, aber die Art des Systems, auf dem es fehlschlägt, würde auch alle anderen Einreichungen hier fehlschlagen. Ich dachte, es ist ein strittiger Punkt.)

Geknackt

Bearbeiten

Ich machte einen Fehler. Neuer Code, der vor offensichtlichen Angriffen sicherer ist:

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

gleiche Ausgänge. Neue Größe von 65 Bytes. Hoffentlich schwieriger ... obwohl es wahrscheinlich immer noch zu einfach ist.

Durch issacg geknackt

MATLAB, 20 Bytes

Code

format long
sin(i^pi)

Originalausgabe

0.331393418243797 - 1.109981778186163i

Ausgabe geändert

0.220584040749698 - 0.975367972083631i

Geknackt

Oktave, 20 Bytes

format long;
cos(1)*1

Ausgabe:

0.540302305868140

Geänderte Ausgabe:

111

CJam, 28 Bytes (sicher)

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

Probieren Sie es online aus .

Originalausgabe

7705397905065379035618588652533563996660018265606606763127193120855297133322151462150247488267491212817218321670720380456985476811737021068519164822984561148339610474891720342171053455881107227302663880445203851079295537592154028123394687360216561235621729967011148112746984677807932995700334185726563970223018774

Geänderte Ausgabe

16650180159137697345989048346412185774444335111603430666402604460993564226370500963166158223117360250140073061887053326627468495236957122711656527124216908303912850181595147494475577084810653496778801228980874902968634143062

Lösung

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

Probieren Sie es online aus.

Wie es funktioniert

Ich bin ein wenig über Bord gegangen mit diesem ...

Der ursprüngliche Code führt Folgendes aus:

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

Die beabsichtigte Änderung ersetzt (imit Wci.

Dadurch bleibt die wiederholte Zeichenfolge unangetastet und wird 65535 verschoben (durch Umwandeln in ein 16-Bit-Zeichen ohne Vorzeichen und dann zurück in eine Ganzzahl), sodass die ersten Elemente der verzögerten Fibonacci-Sequenz erhalten werden

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

und die Schleife wird 126 mal wiederholt .

Javascript, 47 (sicher)

Code

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

Originalausgabe

11.948938595656971

Ausgabe geändert

3.679331284911481

Die Entfernung beträgt genau 15.

Getestet in Chrome und IE.

Lösung

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

Dies verwendet den Bitzuweisungsoperator i>>=1, um das Schleifenintervall nichtlinear zu machen. Auch dies hat die amüsante Eigenschaft, dass jemand, der versucht, eine Lösung zu erzwingen, auf mehrere Varianten stößt, die unendlich laufen.

Geknackt

Fantom , 26

Code

Float.makeBits(1123581321)

Originalausgabe

5.55122931E-315

Ausgabe geändert

124.24518585205078

Sicherheit durch Dunkelheit: Wenn niemand die Sprache kennt, kann niemand sie knacken. Levenshtein Abstand von 15. Führen Sie es in fansh.

Geknackt

CJam, 6 Zeichen

25mse7

Originalausgabe

-1323517.5009777304

Ausgabe geändert

72004899337.38588

Das könnte zu einfach sein. : P

Geknackt

Java, 149 Zeichen

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

Originalausgabe

174542852132661

Geänderte Ausgabe

106906909674100

Hinweis:

Random.java

Brainfuck, 100 Bytes

Code

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

Originalausgabe

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Ausgabe geändert

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

Hinweis: Möglicherweise leicht zu knacken. Aber dann ist in Brainfuck nichts einfach.

geknackt

modernes Perl 5, 70

Code

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

Originalausgabe

Eine einzelne Newline.

Ausgabe geändert

 mile mile mile mile mile mile mile mile mile mile

Die Ausgabe beginnt mit einem Leerzeichen und endet mit einer neuen Zeile.

Geknackt

Matlab, 12 Bytes

Code

-sin(2:.5:3)

Originalausgabe

-0.9093   -0.5985   -0.1411

Ausgabe geändert

0.4228    0.7032    0.9228

Perl, 12 Bytes

geknackt

Code

print sin 97

Originalausgabe

0.379607739027522

Gewünschte Ausgabe

-0.64618863474386

Geknackt

SWI-Prolog, 54 Bytes

Code

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

Originalausgabe

true.

123456123456
true.

Ausgabe geändert

true.

false.