text:
Code ladder, Robbers
This is the robbers' thread. The cops' thread goes here.
Write a code that has the same number of bytes as the cop post and where the revealed characters are identical. The code must produce 1 in its initial state, and produce the numbers 2, 3 .. when single alterations are made.
The winner will be the robber that cracked the most posts.
Example post:
MyLang, 9 bytes, 8 numbers (including link to answer), Cop's username.
Original code:
abc1efghi

Code that produces 1 - 8:
1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi

Explanations are encouraged. The exact format of the robber post is optional.

Retina, 2 bytes, 10 numbers, by Martin Ender.
Original code:

1

This replaces the empty input by the number 1.
Code that produces 1 - 10 (showing newlines as \n for convenience):
1 : \n1
2 : \n1\n
3 : \n11\n
4 : \n111\n
5 : \n1111\n
6 : \n11111\n
7 : \n111111\n
8 : \n1111111\n
9 : \n11111111\n
10: \n111111111\n

For 2 and onwards, we count the number of empty strings in the previous stage. For 2, there is an empty string before and after the 1. For 3 there is an empty string before the ones, in between the ones and after the ones. This works all the way up to 10.
Try it online

Perl, 12 bytes, 10 numbers, by ais523
Original code:
____;say__-9

Code that produces 1 - 10:
wait;say$!-9
wait;say$!-8
wait;say$!-7
wait;say$!-6
wait;say$!-5
wait;say$!-4
wait;say$!-3
wait;say$!-2
wait;say$!-1
wait;say$!-0

Explanation:
wait;         # waits for a child process to end (there is no child so it just returns)
     say      # put the following on the screen:
        $!    # current value of the C errno. In this case, ECHILD (No child processes)
              # which has a value of 10
          -9  # minus 9

JavaScript, 30 bytes, 10 numbers, by ETHproductions.
Original code:
1: alert(Array(2).join(3).length)

Other numbers
 2: alert(Array(2).join(31).length)
 3: alert(Array(2).join(314).length)
 4: alert(Array(2).join(3141).length)
 5: alert(Array(2).join(31415).length)
 6: alert(Array(2).join(314159).length)
 7: alert(Array(2).join(3141592).length)
 8: alert(Array(2).join(31415926).length)
 9: alert(Array(2).join(314159265).length)
10: alert(Array(2).join(3141592653).length)

Explanation
Array(2) creates an Array with two empty cells. The .join method joins all the elements in an Array using a delimiter, which converts it into a String. In the Original Code, the delimiter was 3. This meant that the two empty cells in the Array are joined together used 3 as their delimiter. This evaluates "3", without anything on either side of the 3 because the Array is empty. And since the length of "3" is 1, this value is outputted to the console.
For the other numbers, I add 1 more digit to the delimiter that is joining the elements of the Array. Hence, this increases its length, thus alerting with increasing values. Note that the numerical value of the delimiter is not important, only its length is.
Snack Snippet!
Note: I used console.log instead of alert in my Snack Snippet for obvious reasons. Also, output from the console is display in the snippet.

console.log(Array(2).join(3).length)
console.log(Array(2).join(31).length)
console.log(Array(2).join(314).length)
console.log(Array(2).join(3141).length)
console.log(Array(2).join(31415).length)
console.log(Array(2).join(314159).length)
console.log(Array(2).join(3141592).length)
console.log(Array(2).join(31415926).length)
console.log(Array(2).join(314159265).length)
console.log(Array(2).join(3141592653).length)

Nice! That was the intended solution (although I wasn't as imaginative with the joining number ;) )

Octave, 17 bytes, 10 numbers, by Stewie Griffin
original:
_i_(__i__(2_5_))

solution:
fix( 'i'-(2*52))
fix( 'j'-(2*52))
fix( 'k'-(2*52))
fix( 'l'-(2*52))
fix( 'm'-(2*52))
fix( 'n'-(2*52))
fix( 'o'-(2*52))
fix( 'p'-(2*52))
fix( 'q'-(2*52))
fix( 'r'-(2*52))

Hah, far from my solution! Well done! :) I'll post the intended one in my post :)

Python 2, 17 bytes, 10 numbers, by xnor
print len(['  '])
print len(*['  '])
print len(*['   '])
print len(*['    '])
print len(*['     '])
print len(*['      '])
print len(*['       '])
print len(*['        '])
print len(*['         '])
print len(*['          '])

repl.it

Python 2, 9 bytes, 10 numbers, xnor
print 8/8
print 18/8
print 28/8
print 38/8
print 38/7
print 38&7
print 31&7
print 31&72
print 31&73
print 31&74

Congrats! That's the one I thought of too. I was curious and ran a search. It turns out there are many solutions, including ones that don't use bitwise operations.

print 10/10 is quite an interesting one if you ban &, according to the tree search. Or, if you require going to 11.

Perl, 14 bytes, 10 numbers, by Dada
Original code:
say_!"___"%""_

Code that produces 1 - 10:

say"!"+1#"%""r
say"!"+2#"%""r
say"!"+3#"%""r
say"!"+4#"%""r
say"!"+5#"%""r
say"!"+6#"%""r
say"!"+7#"%""r
say"!"+8#"%""r
say"!"+9#"%""r
say"1"+9#"%""r

I have a feeling this isn't what you were going for.

I should have more letters... The original code was say"!"=~y"%""c (so say"!!"=~y"%""c, etc, with one more ! each time). But well played! :)

Right, there was enough of a gap to sneak an integer constant into the middle and comment out the rest of the line. That seems dangerous in a challenge like this one.

I didn't want to give to much information : = or ~ would have been a huge hint, and the structure of the " as I showed them was misleading (I hope)... But I should have consider that commenting half of it was doable!

I'd actually guessed that there was an =~ in the intended solution. However, I was busy trying s, m and / and didn't think of y.

Welcome on PPCG btw! Nice to see new perl golfers!

JavaScript, 22 bytes, 10 numbers, by Arnauld
Original program:
alert(0_6_4_>_0_2_0_7)

Cracked:

alert(0+6^42>101210^7)
alert(0+5^42>101210^7)
alert(0+4^42>101210^7)
alert(0+3^42>101210^7)
alert(0+2^42>101210^7)
alert(0+1^42>101210^7)
alert(0+0^42>101210^7)
alert(0+0^42>101210^8)
alert(0+0^42>101210^9)
alert(0+3^42>101210^9)

The hard part is to deal with the >, which has a very low precedence. I tried changing it to an >>, but it's easiest to just absorb it by making it uselessly calculate a boolean false (the 42>101210 section) which is numerically 0, and just generate the numbers from 1 to 10 with operators with an even lower precedence than >. I used ^, bitwise xor, because it can generate the numbers from 1 to 10 fairly easily (conveniently, the 6 and 7 in the original input let me simplify the expression down to 6^7 which is 1).

JavaScript, 9 bytes, Hedi
Original code:
alert(+1)

Modifications:
alert(1+1)   // 2
alert(2+1)   // 3
alert(3+1)   // 4
alert(4+1)   // 5
alert(5+1)   // 6
alert(6+1)   // 7
alert(7+1)   // 8
alert(8+1)   // 9
alert(9+1)   // 10

JavaScript, 22 bytes, 10 numbers by Arnauld
Original code:
alert(__14_337__xc_de)

Modified:
alert(00140337-0xc0de) // 1
alert(00140337-0xc0dd) // 2
alert(00140337-0xc0dc) // 3
alert(00140337-0xc0db) // 4
alert(00140337-0xc0da) // 5
alert(00140337-0xc0d9) // 6
alert(00140337-0xc0d8) // 7
alert(00140337-0xc0d7) // 8
alert(00140337-0xc0d6) // 9
alert(00140337-0xc0d5) // 10

I'm guessing this isn't the intended solution, but I'm hoping it's not too far off...

That's the intended solution indeed. Well done!

It really should have been alert(0140337-0xc0de) (one byte shorter) but I mistakenly used the ES6 octal notation 0o140337 and decided to let it that way.

@Arnauld I'm glad I was able to get the 'right' solution! Thanks for the challenge!

Octave, 55 bytes, 10 numbers, flawr
(o=@(O,o)(@(O,o)o{2-O} ) (0<O,{ (yo=O-1)+1,@()1}))(1,o)

The final 1 can be cycled up to 9, and then change the +1 to +2.

Good job, did you perhaps find my post about this on SO? :)

@flawr Hmm? About what?

Oh, I see you've written something about recursive functions in the original post. My crack doesn't use any recursion.

Oh now I see, I wasn't even able to tell the difference at first glance ^^

Python 3, 16 bytes, 10 numbers, by Sp3000
This was fun.
print(?%??f?r?t)

print(1%0xfor t)
print(2%0xfor t)
...
print(8%0xfor t)
print(84%0xfor t)
print(85%0xfor t)

