Two Makes All The Difference - Cops

Question

NOTICE - This challenge is now closed. Any new answers will be ignored and the accepted answer will not change

Challenge

Write a valid program which, when just two characters in the program are changed, removed or added, completely changes the output.

The changed output must have a Levenshtein Distance of 15 or more from your original output.

The output must be non empty and finite. Your program therefore must terminate within 1 minute.

Your output must be deterministic, outputting the same thing each time you run the program. It also must not be platform dependent.

Any hash functions are disallowed, as are built in PRNGs. Similarly, seeding an RNG is not allowed.

After a period of three days, an uncracked submission will become safe. In order to claim this safety, you should edit your answer to show the correct answer. (Clarification: Until you reveal the answer, you are not safe and can still be cracked.)

Formatting

Your answer should be in the following format:

# <Language name>, <Program length>

## Code

<code goes here>

## Original Output

<output goes here>

## Changed output

<changed output goes here>

Robbers

The robbers' challenge is to find out which two characters you have changed. If a robber has cracked your solution, they will leave a comment on your answer.

You can find the robbers' thread here.

Winning

The person with the shortest uncracked solution wins.

Leaderboard

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

Answer 1

CJam, 13 bytes (safe)

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

Try it online.

Original output

000010010101001010001101111000111011100110100100001011101101010100011111110010010010001111111111010000010011001110001010011111000010001001110111100000010110000010000111011011110101110010000011100111100

Modified output

11101101100011110001011010000100111011000010011101100000001010100111011010011011010111101000000011101111100000000110001000111110110110101111110100101110000101110100110011110000010101110

Solution

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

Try it online.

How it works

This takes advantage of how CJam implicitly prints the entire stack after executing the program.

Simply dumping the base-2 representations of a few integers on the stack causes them to be printed without any separator, so it should be hard to figure out where one of them begins and another one ends.

The original code does the following:

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#

As @AndreaBiondo notes in the comments, the binary representations of 0! to 8! can be found at the beginning of the output (spaces added for clarity):

1 1 10 110 11000 1111000 1011010000 1001110110000 1001110110000000

The intended change was to replace mQ with ci, which takes the integer modulo 65536, using 16-bit character arithmetic (casting to an unsigned 16-bit character, then back to integer).

I hoped the idea of using c to replace a mathematical operator would be obscure enough.

Answer 2

Cracked

Shakespeare, 1721 bytes

I tried a Shakespeare answer. It is not short, and I had difficulties to change the output with only 2 characters, but I think I succeeded quite well. Good Luck everybody. As a side note, I used the "compiler" available at this address and it may not work with another one. (it does not work with the online interpreter) The output does not contain any unprintable characters.

Code

The Hidden Change.

Helen, a young woman with a remarkable patience.
Helena, a likewise young woman of remarkable grace.
Claudio, a remarkable man much in dispute with Claudius.
Claudius, the flatterer.
The Archbishop of Canterbury, the useless.


          Act I: Claudius's insults and flattery.

          Scene I: The insulting of Helen.

[Enter Claudius and Helen]

Claudius:
 Thou art as hairy as the sum of a disgusting horrible fatherless 
 dusty old rotten fat-kidneyed cat and a big dirty cursed war.
 Thou art as stupid as the product of thee and a fat smelly 
 half-witted dirty miserable vile weak son.

[Exeunt]

          Scene II: The complimenting of Helena.

[Enter Claudio and Helena]

Claudio:
 Thou art the sunny amazing proud healthy peaceful sweet joy.
 Thou art as amazing as the product of thee and the pretty
 lovely young gentle handsome rich Hero. Thou art as great 
 as the sum of thee and the product of a fair golden prompt good honest 
 charming loving noble king and a embroidered rich smooth golden angel.

[Exeunt]

          Scene III: The insulting of Claudio

[Enter Claudius and Helen]

Helen:
 Thou art as stupid as the sum of the sum of thee and a cat and me.
[Exit Helen]

[Enter Claudio]

Claudius:
 Thou art as stupid as the sum of thee and the product of the 
 product of me and Helen and Helena

[Exeunt]

          Scene IV: The Final Countdown

[Enter The Archbishop of Canterbury and Claudius]

Claudius:
 Thou art the sum of you and a cat.

The Archbishop of Canterbury:
 Am I better than a fine road?

Claudius:
 If not, let us return to the insulting of Claudio.

[Exit The Archbishop of Canterbury]

[Enter Claudio]

Claudius:
 Open your heart!
 Open your heart!
[Exeunt]

Original Output

11324620811132462081

Changed Output

11

