UWAGA - To wyzwanie jest teraz zamknięte. Wszelkie nowe odpowiedzi zostaną zignorowane, a zaakceptowana odpowiedź nie ulegnie zmianie

Wyzwanie

Napisz prawidłowy program, który, gdy tylko dwa znaki w programie zostaną zmienione, usunięte lub dodane, całkowicie zmieni dane wyjściowe.

Zmieniona moc wyjściowa musi mieć odległość Levenshteina 15 lub więcej od oryginalnej mocy wyjściowej.

Dane wyjściowe muszą być niepuste i skończone. Twój program musi zatem zakończyć się w ciągu 1 minuty.

Twój wynik musi być deterministyczny, generując to samo przy każdym uruchomieniu programu. Nie może również zależeć od platformy.

Wszelkie funkcje skrótu są niedozwolone , podobnie jak wbudowane w PRNG. Podobnie, inicjowanie RNG jest niedozwolone.

Po upływie trzech dni nieprzesłane zgłoszenie stanie się bezpieczne. Aby domagać się tego bezpieczeństwa, należy edytować swoją odpowiedź, aby pokazać poprawną odpowiedź. (Wyjaśnienie: Dopóki nie ujawnisz odpowiedzi, nie jesteś bezpieczny i nadal możesz zostać złamany.)

Formatowanie

Twoja odpowiedź powinna mieć następujący format:

# <Language name>, <Program length>

## Code

<code goes here>

## Original Output

<output goes here>

## Changed output

<changed output goes here>

Rabusie

Wyzwaniem rabusiów jest ustalenie, które dwie postacie zmieniłeś. Jeśli złodziej złamał twoje rozwiązanie, skomentuje twoją odpowiedź.

Wątek złodziei znajdziesz tutaj .

Zwycięski

Osoba z najkrótszym nieskradzionym rozwiązaniem wygrywa.

Tabela liderów

<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 bajtów (bezpieczny)

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

Wypróbuj online.

Oryginalne wyjście

000010010101001010001101111000111011100110100100001011101101010100011111110010010010001111111111010000010011001110001010011111000010001001110111100000010110000010000111011011110101110010000011100111100

Zmodyfikowane wyjście

11101101100011110001011010000100111011000010011101100000001010100111011010011011010111101000000011101111100000000110001000111110110110101111110100101110000101110100110011110000010101110

Rozwiązanie

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

Wypróbuj online.

Jak to działa

Wykorzystuje to sposób, w jaki CJam domyślnie drukuje cały stos po uruchomieniu programu.

Po prostu zrzucenie reprezentacji base-2 kilku liczb całkowitych na stosie powoduje, że są one drukowane bez żadnego separatora, więc trudno będzie ustalić, gdzie jedna z nich się zaczyna, a druga kończy.

Oryginalny kod wykonuje następujące czynności:

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#

Jak zauważa @AndreaBiondo w komentarzach, reprezentacje binarne 0! do 8! można znaleźć na początku danych wyjściowych (dodano spacje dla zachowania przejrzystości):

1 1 10 110 11000 1111000 1011010000 1001110110000 1001110110000000

Zamierzoną zmianą było zastąpienie mQprzez ci, który przyjmuje liczbę całkowitą modulo 65536, przy użyciu arytmetyki 16-bitowych znaków (rzutowanie na 16-bitowy znak bez znaku, a następnie powrót do liczby całkowitej).

Miałem nadzieję, że pomysł czastąpienia operatora matematycznego będzie dość niejasny.

Pęknięty

Szekspir, 1721 bajtów

Próbowałem odpowiedzi Szekspira. Nie jest krótki i miałem trudności ze zmianą wyników za pomocą tylko 2 znaków, ale myślę, że udało mi się całkiem dobrze. Powodzenia wszystkim. Na marginesie użyłem „kompilatora” dostępnego pod tym adresem i może on nie działać z innym. (nie działa z tłumaczem online) Dane wyjściowe nie zawierają żadnych niedrukowalnych znaków.

Kod