Exploits the fact (which I didn't know till now) that a hex literal ends as soon as a character that isn't 0-9a-fA-F is encountered--thus 0xfor is a very sneaky way to write 15 or. After that, it was a matter of finding the right value congruent to 10 modulo 15.

Fast :P But at least it should be obvious now how the bin() one was intended to be solved too.

Octave, 32 bytes, 10 numbers, by Luis Mendo
Original code:
nnz(isprime(floor(s=3):i*-2i))+1

Modified codes:
2:  nnz(isprime(floor(s=3):i*-3i))+1
3:  nnz(isprime(floor(s=3):i*-5i))+1
4:  nnz(isprime(floor(s=3):i*-9i))+1
5:  nnz(isprime(floor(s=3):i*-9i))+2
6:  nnz(isprime(floor(s=3):i*-9i))+3
7:  nnz(isprime(floor(s=3):i*-9i))+4
8:  nnz(isprime(floor(s=3):i*-9i))+5
9:  nnz(isprime(floor(s=3):i*-9i))+6
10: nnz(isprime(floor(s=3):i*-9i))+7

There are many ways to make modifications here (for instance s=2 and +0 in the beginning).
Edit: A more probable alternative:
nnz(isprime(floor(s=2):i*-2i))+0
nnz(isprime(floor(s=2):i*-2i))+1
nnz(isprime(floor(s=2):i*-2i))+2
nnz(isprime(floor(s=2):i*-2i))+3
nnz(isprime(floor(s=2):i*-2i))+4
nnz(isprime(floor(s=2):i*-2i))+5
nnz(isprime(floor(s=2):i*-2i))+6
nnz(isprime(floor(s=2):i*-2i))+7
nnz(isprime(floor(s=2):i*-2i))+8
nnz(isprime(floor(s=2):i*-2i))+9

05AB1E, 11 bytes, 10 numbers, by Oliver
Original code:
 1: 3628801zï0>

Other numbers
 2: 3628801zï0>>
 3: 3628801zï0>>>
 4: 3628801zï0>>>>
 5: 3628801zï0>>>>>
 6: 3628801zï0>>>>>>
 7: 3628801zï0>>>>>>>
 8: 3628801zï0>>>>>>>>
 9: 3628801zï0>>>>>>>>>
10: 3628801zï0>>>>>>>>>>

Explanation
3628801                        # push this number
       z                       # find its reciprocal
        ï                      # round it to the nearest integer (becomes 0)
         0                     # push 0
          >>>>                 # increment by 1 for each `>` present (this is for 4)
                               # implicit output

To summarise it, push 3628801, take its reciprocal and round that to the nearest integer (evaluates to 0). Then increment the stack. TADA!
Try it online! For output = 1 Then add as many >s as you want depending on what number you want to output.

JavaScript, 12 bytes, 10 numbers, Hedi
Original code:
alert(+[+1])

2 through 10:
alert(+[1+1])
alert(+[2+1])
alert(+[3+1])
alert(+[4+1])
alert(+[5+1])
alert(+[6+1])
alert(+[7+1])
alert(+[8+1])
alert(+[9+1])

There's only so much you can do with this much code...

'There's only so much you can do with this much code...' yet you found a solution I didn't think of ^^'  The solution I had don't need +.

Jelly, 7 bytes, 10 numbers, Jonathan Allan
Original code:
“1‘ỌȮḊ‘

Then:
“1‘‘ỌȮḊ‘
“1‘‘‘ỌȮḊ‘
“1‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌvḊ‘

You can check the last one on TryItOnline!

Another way would be
“2‘ỌȮḊ‘
“3‘ỌȮḊ‘
...
“9‘ỌȮḊ‘
“9‘ỌvḊ‘

Octave, 21 bytes, 10 numbers, by Stewie Griffin
The fpr was a nice misguidance=)  But I love the (1') -> 2(1') -> 2+(1') sequence!
original:
disp(fpr___f__e_(_'_)     % original
disp(fprintf= e=(1'))     % my solution
disp(fprintf= e=2(1'))
disp(fprintf= e=2+(1'))
disp(fprintf= e=3+(1'))
disp(fprintf= e=4+(1'))
disp(fprintf= e=5+(1'))
disp(fprintf= e=6+(1'))
disp(fprintf= e=7+(1'))
disp(fprintf= e=8+(1'))
disp(fprintf= e=9+(1'))

That sequence is a nice trick indeed!

Hexagony, 7 bytes, 10 numbers, by Martin Ender
Original:
1<@|!__

Code that produces 1 - 10:
1<@|!).
2<@|!).
3<@|!).
4<@|!).
5<@|!).
6<@|!).
7<@|!).
8<@|!).
9<@|!).
9<@|!).!

1: Try it Online!
9: Try it Online!
10: Try it Online!
Here is the hex for the first 9 programs (where # is the number that you want to print):
 # <
@ | !
 ) .

The memory edge is just set to the value you want to print, deflected to the SE and printed.
And the hex for 10:
  9 < @
 | ! ) .
! . . . .
 . . . .
  . . .

Here, I added a character to the end which increased the hex size. First, the memory edge is set to 9, the pointer is deflected to the SE, memory is incremented, wraps around, the pointer is deflected to the SW, the value is printed and the program ends.

Here is a second solution:
1<@|!$)
2<@|!$)
3<@|!$)
...
8<@|!$)
9<@|!$)
9#@|!$)

1: Try it Online!
9: Try it Online!
10: Try it Online!
The hex for 1 - 9 (this time * is the number to print):
 * <
@ | !
 $ )

This works the same as 1 - 9 above.
The hex for 10:
 9 #
@ | !
 $ )

This hits 9 then # switched the instruction pointer to the lower right one, memory is incremented to 10, $ jumps over the !, the pointer is reversed back east where it jumps over ) and ends.

That's amazing. :D I was trying to design a cop where those two solutions (going to side-length 3 and using # on 9) were possible but always ended up with cops that also had boring shortcuts. I was looking for ages whether there was a way to make the # solution work with the | in the centre but didn't find one. Nice work on sorting that out anyway! :)

C#, 90 bytes, 10 numbers, Scepheo
Original:
using ______________________________________________;class C{static void Main(){_______;}}

First:
using System;class D{public D(){Console.Write(+1);}};class C{static void Main(){new D();}}

Then:
using System;class D{public D(){Console.Write(1+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(2+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(3+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(4+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(5+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(6+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(7+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(8+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(9+1);}};class C{static void Main(){new D();}}

That's exactly the intended solution. Nice work.

... tried the same but had a weird compiler error on ideone... knew it was something obvious...

Ruby, 81 bytes, 10 numbers, histocrat
Original code:
x=##/=#%#
)
###x

Cracked:
x=/$/=~%q
)

p x

This was a tricky one. Many characters that were revealed turned out to be red herrings! / isn't division but part of a regex literal. % isn't mod but part of an uncommon string literal syntax. This program simply prints the length of a string delimited by newlines. The subsequent programs can be obtained by inserting additional characters in the second line.

This is very similar to my intended solution, but mine doesn't use p-~x. Can you point to a Ruby version where that's interpreted correctly? In the two I have locally, p~-x works, but p-~x is interpreted as p()-~x causing an undefined method '-' for nil error.

@histocrat Thanks for pointing that out. I assumed it would work and did not test it. Hopefully this edit is what you had in mind.

Even closer, but that prints 0 unmodified. There's one last trick left to find.

@histocrat I think I finally figured it out.

Ding! Well done :)

Octave, 25 bytes, 10 numbers, by Luis Mendo
mean(repmat(1,ones(1,1)))
mean(repmat(2,ones(1,1)))
mean(repmat(3,ones(1,1)))
mean(repmat(4,ones(1,1)))
mean(repmat(5,ones(1,1)))
mean(repmat(6,ones(1,1)))
mean(repmat(7,ones(1,1)))
mean(repmat(8,ones(1,1)))
mean(repmat(9,ones(1,1)))

New iteration here

아희(Aheui), 19 bytes, 10 numbers, by JHM
Original code:
봃法희
반자뭉

Modified:
2
봃法희
반반뭉
3
봃法희
반밬뭉
4
봃法희
반밭뭉
5
봃法희
반발뭉
6
봃法희
반타뭉
7
봃法희
반밝뭉
8
봃法희
반밣뭉
9
봃法희
반밢뭉
10
봃法희
반다뭉

Acc!!, 10 bytes, 9 numbers, by DLosc
Original code :
Write 49+_

To produce the numbers 1 to 9 :
Write 49+_
Write 49+1
Write 49+2
Write 49+3
Write 49+4
Write 49+5
Write 49+6
Write 49+7
Write 49+8

49 is the ascii code of 1. _ contains 0 by default (so 49+_ = 1). And Write prints the character corresponding to the ascii code of its argument. Pretty straight forward.

Octave, 24 bytes, 9 numbers, by flawr
max(repmat(1,ones(),1))%
max(repmat(2,ones(),1))%
max(repmat(3,ones(),1))%
max(repmat(4,ones(),1))%
max(repmat(5,ones(),1))%
max(repmat(6,ones(),1))%
max(repmat(7,ones(),1))%
max(repmat(8,ones(),1))%
max(repmat(9,ones(),1))%

Octave, 24 bytes 9 10 numbers
Note: This crack is for the first version of the cop post (posted the wrong snippet), with the revealed code looking like this: ___a__repmat(__one__),__). The correct version is above.
Original code:
+mean(repmat(1,ones(),1))

Modified versions that print 2-10
1+mean(repmat(1,ones(),1))
2+mean(repmat(1,ones(),1))
3+mean(repmat(1,ones(),1))
4+mean(repmat(1,ones(),1))
5+mean(repmat(1,ones(),1))
6+mean(repmat(1,ones(),1))
7+mean(repmat(1,ones(),1))
8+mean(repmat(1,ones(),1))
9+mean(repmat(1,ones(),1))

Octave, 21 bytes, 9 numbers, by flawr
I really enjoyed this one... Clever :)
a='repmat(1one'(1,8)
a='repmat(2one'(1,8)
a='repmat(3one'(1,8)
a='repmat(4one'(1,8)
a='repmat(5one'(1,8)
a='repmat(6one'(1,8)
a='repmat(7one'(1,8)
a='repmat(8one'(1,8)
a='repmat(9one'(1,8)

What the heck, no that was still not my solution =)

WHAT? Are you kidding me? My oh my...

Well I'll post my solution now=)

JavaScript, 15 bytes, 10 numbers, ETHProductions
Original code:
alert( +"+1"+0)  // Prints 1

Programs:
alert( +"+1"+1)  // Prints 2
alert( +"+1"+2)  // Prints 3
alert( +"+1"+3)  // Prints 4
alert( +"+1"+4)  // Prints 5
alert( +"+1"+5)  // Prints 6
alert( +"+1"+6)  // Prints 7
alert( +"+1"+7)  // Prints 8
alert( +"+1"+8)  // Prints 9
alert( +"+1"+9)  // Prints 10

Python 2, 49 bytes, 10 numbers, AlexRacer
Maybe (just maybe) the intended solution, but if so, plenty of bytes could have been golfed off:
y=10-6;s='0901100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0902100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0903100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0904100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0905100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0906100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0907100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0908100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0909100000';print int(s[8-8+y-2+0+0:y])
y=10-4;s='0909100000';print int(s[8-8+y-2+0+0:y])

Blast I didn't notice you already cracked it until I was about to submit mine. I did: y=10*6;s='0910_____1';print int(s[8+(y>4or-6):y]) changing that final 1 to a 2, ... , 9 and then the * to -: https://repl.it/EW5q :(

Wow, nice one, I knew I hid too many characters :)

Befunge-93, 11 bytes, 10 numbers, James Holderness
905:**-8-.@
905:**-7-.@
905:**-6-.@
905:**-5-.@
905:**-4-.@
905:**-3-.@
905:**-2-.@
905:**-1-.@
905:**-0-.@
905:**-~-.@

Try it online!
Probably not the intended solution.
What I did was get rid of the pesky 25 (5:*) by multiplying it by 0. If we then put a 9 at the beginning then the outputs will be 9 - N where need to generate N from a single command. The only issue is -1 to get 10, but trying to read an integer if there's no input conveniently pushes a -1.

05AB1E, 5 bytes, 10 numbers, by Adnan.
Original code:
…[==1

1-10:
…[==1
…[==2
…[==3
…[==4
…[==5
…[==6
…[==7
…[==8
…[==9
…[==T

Explanation:
…[==   3 char string
    1  Push number

05AB1E, 6 bytes, 10 numbers, Adnan
Original code:
¼ [==q

Keep adding ¼'s to output up to 10:
¼¼ [==q
¼¼¼ [==q
¼¼¼¼ [==q
¼¼¼¼¼ [==q
¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼¼ [==q

Try it online
How it works:
¼        # Increment counter_variable to count_of(¼), it's printed at some point...
  [      # Infinite loop start
   ==    # Print nothing because stack is empty
     q   # Quit

Python 2, 111 bytes, 10 numbers, feersum
Original, then the program for 1:
print +int('''3EE5EE6EE0EE2EE5EE6EE4EE9EE1EE5EE9EE4EE6EE7EE5EE7E''')%int('''2EE0EE9EE8EE9EE2EE3EE5EE0EE3EE6''')
print +int('''39951562603020050069949998519154798549467371659275''')%int('''2000009008009002\x3005000\x3006''')

The other programs are just appending 1-9 before the +. With numbers of this size the problem is fairly simple, since we have a lot of freedom in the lower digits of the larger number. To make things a bit easier, a few of the 3s in the modulus have been turned into \x30, which is the code point for 0.

Python 3, 19 bytes, 10 numbers, Sp3000
Newlines are a real bummer.
print(##bin()

0+1)

0+1 ... 9+1.

Yeah... I forget about newlines every CnR... :/

JavaScript, 21 Bytes, 10 Numbers, Shaun H
Original:
alert(b_oa_"3____1"))

First:
alert(btoa|"3"&("1"))

Then:
alert(btoa|"3"-("1"))
alert(btoa|"3"-("0"))
alert(btoa|"4"-("0"))
alert(btoa|"5"-("0"))
alert(btoa|"6"-("0"))
alert(btoa|"7"-("0"))
alert(btoa|"8"-("0"))
alert(btoa|"9"-("0"))
alert(btoa|"9"-(~"0"))

//Using console.log instead of alert

console.log(btoa|"3"&("1"))
console.log(btoa|"3"-("1"))
console.log(btoa|"3"-("0"))
console.log(btoa|"4"-("0"))
console.log(btoa|"5"-("0"))
console.log(btoa|"6"-("0"))
console.log(btoa|"7"-("0"))
console.log(btoa|"8"-("0"))
console.log(btoa|"9"-("0"))
console.log(btoa|"9"-(~"0"))

Python 2, 26 bytes, 10 numbers, DLosc
Original:
print r___e(3______+_[___]

Solve:
print range(3,)[1]#+_[___]
print range(3,)[-1]#+_[___]
print range(3,4)[-1]#+_[___]
print range(3,5)[-1]#+_[___]
print range(3,6)[-1]#+_[___]
print range(3,7)[-1]#+_[___]
print range(3,8)[-1]#+_[___]
print range(3,9)[-1]#+_[___]
print range(3^9)[-1]#+_[___]
print range(2^9)[-1]#+_[___]

Yeah, I'm fairly sure this still isn't the intended solve.

I am learning things about Python that I never knew. Never expected range(3,) to be valid syntax.

Befunge-93, 11 bytes, 10 numbers, James Holderness
"15:**-6-.@
"15:**-6-2.@
"15:**-6-2+.@
"15:**-6-3+.@
...
"15:**-6-9+.@

A more complete crack of James' Befunge cop, after Martin's here. Because Befunge-93 has a limited board, the IP actually waits until it gets to the end of the board before wrapping around, unlike other 2D languages such as ><>. This means that a wraparound char push with " ends up pushing the values of the empty cells too, which by default is 32 for space.
Hence here at the start we push a bunch of chars, with 32 on top, then 1:5**- on that gives 32 - (1*(5*5)) = 32 - 25 = 7. Subtract another 6, and we have 1 to start off the ladder.

Not only was your quote trick unexpected, but I never realised you could so easily get the rest of the sequence once you had the 1. In retrospect, Martin's solution could have been made to work in the same way without having to resort to the -1 hack.

@JamesHolderness Come to think about it... yeah, that would have been much simpler (and nicer)

Perl, 31 bytes, 10 numbers, by Gabriel Benamy
I'm pretty sure this is the intended answer this time (up to trivial variations, such as using '<' rather than "<").
Original code (must be saved to a file and run via giving the file at the command line, it doesn't matter what the name is):
__e_$a,_<__$_;1 while_$a_;say$_

Crack for 1:
open$a,"<",$0;1 while<$a>;say$.

To crack for the other values, append a newline to the file each time (e.g. the above prints 2 with one newline appended, 3 with two newlines appended, and so on). The program works by reading its own source code from disk (this isn't a quine competition, so you're allowed to do that!) and printing the line number of the line just beyond the end.
I found this via deducing that it probably started with a keyword or built-in function with a four letter name, and searching the list of keywords and builtin functions for functions matching ..e.. As soon as you realise that open is a possibility, everything is straightforward from there (the unknown character before the final semicolon is in retrospect very suspicious).

Yes!  This was it all along!

Pyth, 3 bytes, 10 numbers, by Yotam Salmon
Original code was __Q, with_ unknown.
1.Q: Implicit print 1, throw error when trying to evaluate empty input.
 Same answer for 2-9 (with the number 1 replaced by 2-9), and the code T.Q for 10 (since T is initialized to 10).

Cool solution! Not what I thought of ;-) But my solution worked for any number, and yours works up to 10. Is that accepted?

Octave, 19 bytes, 10 numbers, by flawr
Probably not the intended solution, but hey.
'psca'(1 )+'1'-160'
'qsca'(1 )+'1'-160'
...
'ysca'(1 )+'1'-160'

Wasn't even close to my solution=)

Octave, 26 bytes, 10 numbers, by LuisMendo
original
__a__repmat(_+one___1+__))

solution:
mean(repmat(0+ones, 1+0 ))
mean(repmat(1+ones, 1+0 ))
mean(repmat(2+ones, 1+0 ))
...

Octave, 17 bytes, 10 numbers, by flawr
From
_od(3_13_13_7_1_)

To the original code:
mod(3113+1387,11) #1

The rest of the numbers:
mod(3113+1388,11) #2
mod(3113+1389,11) #3
mod(3114+1389,11) #4
mod(3115+1389,11) #5
mod(3116+1389,11) #6
mod(3117+1389,11) #7
mod(3118+1389,11) #8
mod(3119+1389,11) #9
mod(3119+1379,11) #10

Try it online! for the first case
Explanation
mod(x, y) computes the modulo of x and y. Here is the docs for mod.
Process
I don't know Octave, I've never used it, but I was interested in this particular sumbission. So I decided to try to crack it. First, I used this website to help me find an Octave command that is three characters long and has an od in the end. I found it to be mod. Then I began experimenting with the numbers in its online interpreter. After some time, I ended up with
mod(3_13+13_7,1_)

after which time I decided to create a python script (on TIOv2!) to brute-force the solution. The script printed the values for the _ whenever first_param%second_param==1. I first ran the python script for 10 (the second paramter to the mod function). I got tons of hits. Then I ran it again for 11. I got only a few hits this time, after which I decided to use 11 as the second parameter and the following values for the first parameter 3113+1387 just out of randomness. Now I got the original code. From there, I began incrementing the last digit of the numbers, so that I did 1387->1388->1389 and then 3113->3114->3115->3116->3117->3118->3119. Now I got the first 9 numbers.
mod(3119+1389,11) #evaluates to 9

Now 10 was the only one remaining. I tried changing the 1389 to 1399 to see if it becomes 10, but instead it resulted to 8. So I changed it to 1379, and it resulted in 10!

That almost feels like cheating, but good job! =)

@flawr Well, you know how the saying goes, "Fight code with code," or in this case, "Crack code using code." :)

Good luck with this one =)

C, 216 bytes, 10 numbers, by Joshua
Original code :
#include <stdio.h>

FILE *a, *b;

void x() { ___________ int x; x = __; ________a____d____x_;}
void y() { ___________ int x; fprintf(b,"%d\n",x);}
int main() { a=fopen("/dev/null", "w");b=stdout;x();y();return 0;}

Cracked code :
#include <stdio.h>

FILE *a, *b;

void x() { volatile    int x; x =  0; fprintf(a," %d",++x);}
void y() { volatile    int x; fprintf(b,"%d\n",x);}
int main() { a=fopen("/dev/null", "w");b=stdout;x();y();return 0;}

Change the x = 0 to the number you want to print minus 1 : x=0 for 1, x=1 for 2, x=2 for 3 etc, until x=9 for 10.

This is indeed the form of the solution. I have a few characters different but this does work.

@Joshua I think you didn't used volatile since at first you said there were no spaces in the eleven _ before int x, so what did you use instead? (I'm intrigued because I don't think there is any C keyword that is 11 characters long...)

I used volatile/**/ to throw people off the scent. ;;;;volatile also works the same way.

@Joshua volatile/**/ is 12 characters long and there were only 11 underscores...

my bad. It's a transcription error on masking it. Did you notice also your file was 214 bytes?

@Joshua Indeed I noticed the original code was 214 instead of 216 but I just thought it was some spaces at the end of a line of something alike that resulted in a wrong byte count. But it was the two underscores missing!

PowerShell, 7 bytes, 10 numbers, by TimmyD
Original code :
___(__0

Cracked code :
+1#(__0
+2#(__0
+3#(__0
...
+9#(__0
1+9#(__0

Java, 70 bytes, 10(+) numbers, by masterX244
//Submission v
__________________________ ____(_____________________________)________
//Original code v
class A{public static void main(String[]a){System.out.print(')'-40);}}//1

This makes use of the character codes for numbers. The char ) is 41. So when you subtract 40 from it, it evaluates to 1. By incrementing the char by 1, we effectively increase the output by 1 too.
Try it online in Ideone!. Note: in Ideone, you need to have public before class and the name of the class should be HelloWorld
Other numbers:
class A{public static void main(String[]a){System.out.print('*'-40);}}//2
class A{public static void main(String[]a){System.out.print('+'-40);}}//3
class A{public static void main(String[]a){System.out.print(','-40);}}//4
class A{public static void main(String[]a){System.out.print('-'-40);}}//5
class A{public static void main(String[]a){System.out.print('.'-40);}}//6
class A{public static void main(String[]a){System.out.print('/'-40);}}//7
class A{public static void main(String[]a){System.out.print('0'-40);}}//8
class A{public static void main(String[]a){System.out.print('1'-40);}}//9
class A{public static void main(String[]a){System.out.print('2'-40);}}//10
...
class A{public static void main(String[]a){System.out.print('~'-40);}}//86

Edit: fixed mistake
Edit 2: Yes, this can go upto 86 and maybe even more!

Grrr. Back to square one... need some dirtier code...

Perl, 31 bytes, 10 numbers, by Gabriel Benamy
Original code:
__e_$a__<__$_;1 while_$a_;say$_

Cracked:

the;$a+=<1\$>;1 while!$a ;say$a
the;$a+=<1\$>+1 while!$a ;say$a
the;$a+=<1\$>+2 while!$a ;say$a
the;$a+=<1\$>+3 while!$a ;say$a
the;$a+=<1\$>+4 while!$a ;say$a
the;$a+=<1\$>+5 while!$a ;say$a
the;$a+=<1\$>+6 while!$a ;say$a
the;$a+=<1\$>+7 while!$a ;say$a
the;$a+=<1\$>+8 while!$a ;say$a
the;$a+=<1\$>+9 while!$a ;say$a

The principle using q<> I used last time doesn't seem to quite work here, so I used one of the intended uses of <> brackets (if a fairly obscure one) to create the string 1$ via globbing. Using += rather than = for the assignment to $a converts it to an integer, thus just 1, and then the solution continues the same way as my previous crack.
Fun fact: random sequences of letters in void context (such as the) are no-ops in Perl if they don't happen to spell a keyword.

You're really gonna make me give up how I did it, aren't you? :P  Should I add one more byte to confuse you?

Perl, 26 bytes, 10 numbers by Gabriel Benamy
Original code:
____;@a=($_..10);say$a[__]

Cracked:
$_=0;@a=($_..10);say$a[+1]
$_=1;@a=($_..10);say$a[+1]
$_=2;@a=($_..10);say$a[+1]
$_=3;@a=($_..10);say$a[+1]
$_=4;@a=($_..10);say$a[+1]
$_=5;@a=($_..10);say$a[+1]
$_=6;@a=($_..10);say$a[+1]
$_=7;@a=($_..10);say$a[+1]
$_=8;@a=($_..10);say$a[+1]
$_=9;@a=($_..10);say$a[+1]

In fact I tested this on my Mac using print instead of say with perl -e... However I do think they should work basically the same.
This is incrementing the "base" of the array and say the second element of the array.  Replacing _s by other characters should work too.

Perl, 26 bytes, 10 numbers, by Gabriel Benamy
Original code:
____;@a=($_..10);say$a[__]

Cracked:

____;@a=($|..10);say$a[+1]
____;@a=($|..10);say$a[1+1]
____;@a=($|..10);say$a[2+1]
____;@a=($|..10);say$a[3+1]
____;@a=($|..10);say$a[4+1]
____;@a=($|..10);say$a[5+1]
____;@a=($|..10);say$a[6+1]
____;@a=($|..10);say$a[7+1]
____;@a=($|..10);say$a[8+1]
____;@a=($|..10);say$a[9+1]

I didn't even need the blanks at the start (and as ____ is a legal but pointless Perl statement, I left them as is). The only subtlety here is finding a variable that starts at 0, but there are plenty to choose from; I chose $|.

C++, 10 numbers, 468 bytes, by Joshua
Original program:
#include <unistd.h>
#include <iostream>
#include <fstream>

$$$$$$$$$$$$$ {
    std::ofstream *garbalgase()
    {
        std::ofstream *golgi = new std::ofstream;
        golgi->open("/dev/null");
        return golgi;
    }

    std::ostream * const jawbone = garbalgase();
    $$$$$ int value = $_$$$$$$;
}

int main()
{
    $$$$$ $$$$$$$$/$$int vl = value;
    if (fork() == 0)
    {
        $$$$$$$$$$$<std::ostream $*>($jawbone) = &std::cout;
        vl -= 4;
        _exit(0);
    }
    (*jawbone) << (vl - 9) << std::endl;
}

My crack (prints 1):
#include <unistd.h>
#include <iostream>
#include <fstream>

extern "C++"  {
    std::ofstream *garbalgase()
    {
        std::ofstream *golgi = new std::ofstream;
        golgi->open("/dev/null");
        return golgi;
    }

    std::ostream * const jawbone = garbalgase();
    /*$*/ int value = '_',vl=1;
}

int main()
{
    std:: cout<<+1/1;int vl = value;
    if (fork() == 0)
    {
        //$$$$$$$$$<std::ostream $*>($jawbone) = &std::cout;
        vl -= 4;
        _exit(0);
    }
    (*jawbone) << (vl - 9) << std::endl;
}

To get a crack for 2 up to 10, change the +1/1 to 1+1/1, 2+1/1, 3+1/1, and so on.
I originally tried to comment out much more of the program than this, but it turns out that most of it is naturally harmless and cancels itself out. (Because it happens to use _exit rather than exit, we can put the number to print out into the stdout buffer in both threads; the parent thread won't have time to flush it before it exits.) The hardest part is dealing with the } character just before int main(); you can't make it the closing brace of a function without -fpermissive, but you can make it the closing brace of a calling convention block (in this case I used extern "C++", the default, to basically cancel the braces out).
I also accidentally declared vl twice, but oh well. It doesn't break the crack, just shows how many spare characters there are here.

Ohhhh, extern "C++"! That was the missing piece of the puzzle for me.

The intended solution is quite different. I forgot you could have a space after :: or I would have managed to block this solution. Oh well.

COW, 51 bytes, 10 numbers, by Gabriel Benamy
MoO ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ OOM // incomplete
MoO Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ OOM //original code outputs 1

Other numbers:
MoO MoO Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ OOM //2
MoO MoO MoO Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ OOM //3
MoO MoO MoO MoO Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ OOM //4
MoO MoO MoO MoO MoO Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ OOM //5
MoO MoO MoO MoO MoO MoO Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ OOM //6
MoO MoO MoO MoO MoO MoO MoO Mo_ Mo_ Mo_ Mo_ Mo_ OOM //7
MoO MoO MoO MoO MoO MoO MoO MoO Mo_ Mo_ Mo_ Mo_ OOM //8
MoO MoO MoO MoO MoO MoO MoO MoO MoO Mo_ Mo_ Mo_ OOM //9
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Mo_ Mo_ OOM //10

Explanation
MoO //increment current memory block value by 1.
OOM //print current memory block as output to STDOUT
Mo_ //gets ignored since the compiler doesn't recognise it

Try it online!

Cows don't moo, Cows quack!

Hexagony, 15 bytes, 10 numbers, Sunny Pun
\!?\1<<3@_!?_<3
\!?\2<<3@_!?_<3
\!?\3<<3@_!?_<3
\!?\4<<3@_!?_<3
\!?\5<<3@_!?_<3
\!?\6<<3@_!?_<3
\!?\7<<3@_!?_<3
\!?\8<<3@_!?_<3
\!?\9<<3@_!?_<3
\!?\9)<<3@_!?_<3

Try it online!
I'm afraid this wasn't sufficiently well constrained (as this is almost definitely nowhere near the intended solution).

Will mark as cracked once not on mobile.  Overlooked that adding a byte at line 2 will also shift line 3 :P

Python 2, 26 bytes, 10 numbers DLosc
Original: print r___e(3_4____+_[___]
print range(304)[ 1+#[
0 ]

Where the 0 character is incremented up through 9.

Well, Sp3000 warned me about newlines... heh. Have an upvote.

alternate: print r'1_e(3_4____+'[0  ]

@DestructibleWatermelon How do you get 10 with that?

whoops lol. It almost worked

I got it! print r'10e(3642345+'[0+0], print r'10e(3642345+'[0+7], print r'10(3642345+'[0+7], print r'103642345+'[0+7], print r'10642345+'[0+7], print r'10642345+'[0+2], print r'10742345+'[0+2], print r'10842345+'[0+2], print r'10942345+'[0+2], print r'10942345+'[0:2]

I'm actually rather proud of myself for that one

Java, 126 bytes, 10 numbers, masterX244
Yes we have seen Unicode escapes many times here at PPCG.
cl\u0061ss Z\u007bpublic st\u0061tic void main(String[]a){System. out.print(/*_"___42*/0+1/*_00____00____".*/)/*______0)_*/;}}

s/0+1/1+1/ ... 9+1.

Damn again... btw my intended solution only has one commented out character

got more unicode for you to crack this time....

QBasic, 13 bytes by DLosc
?+INT(LOG(3))  'Fixed thanks to feersome
?1+INT(LOG(3))
?2+INT(LOG(3))
?3+INT(LOG(3))
?4+INT(LOG(3))
?5+INT(LOG(3))
?6+INT(LOG(3))
?7+INT(LOG(3))
?8+INT(LOG(3))
?9+INT(LOG(3))

Try QBasic at archive.org.
Seems like the intended solution is:
? INT(LOG(3))    '1
? INT(LOG(13))   '2
? CINT(LOG(13))   '3

but that can't possibly work because the natural log function grows too quickly. There are no sequences of this form that get past 4.

I don't think this works. You have to change from 9 to 10 via one edit, whereas changing 9 to 1 and inserting 0 is two edits. Unless I'm misunderstanding...? Please post the exact sequence of changes.

@DLosc: I believe the rules allow 1 insertion character and resetting all the mask characters. If not so, all of the edit-only solutions don't work for 10.

The wording of the rules is admittedly not the clearest, but I'm quite sure that each iteration must be a modification from the previous iteration, without "resetting." See all the solutions that do 0+1 -> 8+1 -> 9+1 rather than 1 -> 9 -> 10. In any case, I can tell you that my original code does not reset, but makes one edit at each step.

The second attempt inserts 3 characters before the I where there are only two blanks, but would it work if you started with ?+INT(LOG(3)) and then continued with the same 2-10?

@feersum: That would work if I'm allowed to change the inserted character.

The 1 program must have exactly one character for each blank. After that, each new program must have a Levenshtein distance of one from the previous, irrespective of where the blanks were.

@DLosc: Try the second one then.

Ah. There I confess you've got me. (But please edit the first one out of your answer.)

Python 2, 26 bytes, 10 numbers, DLosc
print range(11)[1or+ [  ]]
print range(11)[2or+ [  ]]
print range(11)[3or+ [  ]]
print range(11)[4or+ [  ]]
print range(11)[5or+ [  ]]
print range(11)[-5or+ [  ]]
print range(11)[-4or+ [  ]]
print range(11)[-3or+ [  ]]
print range(11)[-2or+ [  ]]
print range(11)[-1or+ [  ]]

I thought I'd try this with comments or newlines or anything. Definitely not the intended solution...

Nope, not intended. :) Back to the drawing board...

JavaScript (ES6), 63 bytes, 10 numbers by Arnauld
Original code:
eval([...(n=0,"l?0?a?(?x?")].sort(_=>[...????+[]][n++]).join``)

Modified:
eval([...(n=0,"le0ta1(rx)")].sort(_=>[...8/73+[]][n++]).join``)
eval([...(n=0,"le0ta2(rx)")].sort(_=>[...8/73+[]][n++]).join``)
...
eval([...(n=0,"le0ta9(rx)")].sort(_=>[...8/73+[]][n++]).join``)
eval([...(n=0,"le0taa(rx)")].sort(_=>[...8/73+[]][n++]).join``)

This was a lot of fun to get to the bottom of, even though my first approach was off!

Hey, well done! ;)

R, 22 bytes, 10 numbers by Gregor
Original code:
_et_______)____is_____

Cracked:
For 1
#et
cat(+1)#___is_____

For 2
#et
cat(1+1)#___is_____

For the rest just increment the 1's
found a short enough print to sneak it in a gap with newline and comment.

the cat is after a newline which is placed behind the  _et :P @Gregor And newlines are exactly one character

Hmmm, I guess it's legit.

yeah, some other submissions got broken in a similar way, always check that gaps don't allow to sneak something in to avoid surprise cracks like this one. @Gregor

Octave, 16 bytes, 10 numbers by Stewe Griffin
Original code:
ev_l('P_NIS'-2_)

Cracked:
eval('PFNIS'-28)
eval('PFNIR'-28)
eval('PFNIQ'-28)
eval('PFNIP'-28)
eval('PFNIO'-28)
eval('PFNIN'-28)
eval('PFNIM'-28)
eval('PFNzM'-28)
eval('PFNGM'-28)
eval('PFNGN'-28)

After finding a way around the 8 without a zero it was easy. Trick was to use the 1 as a exponent which is a no-op and then contineru with +
relevant part unobfuscated here:
4*2-1
eval('PFNIM'-28)
4*2^1
eval('PFNzM'-28)
4*2+1
eval('PFNGM'-28)

JavaScript, 33 Bytes, 10 Numbers, Shaun H

Original:
alert(_to__"_Xc0__0_B6____Zp=="))

First:
alert(atob|"0Xc0"/0xB6||("Zp=="))

Then:
alert(atob|"0X1c0"/0xB6||("Zp=="))
alert(atob|"0X2c0"/0xB6||("Zp=="))
alert(atob|"0X2F0"/0xB6||("Zp=="))
alert(atob|"0X3F0"/0xB6||("Zp=="))
alert(atob|"0X4F0"/0xB6||("Zp=="))
alert(atob|"0X4F0"/0xB0||("Zp=="))
alert(atob|"0X5F0"/0xB0||("Zp=="))
alert(atob|"0X5F0"/0xA0||("Zp=="))
alert(atob|"0X5F0"/0x90||("Zp=="))

// Using console.log instead of alert

console.log(atob|"0Xc0"/0xB6||("Zp=="))
console.log(atob|"0X1c0"/0xB6||("Zp=="))
console.log(atob|"0X2c0"/0xB6||("Zp=="))
console.log(atob|"0X2F0"/0xB6||("Zp=="))
console.log(atob|"0X3F0"/0xB6||("Zp=="))
console.log(atob|"0X4F0"/0xB6||("Zp=="))
console.log(atob|"0X4F0"/0xB0||("Zp=="))
console.log(atob|"0X5F0"/0xB0||("Zp=="))
console.log(atob|"0X5F0"/0xA0||("Zp=="))
console.log(atob|"0X5F0"/0x90||("Zp=="))

The intended version:
alert(_to__"_Xc0__0_Bf____Zp=="))

First:
alert(atob|"0Xc0"/0xBf||("Zp=="))

Then:
alert(atob|"0X1c0"/0xBf||("Zp=="))
alert(atob|"0X2c0"/0xBf||("Zp=="))
alert(atob|"0X2c0"/0xB0||("Zp=="))
alert(atob|"0X3c0"/0xB0||("Zp=="))
alert(atob|"0X4c0"/0xB0||("Zp=="))
alert(atob|"0X4F0"/0xB0||("Zp=="))
alert(atob|"0X5F0"/0xB0||("Zp=="))
alert(atob|"0X5F0"/0xA0||("Zp=="))
alert(atob|"0X5F0"/0x90||("Zp=="))

// Using console.log instead of alert

console.log(atob|"0Xc0"/0xBf||("Zp=="))
console.log(atob|"0X1c0"/0xBf||("Zp=="))
console.log(atob|"0X2c0"/0xBf||("Zp=="))
console.log(atob|"0X2c0"/0xB0||("Zp=="))
console.log(atob|"0X3c0"/0xB0||("Zp=="))
console.log(atob|"0X4c0"/0xB0||("Zp=="))
console.log(atob|"0X4F0"/0xB0||("Zp=="))
console.log(atob|"0X5F0"/0xB0||("Zp=="))
console.log(atob|"0X5F0"/0xA0||("Zp=="))
console.log(atob|"0X5F0"/0x90||("Zp=="))

Intended crack?
alert(atob|"0Xc0"-0xBf||("Zp=="))
alert(atob|"0Xc0"-0xBe||("Zp=="))
alert(atob|"0Xc0"-0xBd||("Zp=="))
alert(atob|"0Xc0"-0xBc||("Zp=="))
alert(atob|"0Xc0"-0xBb||("Zp=="))
alert(atob|"0Xc0"-0xBa||("Zp=="))
alert(atob|"0Xc0"-0xB9||("Zp=="))
alert(atob|"0Xc0"-0xB7||("Zp=="))
alert(atob|"0Xc0"-0xB6||("Zp=="))

// Using console.log instead of alert

console.log(atob|"0Xc0"-0xBf||("Zp=="))
console.log(atob|"0Xc0"-0xBe||("Zp=="))
console.log(atob|"0Xc0"-0xBd||("Zp=="))
console.log(atob|"0Xc0"-0xBc||("Zp=="))
console.log(atob|"0Xc0"-0xBb||("Zp=="))
console.log(atob|"0Xc0"-0xBa||("Zp=="))
console.log(atob|"0Xc0"-0xB9||("Zp=="))
console.log(atob|"0Xc0"-0xB7||("Zp=="))
console.log(atob|"0Xc0"-0xB6||("Zp=="))

I accidentally posted my version for 10 and you still cracked it, nice

Posted my intended puzzle in the Cops answer, still gave you crack credit but if you want another puzzle feel free to try it.

Python, 10+ numbers, 61 bytes, Flp.Tkc
try:x
except:print(__import__('sys').exc_info()[2].tb_lineno)

For subsequent numbers, add a newline to the start of the program.

Good job! I knew it wasn't hard to crack, I just wanted a funny way to print numbers: "hey, let's throw an error and print the line it's on "

Python 3, 56 bytes, 6 numbers, by Flp.Tkc
Cop's post:
print(_______(str(ord(x))for x in ________).___________)

Crack:
print(0+1)#__(str(ord(x))for x in ________).___________)
print(1+1)#__(str(ord(x))for x in ________).___________)
print(2+1)#__(str(ord(x))for x in ________).___________)
...

Ocaml, 51 bytes, 10 numbers, by feersum
Original code:
^^t^r^^^^-^^^^-^^r^^^^=^^^^^^^r^^^^r^^^^^^^(^^^^/0)

Cracks for 1-10:

let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/0)
let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/1)
let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/2)
let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/3)
let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/4)
let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/5)
let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/6)
let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/7)
let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/8)
let(r,  (-/)(*-  r*)) =0,(+);;r;; print_int(1  -/9)

The hard part is to get rid of the /0, which would normally cause an error. There's just enough room to define a new operator (-/), which I defined to be an alias for addition (+). Then I could construct the answer with 1-/0, 1-/1, 1-/2, and so on. The rest of the solution fits the other required characters into place with comment marks (* *) and statement marks ;;, and mostly just cancels itself out (although I had to define r in order to handle the first r in the program and in order for ;;r;; to correctly be a no-op).

I failed to consider the let statement with tuple assignment. Trying again with one more revealed.

OCaml, 51 bytes, 10 numbers, by feersum
Original code:
^^t^r^^^^-^^^^-^^r^^^^=^^^^^^^r^^^^r^^^^^^^(^^^0/0)

Code that produces 1-10:

let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/0/0)
let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/1/0)
let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/2/0)
let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/3/0)
let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/4/0)
let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/5/0)
let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/6/0)
let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/7/0)
let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/8/0)
let r,((*-^^^^-^^r*)/)=0,(+);;r;; print_int( 1/9/0)