Answer 3

J, 76 bytes (safe)

Code

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

Original Output

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

Changed output

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

EDIT: Solution {: added (shown between ###)

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

Makes use of the monad {:: Map. Most of the rest of the code is useless garbage.

Answer 4

Cracked

Ruby, 14

Code

x=9;puts x*9*9

Original Output

729

Changed output

99999999999999999

Answer 5

Cracked

Bash, 15 bytes

echo {{{1..9}}}

Original output

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

Modified output

1 2 3 4 5 6 7 8 9

Answer 6

Cracked

Python 2, 43 bytes

Code

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

Original Output

334960491355406

Changed output

222084148077792

The Levenshtein Distance is 15 exactly. Both the original and the changed run under 1 minute on my computer.

Answer 7

Cracked

Prolog, 10 bytes

Code

X is 1/42.

Original Output

X = 0.023809523809523808.

Changed output

X = -2.

Answer 8

Cracked

BrainFuck , 504 bytes

No one should ever need to analyse a brainfuck code. This is a modified version of an earlier code, but any change in a Brainfuck code make a big difference in the output. I use the Interpreter at http://esoteric.sange.fi/brainfuck/impl/interp/i.html to test my code. Good Luck !

Code

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

Original Output

 ___
/   \
|   |
\___/

Changed Output

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

Note: The Changed Output contains several STX(ASCII 2) and EOT(ASCII 4) characters

Here is the version with ASCII codes in parenthesis instead of unprintable characters:

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

Answer 9

cracked

Wolfram Language (Mathematica or WolframAlpha), 3 bytes

Code

8.!

Original Output

40320.

Changed output

2.67182 - 0.891969 I

For those trying it on WolframAlpha the result shows up as

I deleted my previous answer because it worked only on Mathematica and not in WolframAlpha. That put robbers behind a paywall (instead of the deserved bars), which wasn't fair.

Answer 10

Cracked

CJam, 8 characters

Code

"~f":i:#

Original output

17290024234092933295664461412112060373713158853249678427974319674060504032816100667656743434803884485234668769970047274563123327020396104330878852891146011372048615474145637592955298601510765168228550988848615653376

Changed output

Output after modification is here. Both take under a minute on my 2GHz laptop.

Explanation

People seem amazed at how this works. The code works like this:

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

This calculates 126^102. The solution was:

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

This calculates ((125^9)^126)^102, which is hundreds of thousands of digits long.

Answer 11

Cracked

Pyth, 8 bytes

Code:

%CG^3y21

Initial Output:

51230235128920219893

Changed Output:

58227066

Answer 12

Cracked

MATLAB / OCTAVE, 7 bytes

Code:

cos(pi)

Original output:

ans =

     -1

Changed output:

ans =

   1.5708 - 0.8814i

This gives a Levenshtein distance of exactly 15.

Answer 13

GolfScript, 15 bytes (safe)

Code

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

Changed code

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

Original Output

47784725839872000000

Changed output

557154

Explainations:

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

Changed code

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)

Answer 14

Cracked

Python 2, 58 bytes

Code

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

Original Output

2444542772018013876036977350299418162656593659528311114655474359757543862791958572561591492595632222632192542272836836649846934427359810217936317967768095940470375690509652583392001888886352103127515963142

Changed output

4669

That 15 distance rule sure made things tricky. I hope this goes well.

Answer 15

Cracked

Python 2, 50 bytes

Original Code:

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

Original Output:

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

Modified Output:

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

Not overly short, and maybe not too hard, I don't really know. I'll try to come up with something better soon.

Answer 16

Cracked

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;

Original Output

2

Changed output

-1.1306063769532

Answer 17

Cracked

APL, 7 bytes

Code

-/3⍴157

Original output

157

Changed output

0.11479360684269167J0.37526348448410907

Answer 18

Cracked

C, 53 bytes

Code

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

Original Output

Expected Output

Changed output

?

Probably too easy, but who knows. (Note: it is technically system dependent but the type of system on which it fails would also fail all the other submissions here, so I figured it was a moot point).

Cracked

Edit

I made a mistake. New code which is more secure to the obvious attack:

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

same outputs. New size of 65 bytes. Hopefully harder... though still probably too easy.

Answer 19

CJam, 28 bytes (safe)

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

Try it online.

Original output

7705397905065379035618588652533563996660018265606606763127193120855297133322151462150247488267491212817218321670720380456985476811737021068519164822984561148339610474891720342171053455881107227302663880445203851079295537592154028123394687360216561235621729967011148112746984677807932995700334185726563970223018774

Modified output

16650180159137697345989048346412185774444335111603430666402604460993564226370500963166158223117360250140073061887053326627468495236957122711656527124216908303912850181595147494475577084810653496778801228980874902968634143062

Solution

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

Try it online.

How it works

I went a little overboard with this one...

The original code does the following:

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

The intended change is replacing (i with Wci.

This leaves the repeated string untouched and pushes 65535 (by casting to an unsigned 16-bit character, then back to integer), so that the first elements of the lagged Fibonacci sequence become

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

and the loop is repeated 126 times.

Answer 20

Javascript, 47 (safe)

Code

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

Original Output

11.948938595656971

Changed output

3.679331284911481

Distance is exactly 15.

Tested in Chrome and IE.

Solution

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

This uses the bit shift assignment operator i>>=1 to make the loop interval non-linear. Also this has the amusing property that someone trying to brute force a solution will run into several variations that run infinitely.

Answer 21

Cracked by issacg

MATLAB, 20 bytes

Code

format long
sin(i^pi)

Original Output

0.331393418243797 - 1.109981778186163i

Changed Output

0.220584040749698 - 0.975367972083631i

Answer 22

Cracked

Octave, 20 bytes

format long;
cos(1)*1

Output:

0.540302305868140

Changed Output:

111

Answer 23

Brainfuck, 100 bytes

Code

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

Original output

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Changed output

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

Note: Possibly easy to crack. But then, nothing is easy in Brainfuck.

Answer 24

Cracked

Java, 149 Characters

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

Original Output

174542852132661

Modified Output

106906909674100

Hint:

Random.java

Answer 25

Cracked

Fantom, 26

Code

Float.makeBits(1123581321)

Original Output

5.55122931E-315

Changed output

124.24518585205078

Security Through Obscurity, if nobody knows the language, nobody can crack it. Levenshtein Distance of 15. Run it in fansh.

Answer 26

Cracked

VBA, 72 bytes

Sub q()
Dim a(2) As Double
a(0)=-5
a(1)=10
msgbox IRR(a,0.253)
End Sub

Original Output

 0.999999999999136

Adjusted Output

1.82842712474619

Need to see some more VBA representation round here.=) Runs in Excel 2007+

Answer 27

Cracked

SWI-Prolog, 54 bytes

Code

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

Original Output

true.

123456123456
true.

Changed output

true.

false.

Answer 28

Cracked

CJam, 6 characters

25mse7

Original output

-1323517.5009777304

Changed output

72004899337.38588

This might be too easy. :P

Answer 29

Cracked

Ruby, 24

Code

p _=?9;p$.+=1until 9#$./

Original Output

"9"

Changed output

"9"
1
2
3
4
5
6
7
8
9

Answer 30

cracked

modern Perl 5, 70

Code

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

Original Output

A single newline.

Changed output

 mile mile mile mile mile mile mile mile mile mile

The output begins with a space and ends with a newline.

Answer 31

Cracked

bc, 22 bytes

4518574615489737231532

Current output

4518574615489737231532

Desired output

195543687803724

Answer 32

Cracked

Matlab, 12 bytes

Code

-sin(2:.5:3)

Original output

-0.9093   -0.5985   -0.1411

Changed output

0.4228    0.7032    0.9228

Answer 33

Cracked

Lua, 55 bytes

Now with less skimpy underwear! This code might look like my last code that was sadly cracked, but I can assure the solution is completely different

G={load="lfkjgGsHjkU83fy6dtrg"}
print(tostring(G.load))

Current output:

lfkjgGsHjkU83fy6dtrg

The correct output on 64 bit machines:

26

And on 32 bit machines:

18

Answer 34

perl, 12 bytes

cracked

Code

print sin 97

Original output

0.379607739027522

Desired output

-0.64618863474386

Answer 35

Cracked by Luis Mendo

MATLAB, 62 bytes

Code

mistake=-1;tragic=rosser;a=hilb(8)*42;
a(:,:)+tragic(8)/mistake

Original Output

   13.0000   -8.0000  -15.0000  -18.5000  -20.6000  -22.0000  -23.0000  -23.7500
   -8.0000  -15.0000  -18.5000  -20.6000  -22.0000  -23.0000  -23.7500  -24.3333
  -15.0000  -18.5000  -20.6000  -22.0000  -23.0000  -23.7500  -24.3333  -24.8000
  -18.5000  -20.6000  -22.0000  -23.0000  -23.7500  -24.3333  -24.8000  -25.1818
  -20.6000  -22.0000  -23.0000  -23.7500  -24.3333  -24.8000  -25.1818  -25.5000
  -22.0000  -23.0000  -23.7500  -24.3333  -24.8000  -25.1818  -25.5000  -25.7692
  -23.0000  -23.7500  -24.3333  -24.8000  -25.1818  -25.5000  -25.7692  -26.0000
  -23.7500  -24.3333  -24.8000  -25.1818  -25.5000  -25.7692  -26.0000  -26.2000

Changed Output

  -22.0000   19.0000   11.0000  -50.5000  -51.6000    1.0000   -1.0000  -51.7500
   12.0000  -41.0000  -43.5000   -3.6000   -6.0000  -45.0000  -44.7500  -11.3333
   -3.0000  -36.5000  -37.6000  -13.0000  -15.0000  -37.7500  -37.3333  -19.8000
  -29.5000  -17.6000  -20.0000  -31.0000  -30.7500  -25.3333  -26.8000  -29.1818
  -23.6000  -27.0000  -29.0000  -23.7500  -23.3333  -33.8000  -35.1818  -21.5000
  -34.0000  -17.0000  -16.7500  -39.3333  -40.8000  -15.1818  -14.5000  -44.7692
  -43.0000   -9.7500   -9.3333  -47.8000  -49.1818   -7.5000   -6.7692  -53.0000
   -2.7500  -53.3333  -54.8000   -1.1818   -0.5000  -58.7692  -60.0000    1.8000

Answer 36

Cracked by Luiz Mendo

MATLAB, 40 bytes

Code

format long
arg = [.1 .2 .3];
sin(arg'*exp(9))

Original Output

  -0.220680258232564
  -0.430479305680324
  -0.619052457794081

Changed Output

  -0.803636351328917
  -0.721159584869623
  -0.148487879352133

Hint: there's another solution to this question

Answer 37

Cracked

Javascript, 53 bytes

Code

a=(((b=(a=1)+a)+a)-b-a)*(a=[b])['length'];
alert(a);

Original Output

0

Changed output

5.551115123125783e-18

Tested under: Firefox, Chrome, IE

Answer 38

Cracked.

Stuck, 21 Bytes

I'll start with an easy one, since nobody has seen this before and there's no documents.. Anyways, Stuck is a stack-based language, very similar in usage to CJam. All you need to know is:

NR -> creates a range [1,N] on the stack. 
[N]z -> zips together the top 2 lists, unless an optional N is specified, then the top N lists.
] -> Flattens the top list by one "dimension".

For the record, while I have made commits since this challenge happened, all of this functionality has been present long before.

Code:

1R2R3R4R5R6R7R8R9R9z]

Original Output:

(1, 1, 1, 1, 1, 1, 1, 1, 1)

Changed Output:

(1, 1, 1, 1, 1, 1, 1, 1)(2, 2, 2, 2, 2, 2, 2, 2)(3, 3, 3, 3, 3, 3, 3, 3)

Answer 39

Fantom, 30 (safe)

Code

[7115432d/9,219.or(64),37][0]

Original Output

790603.5555555556

Changed output

55

Solution

"7115432d/9,219.or(64),37"[0]

By changing the array to a string literal, the index call actually gets the first character of the string. Characters in fantom are actually just ints, so the value of '7' is 55.

Answer 40

PowerShell v3, 384 (SAFE)

(My second post ever on PPCG, please be gentle. :) I think I'm going to like this community!)

Code:

$s="a*h*t*s*m*i*d*o*n*l*k*e*y*u*g*r*w*LOOD> AIG BAE>!+<R S!>>+<GH MHN JFKL> LOOD AIG BAE>?<+"
$cur="";$l="";[char]$n="A";$st=@{}
foreach($c in [char[]]$s){switch -regex($c){
"[\*\>]" {$st[$n]=$cur.TrimStart(" ");$n=[char]([int]$n-1);if($c-eq">"){$l+=$cur};$cur=""}
"\+" {$l=$cur;$cur=""}
"\<" {$l+$cur;$l="";$cur=""}
default {if($st.Contains($c)){$cur+=$st[$c]}else{$cur+=$c}}}}

Original output:

eggs and ham!
eggs and ham!
do you like eggs and ham?

Modified output:

!

GH MHN JFKL LOOD aIG BaEt

(to be clear, that's a blank line in the middle of the modified output)

Mini-hint:

h/t to Adam Barr for the inspiration

Edit - Safe - Below is corrected code, and below that is explanation

$s = "a*h*t*s*m*i*d*o*n*l*k*e*y*u*g*r*w*LOOD> AIG BAE>!+<R S!>>+<GH MHN JFKL> LOOD AIG BAE>?<+" # The string we're cycling through
$cur = "" # What word(s) we've currently built
$l = "" # The current line we've finished building
[char]$n = "A" # Cast as a character instead of a string, this is the index of our temporary store
$st = @{} # Our temporary store - the first time through, this will populate out with the first part of the string $s
foreach ($c in [char[]]$s) { # Loop through the string $s as an array, one $c character at a time
    switch -regex ($c) {
        "[\*\>]" {
            $st[$n] = $cur.TrimStart(" ") # Ensures that we're not adding a space, and adds what we've currently built into the store
            $n = [char]([int]$n + 1)    #ONE OF THE CHANGES - Changed the +1 to -1, which causes the indexing of the store to be off
            if ($c -eq ">") { $l += $cur } # If our current character is a >, add that to the line as it's finished
            $cur = "" # Reset what we're building
        }
        "\+" {
            $l += $cur #ONE OF THE CHANGES - Changed the += to =, which causes the line to not get printed
            $cur = "" # Reset what we're building
        }
        "\<" {
            $l + $cur # Add on our current word to the line and print it out
            $l = "" # Reset our line
            $cur = "" # Reset what we're building
        }
        default {
            if ($st.Contains($c)) {
                $cur += $st[$c] # If our store contains the character, add what's in the store's index at $c to our current word
            } else {
                $cur += $c # Else, just add the character to our current word
            }
        }
    }
}

Explanation

The best way to explain this is that we're using the string at the start as a sort of cypher. The first half of the string, demarcated by asterisks, is our cypher results. The rest of the string is the output, encoded based off of the "integer" value of the letter (from an alphabetical perspective, not an ASCII perspective). For example, the LOOD> takes the 12th character (an e), the 15th character (a g) twice, and then the 4th character (a s), which forms the word eggs, then the > case, which trims off what we're building so that our words don't run together.

The script cycles through the string character by character, building the cypher store at first (because of all the asterisks, the first 34 times through the switch causes either the first case or the default case to be called), while the rest of the times through cause either an index lookup (because we've already added that letter) or text manipulation (e.g., the second change which just re-sets a variable rather than print it out).

Please let me know if you have further questions!

Answer 41

Befunge 98, 30 Bytes(Safe)

Code

153+:*,+:f`#v_
+ ':_;#:-1;#@;,

Original output:

@@@@@@@@@@@@@@@@

Changed output:

@~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!

Solution

g53+:*,+:f`#v_
+ ':_;#:-1;#<@;,

Answer 42

Perl, 49 byes (safe)

Code

$_=cos 99;printf"%.16f",0x7275*sin $_/s/[3-8]/04/

Original Output

145.9795577401910975

Changed Output

23.3077670014990304

---

Clue

I tried to do this before but there was another unintended (easier) solution. The robber to my previous challenge may help you solve this one. Try to solve it with three modifications and you'll be half way to the two modification answer.

Solution

$_=cos 99;printf"%.16f",07275*sin $_/y/[3-8]/04/

1. Remove the x to turn hexadecimal 0x7275 (decimal 29301) into octal 07275 (decimal 3773)

2. Change the s/// (replacement) to y/// (transliteration) so that instead of the first digit from 3-8 becoming the string 04, all digits in that range become 4. Additionally, both return the number of changes; the s/// version only makes one change while y/// makes all 8 changes (the way s///g would). If you could change a third character, you could do s/[3-8]/4/g and have the same result as my y/[3-8]/04/. (This was exploited to solve my previous attempt.)

Example of s/// vs y///:

$_="s: 1234567890, ";s/[3-8]/04/;print; $_="y: 1234567890";y/[3-8]/04/;print

s: 12044567890, y: 1244444490

So therefore we're multiplying by a changed number and the function at the end alters the default variable differently and divides by a different number.

Answer 43

Malbolge, 411 bytes

Code

bCBA@?>=<;:9876543210/.-,+*)('&%$#"!~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9y76543210/(L,l$H('&%$#"!~}v{zyxwvutm3qponmlkjihgfedcba`_^]?zZYXWVOTSRQPONMFjJIHGFEDC<`@?!=<;4X87w/S3s10/.-,+*)('&%$#"!~}|{zyxq7Xtmrk1onPlkdihg`&dcbD`_^]\[ZYXQutTSRQPONMLKJCgGFEDCBA@?>=<;:z81Uv43210/.'Kl*#G'&f|{A!~}|{zs9qvo5mrqponmle+*hgfe^c\"`_^]\[ZYXWV8Nr5QPONGkKJ,HGFEDCBA@?>=<;:3W76/432+O/o-,+*)('&%|B/

Original output

Two Makes All The Difference

Modified output

Two 

(note the trailing space)

Solution

bCBA@?>=<;:9876543210/.-,+*)('&%$#"!~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9y76543210/(L,l$H('&%$#"!~}v{zyxwvutm3qponmlkjihgfedcba`_^]?zZYXWcOTSRQPONMFjJIHGFEDC<`@?!=<;4X87w/S3s10/.-,+*)('&%$#"!~}|{zyxq7Xtmrk1onPlkdihg`&dcbD`_^]\[ZYXQutTSRQPONMLKJCgGFEDCBA@?>=<;:z81Uv43210/.'Kl*#G'&f|{A!~}|{zs9qvo5mrqponmle+*hgfe^c\"`_^]\[ZYXWV8sr5QPONGkKJ,HGFEDCBA@?>=<;:3W76/432+O/o-,+*)('&%|B/

Answer 44

Cracked

C++ 91 Bytes

#include <iostream>
int main()
{
    //can you figure it out?
    std::cout << "I like cake and";
}

Output:

I like cake and

Changed output

Answer 45

Cracked

Python 2, 57 bytes

Code

i=long;j=map;print reduce(i.__mul__,j(i,j(ord,`i`)))/1234

Original Output

3164217824783520557889

Changed output

9072146982802639849575831250318562874251

Answer 46

Python 2/3, 70 bytes (safe)

Code

x=932436
for i in range(99**4):x=(1103515245*x+12345)%2**31
print(x*x)

Original Output

211455574532454121

Changed output

1039038861760158249

Solution

x=9372436
for i in range(59**4):x=(1103515245*x+12345)%2**31
print(x*x)

The solution initializes x to 9372436 instead of 932436, and does range(59**4) instead of range(99**4). As an aside, the solution runs in about 1/10th of the time.

I probably could have made it shorter without making it too much easier, or at all easier.

Answer 47

Cracked

Python 2, 41 bytes

Code

print sum((ord(i)<<0x156 for i in `sum`))

Original Output

19718712710133388269747721838124583424582966957653854505259504044885223633870136963133245450763229047291904

Changed output

20

Answer 48

Cracked

PHP 5.4, 92 bytes

<?php
define('E','!');

$x = 4;
$t = " Hello World";
$t .= E;
$t .= E;
$t .= E;

print($t);

Output:

 Hello World!!!

Changed Output:

 Hello World! Hello World! Hello World! Hello World!

(Note: both outputs include a leading space)

Answer 49

Cracked

Lua, 54 Bytes

G={string="gs_hSDrGSFG5;U*ts"}
print(tostring(G.string))

Current output:

gs_hSDrGSFG5;U*ts

Desired output:

23

Note: I'm not exactly sure why, but if you are using an online compiler (specifically repl.it) the correct output will be 15.

Answer 50

Cracked

Javascript, 169 bytes

Code

a=1,b=a*2,c=a+b,d=[a+b];while(c>b)c-=a;for(i=1;i<=c;i++)d.push(i);i=''+c*d['length']*d['length'];alert(Math[String.fromCharCode(i.charCodeAt(0) * i.charCodeAt(1) / 32)])

Original Output

undefined

Changed output

2.718281828459045

Answer 51

Cracked

MATLAB / OCTAVE, 28 bytes

Code:

f=@(x)x^.7;g=@(x)7/f(x);g(7)

Original output:

ans =

    1.7928

Changed output

ans =

  -0.3011 - 0.4144i

Answer 52

Cracked

Clojure, 35 Bytes

Code

(printf "%d\n" 2155263413256326162)

Original Output

2155263413256326162
nil

Changed output

3681347803529195
nil

Answer 53

Cracked

MATLAB / Octave, 33 bytes

Code

eig(cov(reshape(sin(1:60),5,[])))

Original Output

ans =

   -0.0000
   -0.0000
   -0.0000
   -0.0000
   -0.0000
   -0.0000
    0.0000
    0.0000
    0.0000
    0.0000
    2.4410
    4.5766

Changed Output

ans =

    0.0064
    0.0000
    0.0000
   -0.0000
   -0.0000
    0.0000

Answer 54

Cracked

PHP, 21 bytes

Code

print_r(range(i,09));

Original Output

Array ( [0] => 0 )

Changed output

Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 [6] => 7 )

Answer 55

Fantom, 34

Code

[7115432d/9,219.or(64),37,5555][0]

Original Output

790603.5555555556

Changed output

55

Ok, hopefully this one is a little more competitive than my previous attempt. Levenshtein Distance of 15. Run it in fansh.

Better Code

@isaacg found an easy solution I hadn't even seen. This code removes that solution while keeping the original one I intended, if anyone still wants the challenge.

[7115432d/9,219.or(64),37,55.0f][0]

Answer 56

Cracked

Matlab/Octave, 10 bytes

this should be a fairly easy one.

I only tried it with Octave online, but it should run fine in matlab.

Code:

e^(i*pi)+1

Output

0.0000e+00 + 1.2246e-16i

Changed Output

1.9336e+04

Answer 57

Mathematica, 35 bytes (safe)

Code

z=Zeta[4/3,1/2];N[Min[z,Sec[z]],20]

Original Output

1.4508303658284314991

Changed output

-0.72451364607415832407

Edit: Note that the original code will sort-of work on Wolfram Alpha, but the modified code does not.

Changed Code

z=Zeta[4/3,1/2];N[Sin[z,Set[z]],20]

Set[z] evaluates to Sequence[] so Sin[z,Set[z]] = Sin[z]. Moreover, Mathematica evaluates function arguments serially and in order, so Set[z] is evaluated after the value of z is already used.

Answer 58

Cracked

GolfScript, 4 bytes

9,!9

Original output

09

(trailing linefeed)

Modified output

0123456789012345678

(no trailing linefeeed)

---

If you test your code in Web GolfScript, you have to look at the source code of the output, since the (lack of a) trailing linefeed will be undetectable in the rendered page. For the correct solution, there should be no linefeed between 0123456789012345678 and </textarea>.

It might be easier to use the Ruby interpreter for this one.

Answer 59

MATLAB, 56 bytes (SAFE)

I think this is a step up from some of the previous MATLAB questions, but that remains to be seen I guess:

Code

p=.4 -.2*i;j=.3*i +.7;i=@(c)j./(.6- .4*c);asin(i(p) *5i)

Original output

ans =

  -0.2236 + 2.8380i

Changed output

ans =

   0.1799 + 6.5793i   0.1798 + 5.4395i

Solution:

p=.4 -.2*i;j=.3*'i '+.7;i=@(c)j./(.6- .4*c);asin(i(p) *5i)

Simply change .3*i +.7 to .3*'i '+.7; This creates a vector with the numbers [105 32], since MATLAB automatically casts the chars to integers if it's part of an equation.

All the spaces were just to throw people off (it made it possible to do changes like [.3*i 0.7];, thus making it possible to create vectors this way too.

Answer 60

Cracked

CSS, 53

Code

body:after{counter-reset:a 512;content:counter(a)"₽"}

Original Output

512₽

Changed output

0%

Snippet

body:after{counter-reset:a 512;content:counter(a)"₽"}

Answer 61

Cracked

APL, 5 characters

3⍟877

Current output

6.1682424839682115

Modified output

0.20016493054644696

An edit distance of 16.

Answer 62

APL, 9 bytes

Code

+/○3-3⍴⍳5

Original output

18.84955592153876

Changed output

¯0.31830988618379086 0.31830988618379075 0

Looks like I just missed the deadline, because I suck at time zones. Have fun solving this, anyway.

Answer 63

Cracked

SWI-Prolog, 54 bytes

Code

assert((o(X,Y,Z):-ABC is X**X,print(ABC))). o(99,y,z).

Original Output

true.

369729637649726772657187905628805440595668764281741102430259972423552570455277523421410650010128232727940978889548326540119429996769494359451621570193644014418071060667659301384999779999159200499899
true.

Changed output

true.

true.

Answer 64

Cracked

Javascript, 233 bytes

Code

one = 1;
two = one + one;
three = two + one;
zero = three - two - one;
numbers = [three, two, one];

for (i = numbers.length - 1; i >= zero; i--) {
    numbers.pop();
}

infinity = 1 / numbers['length'];
alert(infinity);

Original Output

Infinity

Changed output

3.333333333333333

Answer 65

Cracked, because I didn't check the simple solution

MATLAB, 8 bytes

Code

sin(1+1)

Original Output

0.909297426825682

Changed Output

-0.262374853703929

Answer 66

Cracked

Python, 227 Bytes

Original Code:

import re;''.join(re.findall('\w(?=\w\w)','t74q joh7 jv f9dfij9j bfjtf0e nnjen3j nnjrb6fgam3gtm5tem3hj s3eim7djsd3ye d5dfhg5un7ljmm8nan3nn6n k m2ftm5bsof5bf r5arm4ken8 adcm3nub0 nfrn6sn3jfeb6n d m6jda5 gdif5vh6 gij7fnb2eb0g '))

Original Output:

't7jof9dfijbfjtfnnjennnjrb6fgam3gtm5tem3s3eim7djsd3d5dfhg5un7ljmm8nan3nnm2ftm5bsof5r5arm4keadcm3nunfrn6sn3jfebm6jdgdif5vgij7fnb2eb'

Changed Output:

'to iterate is human to recurse divine'

Answer 67

PHP, 299

(I hope I have understood the challenge correctly. It seems hard to produce code where and 2 single-character changes make such a difference, even if ignoring whitespace etc.)

Code

<?php $i=0x61;$x=0x15;$y=0x36;$k="";$me=<<<PHP
\$q=\$i=\$i-1;\$x++;\$x=\$x^\$i^$x;if(\$i>0){
for(\$z=0;\$z<__LINE__;\$z++){for(\$l=strlen
("\$me")-1;\$l>=0;\$l--)\$q=\$q^(int)(\$x^
ord(\$me[\$l]));}\$k.=\$q;\$me="/**/\$me";
\$me.="#";eval(\$me);}
PHP;
eval($me);echo wordwrap($k,30,"\n",true)."\n";

FYI: Proof it takes < 1 minute on any modern hardware:

$ time php /tmp/wot.php
711752729711068167264259526921
...
real    0m4.580s
user    0m1.548s
sys     0m3.023s

Original Output

969594939291908988878685848382
818079787776757473727170696867
666564636261605958575655545352
515049484746454443424140393837
363534333231302928272625242322
212019181716151413121110987654
321

Changed output

127127127127127255255255255255
255255255383383383383383383383
383383383511511511511511511511
511511511511511511511639639767
767767767767767895895895895895
895895895895102310231023102311
511151115111511151115111511151
115111511151127912791279127912
791279127912791407140714071407
140714071407140714071407153515
351535153515351535153515351535

Answer 68

OCTAVE, 157 bytes.

format long 
sin(cos(tan(csc(sec(cot(asin(acos(atan(acsc(asec(acot(sinh(cosh(tanh(csch(sech(coth(asinh(acosh(atanh(acsch(asech(acoth(i))))))))))))))))))))))))

Output:8.77828266022653e+276+3.46629794728664e+276i

Modified Output:1.32478170985912-7.32035312239031i

Answer 69

Cracked.

CJam, 9 bytes

Attempt 3...

Ps"."-i2b

Try the code at this correct link.

Expected output

1011001010010100001100001010001001010110110100100001

Modified output

5010670554118

Another easy one??

Answer 70

Cracked

Perl, 48 bytes

Code

$_=cos 99;printf"%.14f",0x7275*sin $_/s/[3-8]/0/

Original Output

287.75699066847318

Changed Output

144.01504526079819

Answer 71

Cracked

Python 3, 57 bytes

Code:

import math, decimal
print(decimal.Decimal(math.tan(749)))

Output:

3.615402552802641888973766981507651507854461669921875

Changed Output:

0.6610431688506868130872362598893232643604278564453125

Answer 72

Cracked

APL, 4

Code

9⍟99

Original Output

2.091329169322069

Changed output

0.11111111111111112

Tested here. Note that the last digit is 2. I just wanted to know how hard is an average APL submission.

Answer 73

JS,

Math.pow(2,10)

Original output:

1024

Changed output:

7.61773480458663923e+85

Has a Levenstein distance of 23(!).

Answer 74

Cracked

Pyth, 4 bytes

.!77

Output:

145183092028285869634070784086308284983740379224208358846781574688061991349156420080065207861248000000000000000000

Changed Output:

3628800

Answer 75

Cracked

Python 2, 86 Bytes

Original Code

import dis
def torun():
 print "hello world"
try:
 print dis.dis(torun)
except:
 pass

Original Output:

 47           0 LOAD_CONST               1 ('hello world')
              3 PRINT_ITEM          
              4 PRINT_NEWLINE       
              5 LOAD_CONST               0 (None)
              8 RETURN_VALUE        
None

Changed Output:

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Answer 76

C, 82 bytes

b=64,i,x[64];main(){for(i=b;i--;)x[(i*3)%b]^=x[(i*5)%b]+i,printf("%02u",x[--b]);}

Output 1:

00006362616059585756555453525150494847464544434241403938373635343332313029282726252423222120191817161514131211100908070605040100

Output 2:

000000006312518624630536342047653158563869074179184088893598110261070111311551196123612751313135013861421145514881520155115811610163816651691171617401763178518061826184518631880189619111925193819501961197119801988222001201400