Ukryta zmiana.

Helen, młoda kobieta o niezwykłej cierpliwości.
Helena, podobnie młoda kobieta o niezwykłej łasce.
Claudio, niezwykły człowiek dużo spierający się z Claudiusem.
Klaudiusz, pochlebca.
Arcybiskup Canterbury, bezużyteczny.


          Akt I: Obelgi i pochlebstwa Klaudiusza.

          Scena I: Obrażanie Helen.

[Enter Claudius and Helen]

Klaudiusz:
 Jesteś owłosiony jak suma obrzydliwego, okropnego pozbawionego ojca ojca 
 zakurzony stary zgniły gruby nerkowy kot i wielka brudna przeklęta wojna.
 Jesteś tak głupi jak twój produkt i śmierdzący tłuszcz 
 na wpół rozumny, brudny, nieszczęśliwy, podły, słaby syn.

[Exeunt]

          Scena II: Komplement Heleny.

[Enter Claudio and Helena]

Claudio:
 Jesteś słoneczną, niesamowitą, dumną, zdrową, spokojną, słodką radością.
 Jesteś tak niesamowity jak twój i ładny
 śliczny młody łagodny przystojny bogaty bohater. Jesteś wspaniały
 jako suma ciebie i iloczyn uczciwego złotego moneta dobry uczciwy 
 uroczy kochający szlachetny król i haftowany bogaty gładki złoty anioł.

[Exeunt]

          Scena III: Obrażanie Claudio

[Enter Claudius and Helen]

Helen:
 Jesteś głupi jak suma ciebie, kota i mnie.
[Wyjdź z Helen]

[Enter Claudio]

Klaudiusz:
 Jesteś głupi jak suma ciebie i iloczyn 
 produkt mnie i Helen i Heleny

[Exeunt]

          Scena IV: Ostatnie odliczanie

[Wpisz arcybiskupa Canterbury i Klaudiusza]

Klaudiusz:
 Jesteś sumą siebie i kota.

Arcybiskup Canterbury:
 Czy jestem lepszy niż dobra droga?

Klaudiusz:
 Jeśli nie, wróćmy do obrażania Claudio.

[Wyjdź z arcybiskupa Canterbury]

[Enter Claudio]

Klaudiusz:
 Otwórz swoje serce!
 Otwórz swoje serce!
[Exeunt]

Oryginalne wyjście

11324620811132462081

Zmieniono wydajność

11

J, 76 bajtów (bezpieczny)

Kod

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

Oryginalne wyjście

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

Zmieniono wydajność

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