The same trick still works; there's rather less room, because now I have to redefine division to mean addition rather than using a new operator, but there's still enough.

Pyth, 4 bytes, 9 numbers, isaacg
Original code:
."1Q

Which is a packed string containing the character 1. The other programs:
."2Q
."3Q
."4Q
."5Q
."6Q
."7Q
."8Q
."9Q

I thought this would also contain some unprintables, but if you insert a l in the beginning of each code, you can see that the length of each string is always 1 (only containing the digit).

Python, 28 bytes, 10 numbers, by CrazyPython
print (0+1+0*1000)+(0*0*0*4)
print (1+1+0*1000)+(0*0*0*4)
print (2+1+0*1000)+(0*0*0*4)
...

My original solution had odr and stuff.. welp you cracked it; congrats.

><>, 5 bytes, 10 numbers, Teal pelican
>21n;
>22n;
>23n;
>24n;
>25n;
>26n;
>27n;
>28n;
>29n;
>2an;

Javascript 19 bytes 10 numbers, by Shaun H
Original:
alert((_1*1_10__1_)

Code that produces 1 - 10:
alert(( 1*1%10)/1 )
alert(( 2*1%10)/1 )
alert(( 3*1%10)/1 )
alert(( 4*1%10)/1 )
alert(( 5*1%10)/1 )
alert(( 6*1%10)/1 )
alert(( 7*1%10)/1 )
alert(( 8*1%10)/1 )
alert(( 9*1%10)/1 )
alert(( 9*1%10)+1 )

Perl, 7 bytes, 10 numbers, ais523
^F means a "Control-F" character.
$^F is a magic variable that equals 2.
say$^F-1
say$^F*1
say$^F+1
say$^F+2
say$^F+3
say$^F+4
say$^F+5
say$^F+6
say$^F+7
say$^F+8

Unless "control-f" is 2 bytes, this is only 7 bytes, not 8.

I miscounted. The original was meant to be 7 bytes.

Alternate crack to DLosc, 26 bytes, 10 numbers
original:
print r___e(3_4____+_[___]

crack
>>> print r'10e(3642345+'[0+0]
1
>>> print r'10e(3642345+'[0+7]
2
>>> print r'10(3642345+'[0+7]
3
>>> print r'103642345+'[0+7]
4
>>> print r'10642345+'[0+7]
5
>>> print r'10642345+'[0+2]
6
>>> print r'10742345+'[0+2]
7
>>> print r'10842345+'[0+2]
8
>>> print r'10942345+'[0+2]
9
>>> print r'10942345+'[0:2]
10

programs 2 to 5's purpose is to place a number next to 10, so that for 10, we can change [0+2] to [0:2], and get the number 10. the rest just change the number to get the other numbers
nice challenge :)
Intended solution?

This is essentially the intended solution, just with a few details changed. Nice work!

@DLosc I take it that the original program was print r'10e(3541234+'[0+7]?

No--see edit to cop submission.

Ruby, 81 bytes, 10 numbers, histocrat
Yay comments...
require'digest/md5'
p Digest::MD5.digest('')&&0+1#')[n=0].ord^'straYNpraq'[n].ord

0+1 ... 9+1 as usual.

You're quite lucky, that barely fits...

Ha, I should've left in a linebreak.

Python 2, 33 bytes, 9 numbers, CrazyPython
Original code:
#__________________
riny
________

Code to print 1:
# my comment
riny=1
riny
print +1

And then just increment the 1 from there on out.

Try solving it without exploiting an unintended easy solution.

@CrazyPython Do you mean "without literal newlines", or there something further?

Python 2, 26 bytes, 10 numbers by DLosc, non-competing
Non-competing because Sp3000 beat me to it.
print r___e(_______+_[___]

print range(19)[1]#+_[___]
print range(19)[2]#+_[___]
print range(19)[3]#+_[___]
print range(19)[4]#+_[___]
print range(19)[5]#+_[___]
print range(19)[6]#+_[___]
print range(19)[7]#+_[___]
print range(19)[8]#+_[___]
print range(19)[9]#+_[___]
print range(19)[-9]#+_[___]

R, 21 bytes, 10 numbers, Gregor

Cop's: __i___________i______
Rob's: write(a<-1+0,file="")

Of course there's a bunch of possibility as a can be any letter (and is not needed at all)...

R, 8 bytes, 10 numbers by Tensibai
Original code:
_a___+__

Modified:
max(0+1)
max(1+1)
...
max(4+5)
max(5+5)

That's the idea, I assume that it's ok as the problem didn't specify if the program should print or return, so cat or max will give the same thing for 1+0 to 1+9. Good job ;)

@Tesnbai Awesome! I've not used R before so I wasn't sure on IO rules... Thanks for confirming!

Well, on a script call, this one won't output anything, the result will only be printed in an interactive session, but as the original challenge doesn't really specify it, I assume it's ok :)

ASMD, 8 bytes, 10 numbers, by Oliver

For 1, 1t-t+++C
For 2, 1t-t+++C{
For 3, 1t-t+++C{{
…

Works with the latest commit at the time of posting. C claims to be implemented, but it isn’t.
Each program works as follows:
1              Push 1.             1
 t             Triplicate.         1 1 1
  -            Subtract.           1 0
   t           Triplicate.         1 0 0 0
    +          Add.                1 0 0
     +         Add.                1 0
      +        Add.                1
       C       Do nothing.         1
        {{{    Increment n times.  4

Perl, 31 bytes, 10 numbers, by Gabriel Benamy
Original code:
__e_$a__<__$_;1 while_$__;say$_

Code that produces 1 to 10 (note: these answers each have a leading space that doesn't show up in StackExchange's markdown):

 $e=$a+q<1_$>;1 while!$e ;say$e
 $e=$a+q<1_$>+1 while!$e ;say$e
 $e=$a+q<1_$>+2 while!$e ;say$e
 $e=$a+q<1_$>+3 while!$e ;say$e
 $e=$a+q<1_$>+4 while!$e ;say$e
 $e=$a+q<1_$>+5 while!$e ;say$e
 $e=$a+q<1_$>+6 while!$e ;say$e
 $e=$a+q<1_$>+7 while!$e ;say$e
 $e=$a+q<1_$>+8 while!$e ;say$e
 $e=$a+q<1_$>+9 while!$e ;say$e

I'm genuinely unsure whether you intended something like this and were aiming for misdirection, or whether this solution is completely different from the intended one.
The main trick I used is Perl's ability to get rid of unwanted characters by using a q, thus changing them into custom quotation marks (while allowing me to drop something that looks like 1 as an integer into the string that's actually quoted). It's not a trick that's normally that useful when golfing, because Perl has quote marks that use fewer bytes, but it comes in handy for challenges like this.

Holy crap??  This is not even remotely what I was going for, but really nicely done!  Let me see if I can add one more character to give you another challenge!

QBasic, 12 bytes, 10 numbers, by DLosc
Cop:
_I_T__O_(3))

Crack:
?I+T-(O<(3))
?I+1-(O<(3))
?I+2-(O<(3))
?I+3-(O<(3))
?I+4-(O<(3))
?I+5-(O<(3))
?I+6-(O<(3))
?I+7-(O<(3))
?I+8-(O<(3))
?I+9-(O<(3))

Still downloading QB64. But I think this should work. Not sure whether it is the original, though.
QBasic uses bitwise operators as logical operators, instead of having both of them. So true is -1.

Well that was unexpected. No, definitely not the original. ;)

QBasic, 12 bytes, 10 numbers, by DLosc
Cop:
_INT(_O_(3))

Crack:
?INT(LOG(3))
?INT(LOG(13))
?INT(LOG(33))
?INT(LOG(73))
?INT(LOG(173))
?INT(LOG(573))
?INT(LOG(1573))
?INT(LOG(5573))
?INT(LOG(9573))
?INT(LOG(39573))

Finally, the intended solution!

Hexagony, 12 bytes, 10 numbers, Sunny Pun
[!_>!@!1)@!_
[!_>!@!2)@!_
[!_>!@!3)@!_
[!_>!@!4)@!_
[!_>!@!5)@!_
[!_>!@!6)@!_
[!_>!@!7)@!_
[!_>!@!8)@!_
[!_>!@!9)@!_
[!__!@!9)@!_

Try it online!
Unfortunately, this is again a cheap solution.

Hexagony, 18 bytes, 10 numbers, Riley
.<.{_]5[$@!.=@.!!1
.<.{_]5[$@!.=@.!!2
.<.{_]5[$@!.=@.!!3
.<.{_]5[$@!.=@.!!4
.<.{_]5[$@!.=@.!!5
.<.{_]5[$@!.=@.!!6
.<.{_]5[$@!.=@.!!7
.<.{_]5[$@!.=@.!!8
.<.{_]5[$@!.=@.!!9
.<.{_]5[$@!.=@)!!9

Try it online!
Certainly not the intended solution.

Acc!!, 46 bytes, 10 numbers, DLosc
1
Count i while 0^_-i  {
Write 49
}
Write _+48

The first character goes 1, 2, 3, 4, 5, 6, 7, 8, 9, 0.
This uses a Python golfing trick that 0**_ is like +(not _). So if _ (which is set by the first line) is zero, the loop will execute once, while if it is nonzero the loop will execute zero times.

><>, 23 bytes, Teal pelican
"H"|;v+2i~?
  _  >l?!;n

For the remaining 9 numbers, replace the i with 0, 1, ..., 8 successively.
Try it online!

Hexagony, 15 bytes, 10 numbers, Sunny Pun
[!?>!@!1)\!?!!!
[!?>!@!2)\!?!!!
[!?>!@!3)\!?!!!
[!?>!@!4)\!?!!!
[!?>!@!5)\!?!!!
[!?>!@!6)\!?!!!
[!?>!@!7)\!?!!!
[!?>!@!8)\!?!!!
[!?>!@!9)\!?!!!
$!?>!@!9)\!?!!!

Try it online!
This might be the intended solution this time, but I'm not entirely sure. This one was definitely a lot more challenging in any case. :)

I laughed into tears because I changed the @ in my mind to a \\ as that looks less repetitive to the last post... Anyway I am impressed to have forced a change to the 1st byte in the code :)

Python 2, 110 bytes, 10 numbers CrazyPython
from hashlib import *
h=md5()
h.update('*F[`')
if h.hexdigest()=='88f4002e27b0902c7018359da9bc5b44':print(0+1)

TI-Basic, 13(?) bytes, 10 numbers, Timtech
DelVar A1→θ
BL>A
θ

The 1 goes up to 9, and then we change it to Xmax. I'm too good at remembering useless information I don't even want to know.

Nice try! Almost correct, but you cannot assume variables like Xmax will be set to certain values. http://tibasicdev.wikidot.com/graphscreen

@Timtech Yes I can. See for example http://codegolf.stackexchange.com/a/52967/30688

Alright then, whatever. I made the mistake of thinking you had to add characters... didn't realize substitutions xD

PHP, 38 bytes, 10 numbers, by Leo
Original code:
<?php__n_p___(_n=___(__=1___echo___?>

Cracks for 1-10:

<?php "n p   ( n=   (  =1"; echo +1?>
<?php "n p   ( n=   (  =1"; echo 1+1?>
<?php "n p   ( n=   (  =1"; echo 2+1?>
<?php "n p   ( n=   (  =1"; echo 3+1?>
<?php "n p   ( n=   (  =1"; echo 4+1?>
<?php "n p   ( n=   (  =1"; echo 5+1?>
<?php "n p   ( n=   (  =1"; echo 6+1?>
<?php "n p   ( n=   (  =1"; echo 7+1?>
<?php "n p   ( n=   (  =1"; echo 8+1?>
<?php "n p   ( n=   (  =1"; echo 9+1?>

Unfortunately, you left way too much space after the echo and it became possible to sneak a +1 in there.

ASMD, 10 bytes, by Oliver
Original:
1_**_**_*÷

Code that produces 1 - 10:
1t**t**t*÷
1t**t**t*÷{
1t**t**t*÷{{
...
1t**t**t*÷{{{{{{{{{

Did I miss something? I had to mess around with the interpreter to get it to work on my system, and this seems too easy.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Steganographic Squares
Steganographic Squares
Your job is to take in a string, and generate an NxN image that represents this string. You must also write the algorithm that takes in the image and turns it back into a string as well. The scoring will be will include the byte count of both algorithms:
"Encryption" Algorithm + "Decryption" Algorithm.
You should post each separately, with byte-counts for both the encryption and decryption algorithms displayed individually.

Example Algorithm
For instance, here's the "Programming Puzzles and Code Golf" using a simple ASCII based steganographic algorithm in the Blue channel:
#2e7250,#6ea972,#04eb6f,#0fc767,#74ab72,#ee6161
#b73b6d,#1aae6d,#f37169,#bda56e,#1fe367,#e99620
#706450,#0d3575,#146b7a,#4ea47a,#2a856c,#95d065
#3f2d73,#cef720,#bab661,#d1b86e,#f22564,#12b820
#0f3d43,#c86e6f,#1ee864,#a66565,#247c20,#c3bb47
#0e296f,#89d46c,#585b66,#c08f20,#455c20,#136f20

Actual Image (  )

You can see the blue channel simply holds the ascii values for this image:
50 =  80(P) 72 = 114(r) 6f = 111(o) 67 = 103(g) 72 = 114(r) 61 =  97(a)
6d = 109(m) 6d = 109(m) 69 = 105(i) 6e = 110(n) 67 = 103(g) 20 =  32( )
50 =  80(P) 75 = 117(u) 7a = 122(z) 7a = 122(z) 6c = 108(l) 65 = 101(e)
73 = 115(s) 20 =  32( ) 61 =  97(a) 6e = 110(n) 64 = 100(d) 20 =  32( )
43 =  67(C) 6f = 111(o) 64 = 100(d) 65 = 101(e) 20 =  32( ) 47 =  71(G)
6f = 111(o) 6c = 108(l) 66 = 102(f) 20 =  32( ) 20 =  32( ) 20 =  32( )

While the rest of the channels hold randomly generated values to "spice up" the variety of colors in the image. When pulling the message back out of the image, we can just simply ignore the other channel values, and pull the hex bit in the blue channel, reconstructing the string:
"Programming Puzzles and Code Golf"

Notice the spaces that were used to pad the string in the square are not included in the final decrypted output. While you must pad the string in the image, you may assume that the input string will not end with spaces.

Rules

You must encode 1 character per pixel, the channel chosen to encode the char is arbitrary.
The channels of the other RGB colors must be randomized, other than the one you're choosing to encode the string into; this means your final non-encoded channels would need to be between 0x0000-0xFFFF (randomly chosen).
Expressing the final result as a 2D array of RGB color values is fine 0x000000-0xFFFFFF, no need to use image creation unless you want to have fun with it or if it's less bytes. If you choose to output as hex strings, prefix the hex string with # E.G. #FFFFFF or #05AB1E. You may separate with tabs, commas, or anything else that would be horizontally sensible, but it must maintain the square pattern; in other words, you must use appropriate newline separation.
The output must be in a square, and the string must be padded with spaces at the end to accomodate this. This means that N≈SQRT(Input#Length()). If the input length is not a perfect square, you should round up on N and pad with spaces.
As stated previously, if you are padding with spaces in the image, you must not include the padded characters in the final "decrypted" output.
You can assume that:

The input string will not end with spaces.
The input string will only use printable ASCII characters.

This is code-golf, lowest byte count wins.

Just to clarify, solutions must encode/decode exactly one character per pixel?

@ETHproductions that sounds like a good follow-up challenge, but for the purpose of this competition, you pick an encoding channel and encode 1 character per pixel.

I'm probably not going to use this, but: is it OK to "overpad" the image with more spaces than necessary? And is it OK to assume that the image will have the same amount of overpadding as the encoder would generate?

@ais523 I cannot see how this type of approach would do anything but require more bytes to implement. I'm going to go with no though, as the challenge is too old to make large changes like that.

Right, I wasn't sure if it was allowed in the original question, rather than recommending a change. (I was thinking about packing the input into a rectangle, which has easier and thus possibly byte-shorter coordinate calculations than packing it into a square, then padding the rectangle out to a larger square.)

What is meant by the line Expressing the final result as a 2D array of RGB color values is fine? Can the output of the encoder be a 2D array or does it need to be formatted in a square?

@Emigna see the Jelly answer.

You should probably remove the text about 2D arrays being fine if it's not allowed. It only adds confusion (at least it did for me).

@Emigna it IS allowed, see the Jelly answer here: http://codegolf.stackexchange.com/a/102159/59376

Ah sorry, I misunderstood you. At a glance I didn't see the commas in the Jelly answer so I figured you meant the opposite.

05AB1E, 34 + 12 = 46 bytes
Uses red channel.
05AB1E uses CP-1252 encoding.
Encode:
DgDtî©n-Äð×JvyÇh`4F15Ý.Rh«}})'#ì®ä

D                                   # duplicate input
 gDtî©n-Ä                           # abs(len(input)-round_up(sqrt(len(input)))^2)
         ð×J                        # join that many spaces to end of input
            v                       # for each char in string
             yÇ                     # get ascii value
               h`                   # convert to base-16 number
                 4F                 # 4 times do:
                   15Ý.Rh           # push random base-16 number
                         «          # concatenate
                          }}        # end inner and outer loop
                            )       # wrap in list
                             '#ì    # prepend a "#" to each element in list
                                ®ä  # split in pieces round_up(sqrt(len(input))) long

Try it online!
Decode:
˜vy3£¦HçJ}ðÜ

˜               # deep flatten input to a list
 v              # for each color in the list
  y3£           # take the first 3 chars
     ¦          # remove the hash sign
      H         # convert from base-16 to base-10
       ç        # get the ascii char with that value
        J       # join to string
         }      # end loop
          ðÜ    # remove trailing spaces

Try it online!
Alternative padding method with equal byte-count
Dgð×J¹gtî©n£

I think you have to specifically join on newlines, according to the question? (Your answer will likely beat mine even if it's adapted to do that, though, because I only spent five bytes dealing with that part of the question, and you're ahead by more than that.)

@ais523: The rules states that 2D arrays were okay. Did I misunderstand that somehow?

"You may separate with tabs, commas, or anything else that would be horizontally sensible, but it must maintain the square pattern; in other words, you must use appropriate newline separation." strongly implies that it needs to be a string, as 2D arrays don't inherently contain newlines. In other words, I interpreted "array" as describing the shape of the output, not the data type of the output.

@ais523: I've asked the OP for clarification. As you say, it's not a big change to implement, but maybe you can save some bytes as well if formatting isn't needed.

@ais523 either way is acceptable.

@Emigna awarded, seeing as it was the lowest byte-count when I checked today.

C, 201 (Encoding) + 175 (Decoding) = 376 bytes
To Encode:
E(char*J){size_t L=ceil(sqrt(strlen(J)));int U;srand(time(NULL));for(int i=0;i<L;i++){for(int f=0;f<L;f++){printf("#%02X%02X%02X ",rand()%256,(U<strlen(J))?(int)J[U]:32,rand()%256);U+=1;}printf("\n");}}

Encodes each character of the input string in the green channel of the RGB spectrum while setting the two other channels as random hex values. Takes input through STDIN as a string and outputs to STDOUT a multiline string of hex color code in the shape of a square. Assuming you have Python 3 and ImageMagick installed, and the above file is compiled into a file named a.out in the current working directory (CWD), you can directly get the resulting image, named Output.png, to the CWD from the textual output using the following command:
./a.out "<Multiline Input>"|python3 -c "import sys,subprocess;Input=sys.stdin.read();print('# ImageMagick pixel enumeration: {0},{0},255,rgb\n'.format(len(Input.split('\n')[1].split()))+'\n'.join(['%d,%d:(%d,%d,%d)'%(g,i,int(j[1:][:2],16),int(j[1:][2:4],16),int(j[1:][4:6],16))for g,h in enumerate(Input.split('\n'))for i,j in enumerate(h.split())]))"|convert - -scale 1000% Output.png

Here is a sample output image created by the above commamd using Programming Puzzles and Code Golf as the input string:

To Decode:
D(int c,char**U){char T[c];for(int Y=1;Y<c;Y++){char G[2]={U[Y][3],U[Y][4]};T[Y-1]=(char)strtol(G,NULL,16);}int C=c-1;T[C]='\0';while(T[C]==' '){T[C]='\0';C-=1;}printf("%s\n",T);}

Takes input through STDIN a sequence of space-separated hex color code strings with each one enclosed in double quotes (") (char** argv in main) and also, when called in main, int argc for the integer input. Outputs to STDOUT a single/multi-line string representing the decoded message.
I will try to golf these more over time whenever and wherever I can.

Also, if you same both of the methods into the same file, you can use the following main method to put it all together with each function getting the correct inputs:
int main(int argc,char**argv){if(strcmp(argv[1],"E")==0){Encode(argv[2]);}else{Decode(argc,argv);}}

and using this, for encoding you must provide E as the first argument to call the encoding method followed by the single string argument, whereas for decoding, all you need to provide is the sequence of space-separated hex color code strings with each one enclosed in double-quotes (").

Finally, if you want, you can get the fully prepared, ready-to-use version here, although it is not golfed, but also does not output any warnings or errors upon compilation.

Python 2, 164 160 + 94 93 = 253 bytes
Saved 1+1 byte thanks to Wheat Wizard.
-5 bytes thanks to Kade
Encoder: string must be enclosed in quotes, e.g. "CodeGolf", output is a color ascii PPM image.
from random import*
s=input()
n=int((len(s)-1)**0.5)+1
s=s.ljust(n*n)
r=randint
print"P3 %d %d 255 "%(n,n)+''.join("%d "*3%(r(0,255),r(0,255),ord(c))for c in s)

Decoder: Takes input filename as command line argument
from sys import*
print''.join(chr(int(c))for c in open(argv[1]).read().split()[6::3]).strip()

Usage:
 python golf_stegansquare_enc.py > stega.ppm

 python golf_stegansquare_dec.py stega.ppm

Example:
Programming Puzzles and Code Golf
Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.

You can remove the space between the close paren and then for

@ETHproductions: sqrt(25-1) = sqrt(24) < 5 and > 4. int from this is 4 which is then +1ed, so 5

Oh, my bad, I didn't see the -1.

What's it output if you take your source code as input?

@mbomb007 As you wish

You can remove the space between print and ' in the decoder. I am also pretty sure you could do int((len(s)+1)**.5) to save some bytes.

I'm redacting the last sentence of my previous comment, however you can shorten the printing by changing ' '.join("%d %d %d" to ''.join(3*"%d " since I'm pretty sure a trailing space is OK.

Scala, 97 + 68 = 165 bytes
Encryption (97 bytes):
s=>s.map(_+((math.random*65535).toInt<<8)).iterator.grouped(math.sqrt(s.size)toInt)withPadding 32

Takes a String and retuns an Iterator of Sequences of Integers.
Decryption (68 bytes):
a=>" +$".r.replaceAllIn(a.flatten.map(h=>(h&0xFF)toChar)mkString,"")

Takes an Iterator of Sequences of Integers and returns a string.
Explanation:
s=>                         //define an anonymous function
  s.map(                      //map each char of the string
    _+(                         //to the ascii value plus
      (math.random*65535).toInt)  //a random integer between 0 and 65535
      <<8                         //shifted 8 bits to the left
    )
  )
  .iterator                     //create an iterator
  .grouped(                     //group them in groups of size...
    math.sqrt(s.size)toInt        //sqrt of the size of the input, rounded up
  )withPadding 32               //pad with spaces to make a square

.
a=>
  " +$"              //take this string
  .r                 //parse it as a regex
  .replaceAllIn(     //replace every occurence of the regex in...
    a.flatten          //a flattened
    .map(h=>           //each element mapped
      (h&0xFF)toChar)    //to the character of the lower 8 bits
    mkString,          //joined to a string
    ""               //with an empty string
  )

Perl, (103+1) + (36+2) = 142 bytes
Text to image encoder (run with -p for a 1-byte penalty; -p0 (for an additional byte of penalties) is necessary if you want to handle newlines in the input string):
$_.=$"while($a=(length)**.5)=~/\./;$_=unpack"H*";s/../sprintf"#%04x$&,",rand+4**8/eg;s/(.*?\K,){$a}/
/g

Image to text decoder (run with -p0 for a 2-byte penalty):
$\.=chr hex for/..\W/g;$\=~s/ *$//}{

This uses the #abcdef text-based image format, and encodes in the blue channel. Here's an example of a possible output given Programming Puzzles and Code Golf as the input:

#b4d250,#bccb72,#43f06f,#4d6767,#74ba72,#269461
#e4f26d,#f63d6d,#701c69,#bbf56e,#6ef967,#d78d20
#4e0d50,#9b2775,#afd37a,#12a47a,#63e46c,#0e9565
#4cad73,#e43420,#6da761,#5a306e,#8fba64,#58f720
#d52443,#b4446f,#fbaf64,#4a4365,#1a5020,#f3ea47
#354c6f,#52cb6c,#11a766,#4c380a,#553820,#b31120

Explanation of the encoder:
$_.=$"             # append a space ($") to the input ($_)
  while            # as long as the following condition holds:
(($a=length)**.5)  # the square root of the input length (save this in $a)
=~/\./;            # has no decimal points in its string represenation
$_=unpack"H*";     # convert the input from base-256 to hexadecimal
s/../              # replace two characters of the input
  sprintf          # with a string formed from the template
  "#%04x$&,",      # four hex digits, the two matched characters, and a comma
  rand+4**8        # those hex digits are a random number from 0 to 4**8 (= 65536)
/eg;               # and do this for every non-overlapping match
s/(.*?             # find the minimum number of characters needed to match
   \K,)            # replacing the part of the match after the last matched comma
  {$a}/            # a string containing $a commas
/gx                # with a newline, for every non-overlapping match

I was really happy this use of \K worked; it specifies where to replace, and placing it inside a loop, it seems that the occurrence on the last loop iteration is what counts. So s/(.*?\K,){$a}/\n/g will match a minimum-length string of the form anything comma anything comma … anything comma, that has $a commas, but the actual replaced part of the match will simply be the last comma. This has the effect of replacing every $ath comma with a newline, giving us the square shape for the image.
The big advantage of Perl for this challenge (other than the built-in character string-to-hexadecimal converter, which was incredibly convenient) is that it has a very short decoder (so short, in fact, that although Perl has a builtin for converting hexadecimal to a string, it was shorter not to use it). Here's how it works:
$\.=chr      # append to $\ the character code
  hex        # of the hexadecimal-string-to-number-translation
for/..\W/g;  # of each two characters that appear before a
             # non-alphanumeric character (not counting overlapping matches)
$\=~s/ *$//  # delete all spaces at the end of $\
}{           # in this context, this means "implicitly print $\,
             # prevent any other implicit printing"

The only instances of two characters immediately before a non-alphanumeric character are the blue channels (which we want to unpack), which appear just before commas and newlines; and the two characters that appear before each # other than the first. We don't want the latter category of matches, but they inevitably overlap the former category, and thus will be excluded by the overlapping matches check.

MySQL, 438 + 237 = 675 bytes
There is a trailing new line at the end of the output, but it does not show up after being decrypted.  The hex function (integer overload) would chop off leading 0's, so I had to pad it with a string 0.  I could save some bytes if I could declare both functions between the delimiters.
Encrypt
delimiter //create function a(i text)returns text begin declare r int;declare q,p text;while mod(length(i),sqrt(length(i)))<>0 do set i:=concat(i,' ');end while;set r:=1;set q:="";while r<=length(i) do set p:=",";if mod(r,sqrt(length(i)))=0 then set p:="\r\n";end if;set q:=concat(q,'#',right(concat(0,hex(floor(rand()*256))),2),right(concat(0,hex(floor(rand()*256))),2),hex(mid(i,r,1)),p);set r:=r+1;end while;return q;end//
delimiter ;

Decrypt
delimiter //create function b(i text)returns text begin declare x int;declare y text;set x:=0;set y:="";while instr(i,'#')>0 do set i:=substr(i,instr(i,'#')+5);set y:=concat(y,unhex(left(i,2)));end while;return trim(y);end//
delimiter ;

Usage:
select a('test')
select b('#7D1874,#FFB465')
select b(a('test'))

Jelly, 40 + 20 = 60 bytes in Jelly's codepage
Encoder (text → image):
”#;;ØHX¤¥4¡
»⁶x⁹²¤¤Ob⁴‘ịØHÇ€sj€”,Y
L½Ċç@

Try it online!
Decoder (image → text):
ḣ2ØHiÐ€’ḅ⁴Ọ
ṣ”#Ç€œr⁶

Try it online!
An example output the program could produce (it stores information in the red channel):
#504219,#720200,#6F38F1,#67055F,#7228C7,#61AC95
#6DD797,#6D20CB,#6962FA,#6E69B1,#67C41C,#209436
#50CB19,#75C9FC,#7A1B06,#7A695B,#6C5D5B,#6539A6
#735925,#20C80F,#612C38,#6EBF9E,#64C79E,#200915
#4337C5,#6F4704,#64FB5F,#65B2D1,#20E075,#47BC7C
#6F0C16,#6CD8EF,#66060B,#203C6C,#20D6E9,#20C0D7

In these larger challenges, Jelly's terseness starts to drop off a bit, needing several "structural" characters to resolve parsing ambiguities, but it's nonetheless still very terse. Here's how the encoder works:
Subroutine 1: convert digits to randomly padded hex string
”#;;ØHX¤¥4¡
”#;                     prepend #
    ØHX                 random hexadecimal digit
       ¤                parse ØH and X as a unit
   ;                    append
        ¥               parse ; and ØHX¤ as a unit
         4¡             repeat four times

Subroutine 2: convert string λ to square with size ρ
»⁶x⁹²¤¤Ob⁴‘ịØHÇ€sj€”,Y
 ⁶                      space
   ⁹²                   ρ squared
     ¤                  parse ⁹² as a unit
  x                     repeat string (i.e. ρ² spaces)
      ¤                 parse ⁶x⁹²¤ as a unit
»                       take maximum
Because space has the lowest value of any printable ASCII character,
this has the effect of padding λ to length ρ² with spaces.
       O                take codepoints of string
        b⁴              convert to base 16
           ịØH          use as indexes into a list of hexadecimal digits
          ‘             0-indexed (Jelly uses 1-indexing by default)
              Ç€        run subroutine 1 on each element
                s       split into groups of size ρ
                  €     inside each group
                 j ”,   join on commas
                     Y  join on newlines

Main program: basically just calculates ρ and lets subroutine 2 do the work
L½Ċç@
L                       length of input
 ½                      square rooted
  Ċ                     rounded up to the next highest integer
   ç@                   call subroutine 2 with the original input and the above

And here's how the decoder works:
Subroutine: convert hexadecimal color string (without #) to character
ḣ2ØHiÐ€’ḅ⁴Ọ
ḣ2                      take first two characters
  ØHi                   find indexes in a string of hexadecimal digits
     Ð€                 for each of those characters
       ’                0-indexed (Jelly uses 1-indexing by default)
        ḅ⁴              convert from base 16
          Ọ             convert integer to character

Main program:
ṣ”#Ç€œr⁶
ṣ”#                     split on # signs
   Ç€                   run the subroutine for each element
     œr⁶                remove spaces from the right

Mathematica, 111 + 65 = 176 bytes
Encoder
Join[255~RandomInteger~{n=⌈Sqrt@Length@#⌉,n,2},ArrayReshape[#,{n,n,1},32],3]~Image~"Byte"&@*ToCharacterCode

Decoder
StringTrim[""<>FromCharacterCode@ImageData[#,"Byte"][[;;,;;,3]]]&

Processing, 220 209 194 + 171 167 151 = 391 380 376 361 345 bytes
Update:
Removed useless noStroke() and made both for-loops one-statementers.
Removed useless image(p,0,0);, gave the decryptor the filename as the parameter
Encryption Algorithm
void g(String h){int s=ceil(sqrt(h.length()));for(int y=0,x;y<s;y++)for(x=0;x<s;rect(x,y,1,1),x++)stroke(h.length()>y*s+x?h.charAt(y*s+x):32,random(255),random(255));get(0,0,s,s).save("t.png");}

Calling the function: g("Programming Puzzles and Code Golf");
This is a function that takes in a String, and creates the output, before saving it as t.png. It uses the red value to store the hidden text.
Decryption Algorithm
void u(String f){PImage p=loadImage(f);f="";for(int j=0,i;j<p.height;j++)for(i=0;i<p.width;i++)f+=(char)red(p.get(i,j));print(f.replaceAll(" +$",""));}

Call function by: u(file_name);
This is also a function that searches for the image specified by the parameter, and then outputs the hidden string (since it is shorter than returning a string).
Expanded code
(Encryption Algorithm)
void g(String h) {
  int s=ceil(sqrt(h.length()));
  for(int y=0,x;y<s;y++)
    for(x=0;x<s;rect(x,y,1,1),x++)
      stroke(h.length()>y*s+x?h.charAt(y*s+x):32,random(255),random(255));
  get(0,0,s,s).save("t.png");
}

The string is passed when the function is called. The first line of the function calculates the side length of the square by taking the ceil of its square root. Then we enter a for-loop, where we set the stroke (the colour of the edge) to have the ASCII value of the character as red, and random values for blue and green. After we do this, we create a rect (rectangle) with width = 1 and height = 1, ie a pixel (for some weird reason, I can't use point properly). In the last line, the resulting image is then saved as t.png.
(Decryption Algorithm)
void u(String f) {
  PImage p=loadImage(f);
  f="";
  for(int j=0,i;j<p.height;j++)
    for(i=0;i<p.width;i++)
      f+=(char)red(p.get(i,j));
  print(f.replaceAll(" +$",""));
}

This function has the name of the file as the parameter (as a string). Then the image in the file is stored in a variable to be used later. After we are done with that, we set the string to "" instead of creating a new string just to hold the hidden string. Then we iterate through the image via two nested for-loops, and we add on to the string the character value of the red value of the pixel. Finally, we print the resulting string after removing leading spaces from it (using a regex). The reason we print the hidden text instead of returning it is because this way it is shorter and we save bytes.

Encrypted challenge raw text:

C#, 312 + 142 = 454 bytes
Encoding:
using System;I=>{var r=new Random();int i=I.Length;int N=(int)Math.Floor(Math.Sqrt(i))+1,S=N*N;while(i++<S){I+=' ';}var R="";for(i=0;i<S;){R+=i%N<1&i>0?"\n":i<1?"":" ";R+="#"+r.Next(256).ToString("X").PadLeft(2,'0')+r.Next(256).ToString("X").PadLeft(2,'0')+((int)I[i++]).ToString("X").PadLeft(2,'0');}return R;};

Decoding:
using System;I=>{var s=I.Replace('\n',' ').Split(' ');var R="";foreach(var t in s)R+=(char)System.Convert.ToInt32(t[5]+""+t[6],16);return R.TrimEnd(' ');};

Full program:
using System;
class Steganographic
{
    static void Main()
    {
        Func<string, string> E = null;
        Func<string, string> D = null;

        E=I=>
        {
            var r=new Random();
            int i=I.Length;
            int N=(int)Math.Floor(Math.Sqrt(i))+1,S=N*N;
            while(i++<S){I+=' ';}
            var R="";
            for(i=0;i<S;)
            {
                R+=i%N<1&i>0?"\n":i<1?"":" ";
                R+="#"+r.Next(256).ToString("X").PadLeft(2,'0')+r.Next(256).ToString("X").PadLeft(2,'0')+((int)I[i++]).ToString("X").PadLeft(2,'0');
            }
            return R;
        };

        D=I=>
        {
            var s=I.Replace('\n',' ').Split(' ');
            var R="";
            foreach(var t in s)
                R+=(char)Convert.ToInt32(t[5]+""+t[6],16);
            return R.TrimEnd(' ');
        };

        string encoded = E("Programming Puzzles and Code Golf");
        Console.WriteLine(encoded);
        Console.WriteLine(D(encoded));

        encoded = E("Hello, World!");
        Console.WriteLine(encoded);
        Console.WriteLine(D(encoded));

        Console.Read(); // For Visual Studio
    }
}

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Blueprint a sestina
A sestina is a format of poem that follows an interesting pattern that we can generate. It has six stanzas of six lines each, where the last words of each line in the first stanza make up the line endings in each successive stanza, rotated in a set pattern. (There's also a three-line stanza at the end, but we won't worry about that.) Take a look at the first three stanzas of Elizabeth Bishop's creatively named Sestina:

September rain falls on the house.
  In the failing light, the old grandmother
  sits in the kitchen with the child
  beside the Little Marvel Stove,
  reading the jokes from the almanac,
  laughing and talking to hide her tears.
She thinks that her equinoctial tears
  and the rain that beats on the roof of the house
  were both foretold by the almanac,
  but only known to a grandmother.
  The iron kettle sings on the stove.
  She cuts some bread and says to the child,
It's time for tea now; but the child
  is watching the teakettle's
  small hard tears
  dance like mad on the hot black stove,
  the way the rain must dance on the house.
  Tidying up, the old grandmother
  hangs up the clever almanac
...

Note how each line ends with one of the six words "house," "grandmother," "child," "stove," "almanac," or "tears." Not only that, but the words are ordered in the pattern 6–1—5–2—4–3, relative to the previous stanza. It ends up looking like a spiral:

We're still a few years away from programmatically generating a full sestina, but we can create a template featuring the end words of each stanza in proper order. Write a program or function that, given the six line ending words, outputs the blueprint for a sestina, following these rules. Here is the expected result for the input house grandmother child stove almanac tears:
house
grandmother
child
stove
almanac
tears

tears
house
almanac
grandmother
stove
child

child
tears
stove
house
grandmother
almanac

almanac
child
grandmother
tears
house
stove

stove
almanac
house
child
tears
grandmother

grandmother
stove
tears
almanac
child
house

The first stanza is the words in original order, the second stanza is in the order 6-1-5-2-4-3 from the first. The third stanza is that order relative to the second, and so on, all the way to stanza 6.
Assume that the input words will always be only letters, uppercase or lowercase. You can take them as an array of strings or a single string delimited by a non-letter character (space, newline, etc.). In the output, lines are separated by newlines (0x0A), and stanzas separated by two newlines. A trailing newline is acceptable.
This is code-golf, so shortest code in bytes wins. That being said, it may be shorter to compress the whole poem's structure, but I'd like to see some solutions that base each stanza on the previous.

Trailing newlines accepted?

Also, can the separator line contain a space?

@LuisMendo Sure, both are okay.

Can the output be an ordered list of ordered lists of strings?

@GregMartin I'm not sure I understand what you mean. It should be a string with no extraneous formatting, though.

+1 for sestinas, but I'm not sure this merits the natural-language tag. The algorithm is the same even if the input is six strings of gibberish.

I read "siesta" and, after reading what is actually was, am now less confident in my ability to win.

Jelly, 15 14 bytes
620œ?$ÐĿY€j⁷Ḥ¤

TryItOnline!
How?
Yey, a use of one of my additions to Jelly! (œ?)
620œ?$ÐĿY€j⁷Ḥ¤ - Main link: list of words L
      ÐĿ       - loop until no longer unique, collecting intermediate results
     $         -     last two links as a monad
   œ?          -         permutation of right argument (initially L) at index
620            -         620
        Y€     - join with line feeds for €each (the words of each stanza)
          j    - join (the stanzas) with
             ¤ - nilad followed by link(s) as a nilad
           ⁷   -     a line feed
            Ḥ  -     double (two line feeds)

Python, 72 64 bytes
i,n=input(),'\n';exec"print n.join(i)+n;i=map(i.pop,[-1,0]*3);"*6

Takes input through STDIN as a comma separated array of 6 strings and outputs to STDOUT in the format described in the post with an additional trailing newline.
Try It Online! (Ideone)
Also, I am not sure if this is okay to do, but here is a shorter answer in the form of an anonymous lambda function at 59 bytes that takes in input in the same format as the above answer, and outputs the program needed to generate the correct output:
lambda i,n='\n':"print n.join(i)+n;i=map(i.pop,[-1,0]*3);"*6

Therefore it must be called in the format exec(<Function Name>(<Array>)). Again, I am not sure if this is okay to do, so I am adding this as an extra, separate, non-competing answer until someone (maybe even OP) can hopefully clarify if this is okay or not, which I would really appreciate.

I like the pop trick!

MATL, 18 17 bytes
0ch5:"t[6l5H4I7])

Input is a cell array of strings, in the format
{'house' 'grandmother' 'child' 'stove' 'almanac' 'tears'}

Try it online!
Explanation
0c          % Push string with a single space, to be used as separator
h           % Input array of 6 strings implicitly and append the above string
5:"         % Repeat 5 times
  t         %   Duplicate the array of strings (previous stanza plus separator)
  [6l5H4I7] %   Push array [6 1 5 2 4 3 7]. The 7th string is the separator, and stays
            %   at the end. The other strings are shuffled as required
  )         %   Index into the array of strings
            % End implicitly
            % Display implicitly

Mathematica, 59 bytes
r=Riffle;""<>Flatten@r[NestList[RotateRight,#,5],""]~r~"\n"&

The core of this unnamed function is NestList[RotateRight,#,5], which takes an input list of length 6 and creates a list of 6 lists, each rotated in the sestina way. Indeed, if a list of lists-of-strings is acceptable output, then NestList[RotateRight,#,5]& does the job in 26 bytes.
Then, r[...,""] inserts an empty string between each of the 6 lists; Flatten turns the whole thing into a single list of strings; ~r~"\n" then inserts a newline between each of those strings; and ""<> concatenates the whole thing into a single string. Thus the other 33 bytes are just to convert the structured output into a single string.

Batch, 99 bytes
@for %%w in (%*)do @if not .%%w==.%7 echo %%w
@echo(
@if not .%7==...... %0 %6 %1 %5 %2 %4 %3 .%7

Explanation: Takes input as command-line parameters. The %0 causes it to loop around, accumulating .s in the originally empty 7th parameter. The extra . is because if doesn't work on empty strings.

Ruby, 51 bytes
->z{z.map{z[1],z[3],z[5],z[4],z[2],z[0]=z+[""]}*$/}

Instead of iterating over the numbers 0..5 as below, we repeat 6 times by iterating over the elements of z. In normal usage such as  (0..5).map{|i|puts i} the code {} reads the elements iterated over. In this case the permutations done by the code inside the {} do not read the elements iterated over, so we can iterate over the elements of z without this interfering with the permutations.
Ruby, 56 bytes
Takes a 6 element array as a parameter
->z{(0..5).map{z[1],z[3],z[5],z[4],z[2],z[0]=z+[""]}*$/}

alternate version taking 6 parameters
->a,b,c,d,e,f{(0..5).map{b,d,f,e,c,a=a,b,c,d,e,f,""}*$/}

With each iteration of map we permute z. The original version plus a "" to represent a break between stanzas becomes the output of the map (this seventh array element is not needed by the assignment so is ignored). *$/ converts the arrays to a string, joining everything together with newlines.

Racket 115 bytes
(let p((o(list l))(m 0))(if(> n m)(p(cons(map(λ(x)(list-ref(list-ref o 0)x))'(5 0 4 1 3 2))o)(+ 1 m))(reverse o)))

Ungolfed:
(define(f l n)
 (let loop ((ol (list l))
             (m 0))
    (if (> n m)
        (loop
         (cons (map
                (λ (x) (list-ref (list-ref ol 0) x))
                '(5 0 4 1 3 2))
               ol)
         (add1 m))
        (reverse ol))))

Testing:
(f (list "house" "grandmother" "child" "stove" "almanac" "tears") 6)

Output:
'(("house" "grandmother" "child" "stove" "almanac" "tears")
  ("tears" "house" "almanac" "grandmother" "stove" "child")
  ("child" "tears" "stove" "house" "grandmother" "almanac")
  ("almanac" "child" "grandmother" "tears" "house" "stove")
  ("stove" "almanac" "house" "child" "tears" "grandmother")
  ("grandmother" "stove" "tears" "almanac" "child" "house")
  ("house" "grandmother" "child" "stove" "almanac" "tears"))


text:
Why don't you grow up?
Why don't you grow up?
In the past week a meme involving the young actor Aaron Bailey became trending in most Brazilian social networks. Entitled "why don't you grow up" it consists in repeating a sentence replacing its vowels with is (it's a bit more complicated than that, I'll explain below). As I want to be a cool guy I decided to write a program that mimimifies a given string.

Challenge
The challenge consists of mimimifying a string, following the rules:

ão and õe should be replaced with im.
ca, ka, que, ke, qui, ki, co ,ko, cu, and ku should be replaced with ki.
ça, ce, çe, ci, çi, ço, and çu should be replaced with ci.
ga, gue, gui, go, and gu should be replaced with gui.
ja, ge, je, gi, ji, jo, and ju should be replaced with ji
You can assume that qua, quo, quu, gua, guo, and guu, will never appear, only a and o can have tildes and if they do they'll be followed by o and e, repsectively (ão, õe).
The only time us are allowed in output strings is gui, besides that case all other vowels present should be is.
In all other circumstances all vowels must be replaced with is.
Other than tilde all other accents may be ignored.
Two or more is in a row are not allowed, you should replace them with only one (Piauiense -> Pinsi)

Examples
Input
Por que você só fala assim?

Output
pir ki vici si fili issim?

Input
Que horas são?

Output
ki hiris sim?

Input
Óculos sem lente pode ser armação

Output
ikilis sim linti pidi sir irmicim

Input
Ganha o código com menos bytes

Output
guinhi i kidigui kim minis bytis

Rules

The vowels are a, e, i, o, and u.
You can see the full list of possible accents here.
code-golf: the shortest code in bytes wins. Check meta if counting bytes is awkward in your language.
Standard loopholes are forbidden
Your output must be consistent in case: all upper/all lower.
You may assume the input to be in whichever encoding you want but if you do you must specify it.

Happy golfing!/Hippy guilfing!

(This phenomenon sounds similar to Ermahgerd in English.)

What is the list of accented characters?

@Mego why? By ignored I meant there presence is irrelevant (ê == e, ó == o)

Retina, 150 bytes
[ÀÁÂàáâ]
a
[ÉÊéê]
e
Í|í
i
[ÓÔóô]
o
[ÚÜúü]
u
T`L`l
ão|õe
im
[ck][aou]|qu[ei]|ke
ki
ç[aeiou]|ce
ci
g[aou]|gue
gui
j[aeou]|g[ei]
ji
(gu)i|[aeou]
$1i
ii
i

Try it online!
This is my first Retina program, so there's probably a lot of improvements to make. Suggestions are welcome.
Thanks to Martin for correcting some mistakes and for some golfing suggestions.
Explanation
I'm going to break up the explanation into 3 sections, to make it easier on me.
Section 1: Preprocessing
[ÀÁÂàáâ]
a
[ÉÊéê]
e
Í|í
i
[ÓÔóô]
o
[ÚÜúü]
u
T`L`l

The first 5 rules replace any accented vowel with the corresponding unaccented version. It's shorter to list out the matches in character classes (or, in the third case, as two options) than to use the culture-invariance and case-insentivity options each time. The last rule converts all ASCII letters to lowercase.
Section 2: Mimimification
ão|õe
im
[ck][aou]|qu[ei]|ke
ki
ç[aeiou]|ce
ci
g[aou]|gue
gui
j[aeou]|g[ei]
ji

These rules simply apply the substitutions specified.
Section 3: Cleanup
(gu)i|[aeou]
$1i
i+
i

The first rule matches any vowel except for the u in gui, and replaces them with is. The second rule removes repeated is.

What better language is there than one that is based on regex  :)

JavaScript, 396 392 389 bytes (383 379 376 characters)
Too many replaces, too much regex, ...
f=s=>s.toLowerCase().replace(/ão|õe/g,"im").replace(/[àâá]/g,"a").replace(/é|ê/g,"e").replace(/í/g,"i").replace(/ó|ô/g,"o").replace(/ú|ü/g,"u").replace(/(k[aeou])|(c[aou])|que|qui/g,"ki").replace(/(ç[aeiou])|ce/g,"ci").replace(/(g[aou])|gue/g,"gui").replace(/(j[aeou])|ge/g,"ji").split("gui").map(function(a){return a.replace(/[aeou]/g,"i")}).join("gui").replace(/i{2,}/g,"i")

I have used this link for a list of Brazilian accented letters so that I know for which letters I have to remove the accent.
Explanation
s.toLowerCase()

First, everything is converted to lowercase.
.replace(/ão|õe/g,"im")

Then I'm am implementing this rule.
.replace(/[àâá]/g,"a").replace(/é|ê/g,"e").replace(/í/g,"i").replace(/ó|ô/g,"o").replace(/ú|ü/g,"u")

Then the accents are removed using regex.
.replace(/(k[aeou])|(c[aou])|que|qui/g,"ki").replace(/(ç[aeiou])|ce/g,"ci").replace(/(g[aou])|gue/g,"gui").replace(/(j[aeou])|ge/g,"ji").split("gui")

After that, the the string is being bombarded by regular expressions to "memify" it.
.split("gui").map(function(a){return a.replace(/[aeou]/g,"i")}).join("gui")

Now all the vowels, except those in gui (that is why I used split) are being converted to i. After that, I rejoin the Array using gui as the delimiter.
.replace(/i{2,}/g,"i")

Finally, I am replacing 2 or more is with just 1 of them.
Snack Snippet!

f=s=>s.toLowerCase().replace(/ão|õe/g,"im").replace(/[àâá]/g,"a").replace(/é|ê/g,"e").replace(/í/g,"i").replace(/ó|ô/g,"o").replace(/ú|ü/g,"u").replace(/(k[aeou])|(c[aou])|que|qui/g,"ki").replace(/(ç[aeiou])|ce/g,"ci").replace(/(g[aou])|gue/g,"gui").replace(/(j[aeou])|ge/g,"ji").split("gui").map(function(a){return a.replace(/[aeou]/g,"i")}).join("gui").replace(/i{2,}/g,"i")

console.log(f("Por que você só fala assim?"))
console.log(f("Que horas são?"))                                                                                //They call me the professional Brazilian-meme-maker
console.log(f("Óculos sem lente pode ser armação"))                                                                                //dank memes, dank memes everywhere
console.log(f("Ganha o código com menos bytes"))

Golfing suggestions are welcome