EDYCJA: {:Dodano rozwiązanie (pokazano między ###)

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

Wykorzystuje {::mapę monady . Większość reszty kodu to bezużyteczne śmieci.

Pęknięty

Ruby, 14 lat

Kod

x=9;puts x*9*9

Oryginalne wyjście

729

Zmieniono wydajność

99999999999999999

Pęknięty

Bash, 15 bajtów

echo {{{1..9}}}

Oryginalne wyjście

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

Zmodyfikowane wyjście

1 2 3 4 5 6 7 8 9

Pęknięty

Prolog, 10 bajtów

Kod

X is 1/42.

Oryginalne wyjście

X = 0.023809523809523808.

Zmieniono wydajność

X = -2.

Pęknięty

Python 2, 43 bajty

Kod

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

Oryginalne wyjście

334960491355406

Zmieniono wydajność

222084148077792

Odległość Levenshteina wynosi dokładnie 15. Zarówno oryginał, jak i zmienione, działają na moim komputerze w czasie poniżej 1 minuty.

Pęknięty

BrainFuck, 504 bajty

Nikt nigdy nie powinien analizować kodu „pieprzony mózg”. To jest zmodyfikowana wersja wcześniejszego kodu, ale każda zmiana w kodzie Brainfuck robi dużą różnicę w wynikach. Używam interpretera na stronie http://esoteric.sange.fi/brainfuck/impl/interp/i.html do testowania mojego kodu. Powodzenia !

Kod

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

Oryginalne wyjście

 ___
/   \
|   |
\___/

Zmieniono wydajność

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

Uwaga: Zmienione wyjście zawiera kilka znaków STX (ASCII 2) i EOT (ASCII 4)

Oto wersja z kodami ASCII w nawiasach zamiast znaków niedrukowalnych:

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

pęknięty

Wolfram Language (Mathematica lub WolframAlpha), 3 bajty

Kod

8.!

Oryginalne wyjście

40320.

Zmieniono wydajność

2.67182 - 0.891969 I

Dla tych, którzy próbują go na WolframAlpha, wynik pokazuje się jako

Usunąłem poprzednią odpowiedź, ponieważ działała tylko na Mathematica, a nie w WolframAlpha . Stawało to rabusiów za zapłatą (zamiast zasłużonych krat), co było niesprawiedliwe.

Pęknięty

MATLAB / OCTAVE, 7 bajtów

Kod:

cos(pi)

Oryginalne wyjście:

ans =

     -1

Zmieniono wydajność:

ans =

   1.5708 - 0.8814i

Daje to odległość Levenshteina dokładnie 15.

Pęknięty

CJam, 8 znaków

Kod

"~f":i:#

Oryginalne wyjście

17290024234092933295664461412112060373713158853249678427974319674060504032816100667656743434803884485234668769970047274563123327020396104330878852891146011372048615474145637592955298601510765168228550988848615653376

Zmieniono wydajność

Dane wyjściowe po modyfikacji są tutaj . Oba zajmują mniej niż minutę na moim laptopie 2GHz.

Wyjaśnienie

Ludzie wydają się zdumieni, jak to działa. Kod działa w następujący sposób:

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

Oblicza to 126 ^ 102. Rozwiązaniem było:

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

Oblicza to ((125 ^ 9) ^ 126) ^ 102, który ma setki tysięcy cyfr.

Pęknięty

Pyth, 8 bajtów

Kod:

%CG^3y21

Wyjściowe wyjście:

51230235128920219893

Zmieniono wydajność:

58227066

Pęknięty

Python 2, 58 bajtów

Kod

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

Oryginalne wyjście

2444542772018013876036977350299418162656593659528311114655474359757543862791958572561591492595632222632192542272836836649846934427359810217936317967768095940470375690509652583392001888886352103127515963142

Zmieniono wydajność

4669

Ta reguła 15 dystansów z pewnością utrudniała grę. Mam nadzieję, że wszystko pójdzie dobrze.

Pęknięty

Python 2, 50 bajtów

Kod oryginalny:

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

Oryginalne wyjście:

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

Zmodyfikowane wyjście:

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

Nie za krótko i może nie za mocno, tak naprawdę nie wiem. Postaram się wkrótce wymyślić coś lepszego.

Pęknięty

PHP, 164 bajty

Kod

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

Oryginalne wyjście

2

Zmieniono wydajność

-1.1306063769532

GolfScript, 15 bajtów (bezpieczny)

Kod

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

Zmieniono kod

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

Oryginalne wyjście

47784725839872000000

Zmieniono wydajność

557154

Wyjaśnienia:

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

Zmieniono kod

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)

Pęknięty

APL , 7 bajtów

Kod

-/3⍴157

Oryginalne wyjście

157

Zmieniono wydajność

0.11479360684269167J0.37526348448410907

Pęknięty

C, 53 bajty

Kod

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

Oryginalne wyjście

Expected Output

Zmieniono wydajność

?

Prawdopodobnie zbyt łatwe, ale kto wie. (Uwaga: jest to technicznie zależne od systemu, ale rodzaj systemu, na którym się nie powiedzie, również nie powiedzie się w przypadku wszystkich innych zgłoszeń tutaj, więc pomyślałem, że to kwestia sporna).

Pęknięty

Edytować

Popełniłem błąd. Nowy kod, który jest bardziej bezpieczny dla oczywistego ataku:

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

te same wyjścia. Nowy rozmiar 65 bajtów. Mam nadzieję, że trudniejsze ... choć nadal prawdopodobnie zbyt łatwe.

Pęknięty przez issacga

MATLAB, 20 bajtów

Kod

format long
sin(i^pi)

Oryginalne wyjście

0.331393418243797 - 1.109981778186163i

Zmieniono wydajność

0.220584040749698 - 0.975367972083631i

Pęknięty

Oktawa, 20 bajtów

format long;
cos(1)*1

Wynik:

0.540302305868140

Zmieniono wydajność:

111

CJam, 28 bajtów (bezpieczny)

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

Wypróbuj online .

Oryginalne wyjście

7705397905065379035618588652533563996660018265606606763127193120855297133322151462150247488267491212817218321670720380456985476811737021068519164822984561148339610474891720342171053455881107227302663880445203851079295537592154028123394687360216561235621729967011148112746984677807932995700334185726563970223018774

Zmodyfikowane wyjście

16650180159137697345989048346412185774444335111603430666402604460993564226370500963166158223117360250140073061887053326627468495236957122711656527124216908303912850181595147494475577084810653496778801228980874902968634143062

Rozwiązanie

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

Wypróbuj online.

Jak to działa

Zrobiłem trochę za burtę z tym ...

Oryginalny kod wykonuje następujące czynności:

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

Zamierzona zmiana zostanie zastąpiona (iprzez Wci.

Powoduje to, że powtarzany ciąg pozostaje nietknięty i przesuwa 65535 (rzutując na znak bez znaku 16-bitowego, a następnie z powrotem na liczbę całkowitą), dzięki czemu pierwsze elementy opóźnionej sekwencji Fibonacciego stają się

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

a pętla jest powtarzana 126 razy.

JavaScript, 47 (bezpieczny)

Kod

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

Oryginalne wyjście

11.948938595656971

Zmieniono wydajność

3.679331284911481

Odległość wynosi dokładnie 15.

Testowane w Chrome i IE.

Rozwiązanie

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

Wykorzystuje to operator przypisania przesunięcia bitów, i>>=1aby interwał pętli był nieliniowy. Ma to również zabawną właściwość, że ktoś próbujący brutalnie wymusić rozwiązanie natrafi na kilka wariantów, które działają nieskończenie.

Pęknięty

Fantom , 26

Kod

Float.makeBits(1123581321)

Oryginalne wyjście

5.55122931E-315

Zmieniono wydajność

124.24518585205078

Bezpieczeństwo Przez Obscurity, jeśli nikt nie zna języka, nikt nie może go złamać. Levenshtein Odległość 15. Uruchom go w fansh.

Pęknięty

CJam, 6 znaków

25mse7

Oryginalne wyjście

-1323517.5009777304

Zmieniono wydajność

72004899337.38588

To może być zbyt łatwe. : P

Pęknięty

Java, 149 znaków

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

Oryginalne wyjście

174542852132661

Zmodyfikowane wyjście

106906909674100

Wskazówka:

Random.java

Brainfuck, 100 bajtów

Kod

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

Oryginalne wyjście

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Zmieniono wydajność

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

Uwaga: Prawdopodobnie łatwe do złamania. Ale w Brainfuck nic nie jest łatwe.

pęknięty

nowoczesny Perl 5, 70

Kod

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

Oryginalne wyjście

Jedna nowa linia.

Zmieniono wydajność

 mile mile mile mile mile mile mile mile mile mile

Wyjście rozpoczyna się spacją i kończy na nowej linii.

Pęknięty

Matlab, 12 bajtów

Kod

-sin(2:.5:3)

Oryginalne wyjście

-0.9093   -0.5985   -0.1411

Zmieniono wydajność

0.4228    0.7032    0.9228

perl, 12 bajtów

pęknięty

Kod

print sin 97

Oryginalne wyjście

0.379607739027522

Pożądane wyjście

-0.64618863474386

Pęknięty

SWI-Prolog, 54 bajty

Kod

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

Oryginalne wyjście

true.

123456123456
true.

Zmieniono wydajność

true.

false.