答:
JavaScript, 12 bytes, 10 numbers, Hedi

Original code:

```<code>alert(+[+1])
</code>```

2 through 10:

```<code>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])
</code>```

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

Title: Code ladder, Robbers

Body:
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...


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

```<code>#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
</code>```

Actual Image (  )

You can see the blue channel simply holds the ascii values for this image:

```<code>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( )
</code>```

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:

```<code>"Programming Puzzles and Code Golf"
</code>```

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.

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

```<code>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 ;
</code>```

Decrypt

```<code>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 ;
</code>```

Usage:

```<code>select a('test')
select b('#7D1874,#FFB465')
select b(a('test'))
</code>```

ContentLicense: CC BY-SA 3.0

Title: Steganographic Squares

Body:
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'))


问:
Write a continuous quine (quine-variant)

Let's define a 2-quine as a program that prints its source code two times. For example, if the program ABC printed ABCABC, it would be a 2-quine.

Let's define a 3-quine as a program that prints its source code three times. For example, if the program ABC printed ABCABCABC, it would be a 3-quine.

Let's define a n-quine as a program that prints its source code n times.

Your task is to write a 2-quine, that prints a 3-quine, that prints a 4-quine, that prints a 5-quine, etc...

For example, here is an example of a valid submission (which is fictional of course):

```<code>AB
</code>```

which prints

```<code>ABAB
</code>```

which prints

```<code>ABABABABABAB
</code>```

which prints

```<code>ABABABABABABABABABABABABABABABABABABABABABABABAB
</code>```

etc.

Remember, this is code-golf, so the program with the fewest bytes wins.

答:
Ruby, 154 bytes

```
s=DATA.read.lines;s+=s[0,2];n=s.size/4;k=1;n/=k+=1while n>0;puts s*k
__END__
s=DATA.read.lines;s+=s[0,2];n=s.size/4;k=1;n/=k+=1while n>0;puts s*k
__END__

```

The trailing newline matters.

This program first duplicates itself; the output triplicates itself; that output quadruplicates itself, etc.

Thus the n-th program is a repetition of these 4 lines, n! times.

s=DATA.read.lines;s+=s[0,2]; gets us the current source code as an array of lines. We take its length, divide it by 4, compute the inverse factorial, add one, then print s that many times.

Body:
Ruby, 154 bytes

s=DATA.read.lines;s+=s[0,2];n=s.size/4;k=1;n/=k+=1while n>0;puts s*k
__END__
s=DATA.read.lines;s+=s[0,2];n=s.size/4;k=1;n/=k+=1while n>0;puts s*k
__END__

The trailing newline matters.

This program first duplicates itself; the output triplicates itself; that output quadruplicates itself, etc.

Thus the n-th program is a repetition of these 4 lines, n! times.

s=DATA.read.lines;s+=s[0,2]; gets us the current source code as an array of lines. We take its length, divide it by 4, compute the inverse factorial, add one, then print s that many times.


问:
GO OUT AND VOTE
Today is November 8th, 2016, Election Day in the United States of America.

If you are a U.S. citizen eligible to vote, then go out and vote if you haven't already before answering this challenge. Do not discuss who you voted for. It only matters that you voted.

If you are not a U.S. citizen or not eligible to vote, then, before answering this challenge, do the U.S. a favor by telling anyone you know who is an eligible citizen to go out and vote if they haven't already.

Challenge

Write a program that indicates that you voted, like a digital "I Voted" sticker.

It should take no input and must output in a reasonable way the phrase I Voted where the I, o, and e are red (#FF0000) and the V, t, and d are blue (#0000FF). The background must be white (#FFFFFF).

For example:

These colors are of course representative of the American flag (though not the official colors). Red comes first simply because it comes first in the common idiom "red white and blue".

To be valid, an answer must:

Use the colors specified in the arrangement specified.

Use a single legible font and font size. The example uses 72pt Times New Roman bold but any common font above 6pt is probably fine.

Have just the phrase I Voted on a single line, capitalized correctly, with a clear space between the two words. It shouldn't look like IVoted.

Not indicate who the answerer voted for or supports for president or any down-ballot races. Let's not start any internet debates. This is about celebrating voting, not candidates.

Any reasonable way of displaying or producing the output is valid, such as:

Drawing the text to an image that is then displayed, saved, or output raw.

Writing the text to a console using color formatting. In this case you may approximate pure red and blue if necessary, and it's ok if only the area directly behind the text can be made white.

Displaying the text on a WPF/Windows form.

Outputting an HTML/RTF/PDF file with the text.

Please post an image of your output.

The shortest answer in bytes wins.

答:
Befunge, 47 bytes

```<code>41+:+"detoV I":v:,,,\<
93"[47;3m"g0%2:_@>,,,^#*
</code>```

Try it online  - you'll need to Compile then Execute

Title: GO OUT AND VOTE

Body:
Befunge, 47 bytes

41+:+"detoV I":v:,,,\<
93"[47;3m"g0%2:_@>,,,^#*

Try it online  - you'll need to Compile then Execute


答:
MySQL, <s>196</s> <s>123</s> <s>118</s> 95 bytes

First wall was backwards, removed procedure.

```<code>set @x:=repeat('_|__',99);select left(repeat(concat(left(@x,70),'\n',mid(@x,3,70),'\n'),9),709)
</code>```

Title: Build me a brick wall!

Body:
Challenge

I need help building a brick wall! Throw together some code for me
 using no input and produce the following output wall shown below:

```<code>_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
</code>```

Now, this wall is exactly 10 characters high and 70 characters
 wide.

As stated above, no inputs, only code. Least amount of bytes, we have
 to efficiently build this brick wall. Obviously, this program has to
 function to get the wall built..? or it obviously won't build itself!
 Good luck!

Winner

The winner goes to Marinus using the APL language, requiring a whole 12 bytes!
https://codegolf.stackexchange.com/a/99028/61857

Thank you everyone for participating!

Body:
MySQL, <s>196</s> <s>123</s> <s>118</s> 95 bytes

First wall was backwards, removed procedure.

set @x:=repeat('_|__',99);select left(repeat(concat(left(@x,70),'\n',mid(@x,3,70),'\n'),9),709)


问:
Code ladder, Cops

Note: This challenge is finished. Submissions are still welcome but can not win.

This is the cops' thread. The robbers' thread goes here.

Write a code that outputs the integer 1. If you add, remove or substitute a single character (of your choosing), the code should output the integer 2. Change one more character (the same or another), and the code should output 3. Continue like this as far as you can, but maximum up to 10. Default output formats such as ans = 1 are accepted. You can ignore output to STDERR (or equivalent).

You must reveal the language, byte count of your initial code, the number of integers it works for, as well as an optional number of characters of the initial code. Note: You don't have to reveal any characters, but remember that revealing characters might make it harder for the robbers as they must use the same character in the same position. You can choose which character you use to denote unrevealed characters (for instance underscore), but make sure to specify this.

Cops can provide the uncracked code after one week and call the submission "SAFE". The winning submission will be the shortest uncracked submission that produces the number 10. If no uncracked submissions are able to print 10, the shortest code that produces 9 will win, and so on. Note that the robbers don't have to make the same changes as you do, and they don't have to reproduce the exact code (unless you reveal all characters). They must only reproduce the output.

Submissions posted later than November 24th are welcome but not eligible for the win (because there will likely be fewer robbers around).

Example post:

The following post is a submission in the language MyLang, it is 9 bytes long, and it works for numbers 1 - 8.

MyLang, 9 bytes, 8 numbers

This submission works for 1 - 8. Unrevealed characters are indicated with an underscore: _.

```<code>abc____i
</code>```

Leaderboard

Disclaimer: The leaderboard is not tested and uncracked submissions might not appear in the list.

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea">

Uncracked submissions

 Language	 Score	 User

Sort by: score creation

Safe submissions

 Language	 Score	 User

```

答:
Octave, 26 bytes, 10 numbers. Cracked

```<code>__a__repmat(_+one___1+__))
</code>```

_ is a hidden char.

New variation...

The intended solution was:

```<code>>> eval(repmat('+ones',1+''))
ans =  1

>> eval(repmat('+ones',1+2'))
ans =  3

>> eval(repmat('+ones',1+9'))
ans =  10
</code>```

Title: Code ladder, Cops

Body:
Octave, 26 bytes, 10 numbers. Cracked

__a__repmat(_+one___1+__))

_ is a hidden char.

New variation...

The intended solution was:

>> eval(repmat('+ones',1+''))
ans =  1

>> eval(repmat('+ones',1+2'))
ans =  3

>> eval(repmat('+ones',1+9'))
ans =  10


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

```<code>abc1efghi
</code>```

Code that produces 1 - 8:

```<code>1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi
</code>```

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

答:
Octave, 19 bytes, 10 numbers, by flawr

Probably not the intended solution, but hey.

```<code>'psca'(1 )+'1'-160'
'qsca'(1 )+'1'-160'
...
'ysca'(1 )+'1'-160'
</code>```

Title: Code ladder, Robbers

Body:
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'


问:
Add weight to one side of a see-saw to balance it

Balancing Act

A see-saw (supposedly from the French 'ci-ça', meaning 'this-that') forms a third of the holy trinity of playground equipment, along with the similarly ubiquitous slide and swing. A see-saw is in perfect balance if, and only if, the sum of the moments on each side are equivalent. A see-saw can therefore be balanced by adding a specific quantity of weight to the side with the lower moment sum; achieving this is your goal for this challenge.

Challenge

Your challenge is to take a depiction of a see-saw as input and output it again, with weight added to one end of the see-saw to balance it.

Input

Your program must take, in any reasonable format, an ASCII see-saw such as the following:

```<code>100             100
-------------------
         ^
</code>```

The first line contains two numbers, each representing weights on the see-saw. Exactly one weight is present on each side, each acting on the very end of its side of the plank. Weights are guaranteed to be integers, and always align with their corresponding end of the plank. These numbers will never overlap the fulcrum (^).

The second line represents the 'plank' of the see-saw. Each dash (-) represents an equal length to each other dash, with the sole exception of the dash directly over the fulcrum (^), which has no length.

The third line represents the fulcrum of the see-saw. This fulcrum is marked by the only character that is not a space on this line, a circumflex ('^'). The fulcrum can be positioned anywhere along the length of the plank in a valid input so long as enough space is left so that the numbers representing weights do not overlap the fulcrum in either the input or the output.

The input is guaranteed to have three lines, and have no white-space prior to or after the characters that constitute the see-saw (excepting, of course, the third line, which requires it).

Output

For output, the same see-saw depiction should be printed to stdout, but with one (and only one) of the weights replaced with a larger weight, so as to balance the see-saw. Inputs are guaranteed to make this possible using integers alone. Therefore, weights must be shown without decimal points or any other similar notations. If your language does not use stdout you should go by community / meta consensus on output. Trailing newlines are fine but any other changes to the depiction format are probably not OK.

Exemplification

Test Inputs and Corresponding Outputs

Input 1

```<code>12                22
--------------------
             ^
</code>```

Output 1

```<code>12                26
--------------------
             ^
</code>```

Input 2

```<code>42       42
-----------
     ^
</code>```

Output 2

```<code>42       42
-----------
     ^
</code>```

Input 3

```<code>3             16
----------------
        ^
</code>```

Output 3

```<code>14            16
----------------
        ^
</code>```

Input 4

```<code>1                56
-------------------
    ^
</code>```

Output 4

```<code>196              56
-------------------
    ^
</code>```

Reference Implementation - Python 3

```<code># Takes a list of strings as input
def balance_seesaw(lines):
    weights = [int(w.strip()) for w in lines[0].split()]

    length  = len(lines[1])
    pivot   = lines[2].find("^")
    left_length    = pivot
    right_length   = length - 1 - pivot

    left_torque  = weights[0] * left_length
    right_torque = weights[1] * right_length

    if left_torque > right_torque:
        weights[1] = left_torque // right_length
    elif right_torque > left_torque:
        weights[0] = right_torque // left_length

    weights = [str(w) for w in weights]

    string_gap = " " * (length - sum(len(w) for w in weights))
    lines[0] = weights[0] + string_gap + weights[1]

    print("\n".join(lines))

balance_seesaw(["1                56",
                "-------------------",
                "    ^              "])
</code>```

Rules

This is code-golf, so the shortest code wins counted in bytes. Check meta if counting bytes is awkward in your language.

Standard rules/loopholes apply.

Input must be taken in a reasonable format. A non-exhaustive list of appropriate formats are given as follows:

A single string with lines separated by newline characters

A list of strings, each string represented a line

A 2D Array or Matrix of characters

Related Challenges

Balance a set of weights on a see-saw - Proposed Aug 2015 by samgak

答:
Python 2, <s>184</s> 183 bytes

Definitely golfable

```<code>i=raw_input
j=int
w=map(j,i().split())
W=len(i())
I=i().find('^')
R=W-I-1
a=[w[1]*R/I,w[0]*I/R]
h=a[1]>w[1]
w[h]=j(a[h])
k='\n'
print(' '*(W-len(str(w))+4)).join(map(str,w))+k+'-'*W+k+' '*I+'^'
</code>```

Pretty straightforward. Just take the adjusted weights for adjusting both sides, see which one's larger than the original, and change that one, and output.

EDIT Switched multiplication and division because integer division is evile (thanks to @JonathanAllan for noticing this)

EDIT -1 byte Changed i().index('^') to i().find('^') (thanks to @JonathanAllan [again!])

Body:
Python 2, <s>184</s> 183 bytes

Definitely golfable

i=raw_input
j=int
w=map(j,i().split())
W=len(i())
I=i().find('^')
R=W-I-1
a=[w[1]*R/I,w[0]*I/R]
h=a[1]>w[1]
w[h]=j(a[h])
k='\n'
print(' '*(W-len(str(w))+4)).join(map(str,w))+k+'-'*W+k+' '*I+'^'

Pretty straightforward. Just take the adjusted weights for adjusting both sides, see which one's larger than the original, and change that one, and output.

EDIT Switched multiplication and division because integer division is evile (thanks to @JonathanAllan for noticing this)

EDIT -1 byte Changed i().index('^') to i().find('^') (thanks to @JonathanAllan [again!])


Title: Code ladder, Robbers

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

```<code>abc1efghi
</code>```

Code that produces 1 - 8:

```<code>1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi
</code>```

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

Body:
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])


答:
Acc!!, 46 bytes, 10 numbers, cracked

```<code>?
Count i while ?????????????????
}
Write ????
</code>```

Works for 1 to 10, with ? as the hidden character.

Original solution:

```1
Count i while _/10 {
Write 49
0
}
Write 48+_```

The initial accumulator value goes from 1 to 9 and then to 99. Whenever it is less than 10, _/10 is 0 and the loop doesn't execute. When it is greater than 10, the inner loop writes a 1 and sets the accumulator to 0, which breaks out of the loop and writes a 0.

Title: Code ladder, Cops

Body:
Note: This challenge is finished. Submissions are still welcome but can not win.

This is the cops' thread. The robbers' thread goes here.

Write a code that outputs the integer 1. If you add, remove or substitute a single character (of your choosing), the code should output the integer 2. Change one more character (the same or another), and the code should output 3. Continue like this as far as you can, but maximum up to 10. Default output formats such as ans = 1 are accepted. You can ignore output to STDERR (or equivalent).

You must reveal the language, byte count of your initial code, the number of integers it works for, as well as an optional number of characters of the initial code. Note: You don't have to reveal any characters, but remember that revealing characters might make it harder for the robbers as they must use the same character in the same position. You can choose which character you use to denote unrevealed characters (for instance underscore), but make sure to specify this.

Cops can provide the uncracked code after one week and call the submission "SAFE". The winning submission will be the shortest uncracked submission that produces the number 10. If no uncracked submissions are able to print 10, the shortest code that produces 9 will win, and so on. Note that the robbers don't have to make the same changes as you do, and they don't have to reproduce the exact code (unless you reveal all characters). They must only reproduce the output.

Submissions posted later than November 24th are welcome but not eligible for the win (because there will likely be fewer robbers around).

Example post:

The following post is a submission in the language MyLang, it is 9 bytes long, and it works for numbers 1 - 8.

MyLang, 9 bytes, 8 numbers

This submission works for 1 - 8. Unrevealed characters are indicated with an underscore: _.

```<code>abc____i
</code>```

Leaderboard

Disclaimer: The leaderboard is not tested and uncracked submissions might not appear in the list.

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea">

Uncracked submissions

 Language	 Score	 User

Sort by: score creation

Safe submissions

 Language	 Score	 User

```

Body:
Acc!!, 46 bytes, 10 numbers, cracked

?
Count i while ?????????????????
}
Write ????

Works for 1 to 10, with ? as the hidden character.

Original solution:

1
Count i while _/10 {
Write 49
0
}
Write 48+_

The initial accumulator value goes from 1 to 9 and then to 99. Whenever it is less than 10, _/10 is 0 and the loop doesn't execute. When it is greater than 10, the inner loop writes a 1 and sets the accumulator to 0, which breaks out of the loop and writes a 0.


答:
C, 10+ numbers, 216 bytes, Cracked

```<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;}
</code>```

If your solution doesn't work with -O1 I will reject it.

Cracked by Dada. Original file:

```<code>#include <stdio.h>

FILE *a, *b;

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

Title: Code ladder, Cops

Body:
C, 10+ numbers, 216 bytes, Cracked

#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;}

If your solution doesn't work with -O1 I will reject it.

Cracked by Dada. Original file:

#include <stdio.h>

FILE *a, *b;

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


答:
Jelly, 7 bytes, 10 numbers, cracked

```<code>“1‘ỌȮḊ‘
</code>```

No wildcards.

The crack achieved (to use an eval with an argument) was, as many seem to be in this thread, not the intended one.

The intended crack was:

```<code>“1‘ỌȮḊ‘ - (prints 1)
“1‘     - code page index list of characters "1": [49]
   Ọ    - cast to ordinals: ['1']
    Ȯ   - print (with no line feed) and return input: effectively prints "1"
        -     (but if left at this would then implicitly print another "1")
     Ḋ  - dequeue: []
      ‘ - increment (vectorises): []
        - implicit print: prints ""

“1‘ỌŒḊ‘ - (prints 2)
“1‘Ọ    - as above: ['1']
    ŒḊ  - depth: 1
      ‘ - increment: 2
        - implicit print: prints "2"

“1‘ỌŒḊ‘‘ - (prints 3)
“1‘ỌŒḊ‘  - as above: 2
       ‘ - increment: 3
         - implicit print: prints "3"

... keep adding an increment operator to print 4 - 10.
</code>```

Title: Code ladder, Cops

Body:
Jelly, 7 bytes, 10 numbers, cracked

“1‘ỌȮḊ‘

No wildcards.

The crack achieved (to use an eval with an argument) was, as many seem to be in this thread, not the intended one.

The intended crack was:

“1‘ỌȮḊ‘ - (prints 1)
“1‘     - code page index list of characters "1": [49]
   Ọ    - cast to ordinals: ['1']
    Ȯ   - print (with no line feed) and return input: effectively prints "1"
        -     (but if left at this would then implicitly print another "1")
     Ḋ  - dequeue: []
      ‘ - increment (vectorises): []
        - implicit print: prints ""

“1‘ỌŒḊ‘ - (prints 2)
“1‘Ọ    - as above: ['1']
    ŒḊ  - depth: 1
      ‘ - increment: 2
        - implicit print: prints "2"

“1‘ỌŒḊ‘‘ - (prints 3)
“1‘ỌŒḊ‘  - as above: 2
       ‘ - increment: 3
         - implicit print: prints "3"

... keep adding an increment operator to print 4 - 10.


答:
Octave, 26 bytes, 10 numbers, by LuisMendo

```<code>original
__a__repmat(_+one___1+__))

solution:
mean(repmat(0+ones, 1+0 ))
mean(repmat(1+ones, 1+0 ))
mean(repmat(2+ones, 1+0 ))
...
</code>```

Title: Code ladder, Robbers

Body:
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 ))
...


Title: Build me a brick wall!

Body:
bash 36 Byte

printf '_|__%.0s' {1..175}|fold -w70

OUtput:

_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__


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

```<code>Por que você só fala assim?
</code>```

Output

```<code>pir ki vici si fili issim?
</code>```

Input

```<code>Que horas são?
</code>```

Output

```<code>ki hiris sim?
</code>```

Input

```<code>Óculos sem lente pode ser armação
</code>```

Output

```<code>ikilis sim linti pidi sir irmicim
</code>```

Input

```<code>Ganha o código com menos bytes
</code>```

Output

```<code>guinhi i kidigui kim minis bytis
</code>```

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!

答:
JavaScript, <s>396</s> <s>392</s> 389 bytes (<s>383</s> <s>379</s> 376 characters)

Too many replaces, too much regex, ...

```<code>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")
</code>```

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

```<code>s.toLowerCase()
</code>```

First, everything is converted to lowercase.

```<code>.replace(/ão|õe/g,"im")
</code>```

Then I'm am implementing this rule.

```<code>.replace(/[àâá]/g,"a").replace(/é|ê/g,"e").replace(/í/g,"i").replace(/ó|ô/g,"o").replace(/ú|ü/g,"u")
</code>```

Then the accents are removed using regex.

```<code>.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")
</code>```

After that, the the string is being bombarded by regular expressions to "memify" it.

```<code>.split("gui").map(function(a){return a.replace(/[aeou]/g,"i")}).join("gui")
</code>```

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.

```<code>.replace(/i{2,}/g,"i")
</code>```

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

Title: Why don't you grow up?

Body:
JavaScript, <s>396</s> <s>392</s> 389 bytes (<s>383</s> <s>379</s> 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


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

```<code>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
</code>```

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.

答:
Jelly, <s>15</s> 14 bytes

```<code>620œ?$ÐĿY€j⁷Ḥ¤
</code>```

TryItOnline!

How?

Yey, a use of one of my additions to Jelly! (œ?)

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

Title: Blueprint a sestina

Body:
Jelly, <s>15</s> 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)


答:
Retina, 150 bytes

```<code>[ÀÁÂàáâ]
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
</code>```

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

```<code>[ÀÁÂàáâ]
a
[ÉÊéê]
e
Í|í
i
[ÓÔóô]
o
[ÚÜúü]
u
T`L`l
</code>```

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

```<code>ão|õe
im
[ck][aou]|qu[ei]|ke
ki
ç[aeiou]|ce
ci
g[aou]|gue
gui
j[aeou]|g[ei]
ji
</code>```

These rules simply apply the substitutions specified.

Section 3: Cleanup

```<code>(gu)i|[aeou]
$1i
i+
i
</code>```

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

Title: Why don't you grow up?

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

```<code>Por que você só fala assim?
</code>```

Output

```<code>pir ki vici si fili issim?
</code>```

Input

```<code>Que horas são?
</code>```

Output

```<code>ki hiris sim?
</code>```

Input

```<code>Óculos sem lente pode ser armação
</code>```

Output

```<code>ikilis sim linti pidi sir irmicim
</code>```

Input

```<code>Ganha o código com menos bytes
</code>```

Output

```<code>guinhi i kidigui kim minis bytis
</code>```

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!

Body:
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.


答:
JavaScript, 22 bytes, 10 numbers, cracked

Probably rather easy to crack.

```<code>alert(__14_337__xc_de)
</code>```

_ being a hidden character

Title: Code ladder, Cops

Body:
JavaScript, 22 bytes, 10 numbers, cracked

Probably rather easy to crack.

alert(__14_337__xc_de)

_ being a hidden character


问:
Quine Anagrams! (Robbers' Thread)
This is the robbers' thread. For the cops' thread, click here.

Cops' Task

For the cops' thread, click here.

Robbers' Task

Find an uncracked submission on the cops' thread. (A submission may only be cracked once.)

Unscramble the code to find a working quine.

Post an answer on the robbers' thread. Include the language, the byte count, the user who posted the scrambled code, a link to that answer, and the unscrambled code.

Here is an example of a robber submission:

Python, 29 bytes, Oliver

```<code>_='_=%r;print _%%_';print _%_
</code>```

Scoring

The user with the most cracks will be the winner of this section.

答:
Underload, 20 bytes, ais523

```<code>(:a~*(*S)):a~*(*S)*S
</code>```

Try it online!

Explanation

The basic quine in Underload is this:

```<code>(:aSS):aSS
</code>```

Here is how it works:

```<code>                                  Stack:               Output:
(:aSS)      # Push string.        (:aSS)
      :     # Duplicate.          (:aSS) (:aSS)
       a    # Wrap in (...).      (:aSS) ((:aSS))
        S   # Print.              (:aSS)               (:aSS)
         S  # Print.                                   (:aSS):aSS
</code>```

The first issue was to reduce the number of S we need, because we've only got 3 for use here. We can do this by making use of swapping (~) and concatenation (*):

```<code>(:a~*S):a~*S
</code>```

Here, instead of printing twice, we put the (...) version and the plain version of the string together and print that only once.

The bigger puzzle is how print an odd number of * and S. I'm not even sure how I actually arrived at the final solution, but it turns out that we can do this by putting the tail of the output in a separate string. That string itself is duplicated in the first string, but the contents are not, which gives us the extra occurrences of * and S we need. Here is a breakdown of the final solution:

```<code>                        Stack:                       Output:
(:a~*(*S))              (:a~*(*S))
          :             (:a~*(*S)) (:a~*(*S))
           a            (:a~*(*S)) ((:a~*(*S)))
            ~           ((:a~*(*S))) (:a~*(*S))
             *          ((:a~*(*S)):a~*(*S))
              (*S)      ((:a~*(*S)):a~*(*S)) (*S)
                  *     ((:a~*(*S)):a~*(*S)*S)
                   S                                 (:a~*(*S)):a~*(*S)*S
</code>```

Title: Quine Anagrams! (Robbers' Thread)

Body:
Underload, 20 bytes, ais523

(:a~*(*S)):a~*(*S)*S

Try it online!

Explanation

The basic quine in Underload is this:

(:aSS):aSS

Here is how it works:

                                  Stack:               Output:
(:aSS)      # Push string.        (:aSS)
      :     # Duplicate.          (:aSS) (:aSS)
       a    # Wrap in (...).      (:aSS) ((:aSS))
        S   # Print.              (:aSS)               (:aSS)
         S  # Print.                                   (:aSS):aSS

The first issue was to reduce the number of S we need, because we've only got 3 for use here. We can do this by making use of swapping (~) and concatenation (*):

(:a~*S):a~*S

Here, instead of printing twice, we put the (...) version and the plain version of the string together and print that only once.

The bigger puzzle is how print an odd number of * and S. I'm not even sure how I actually arrived at the final solution, but it turns out that we can do this by putting the tail of the output in a separate string. That string itself is duplicated in the first string, but the contents are not, which gives us the extra occurrences of * and S we need. Here is a breakdown of the final solution:

                        Stack:                       Output:
(:a~*(*S))              (:a~*(*S))
          :             (:a~*(*S)) (:a~*(*S))
           a            (:a~*(*S)) ((:a~*(*S)))
            ~           ((:a~*(*S))) (:a~*(*S))
             *          ((:a~*(*S)):a~*(*S))
              (*S)      ((:a~*(*S)):a~*(*S)) (*S)
                  *     ((:a~*(*S)):a~*(*S)*S)
                   S                                 (:a~*(*S)):a~*(*S)*S


Title: Code ladder, Cops

Body:
Octave, 17 bytes, 10 numbers, Cracked

_od(3_13_13_7_1_)

Original solution

 mod(3*1361357,10)

 ...

 mod(3*1361357,17)

 mod(3*1361397,17)

 mod(9*1361397,17)

_ is the hidden character.


答:
Racket 115 bytes

```<code>(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)))
</code>```

Ungolfed:

```<code>(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))))
</code>```

Testing:

```<code>(f (list "house" "grandmother" "child" "stove" "almanac" "tears") 6)
</code>```

Output:

```<code>'(("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"))
</code>```

Title: Blueprint a sestina

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

```<code>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
</code>```

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.

Body:
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"))


答:
Octave, 17 bytes, 10 numbers, by flawr

From

```<code>_od(3_13_13_7_1_)
</code>```

To the original code:

```<code>mod(3113+1387,11) #1
</code>```

The rest of the numbers:

```<code>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
</code>```

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

```<code>mod(3_13+13_7,1_)
</code>```

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.

```<code>mod(3119+1389,11) #evaluates to 9
</code>```

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!

Title: Code ladder, Robbers

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

```<code>abc1efghi
</code>```

Code that produces 1 - 8:

```<code>1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi
</code>```

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

Body:
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!


答:
Befunge-93, 11 bytes, 10+ numbers, Cracked

This submission works for at least 1 - 10. Unrevealed characters are indicated with □.

```<code>□□5:**-□-.@
</code>```

Try it online

I must say I was impressed that two people could come up with independent solutions for this, neither of which were what I was expecting. While Martin got there first, I'm giving the "win" to Sp3000 as their solution is more portable.

This was my intended solution though:

g45:**-2-.@

g45:**-1-.@

g45:**-1\.@

g45:**-1\+.@

g45:**-2\+.@

...

g45:**-7\+.@

Because a stack underflow in Befunge is interpreted as 0, the g just reads from 0,0 returning the ASCII value of 'g', namely 103. 45:**- subtracts 100, giving you 3. Then 2- gives you 1.

For the third iteration, the - (subtract) is changed to a \ (swap) instruction, so the 3 becomes the topmost stack entry. And in iteration four, a + (add) instruction is inserted, thus adding the 3 to the 1 giving 4.

Title: Code ladder, Cops

Body:
Note: This challenge is finished. Submissions are still welcome but can not win.

This is the cops' thread. The robbers' thread goes here.

Write a code that outputs the integer 1. If you add, remove or substitute a single character (of your choosing), the code should output the integer 2. Change one more character (the same or another), and the code should output 3. Continue like this as far as you can, but maximum up to 10. Default output formats such as ans = 1 are accepted. You can ignore output to STDERR (or equivalent).

You must reveal the language, byte count of your initial code, the number of integers it works for, as well as an optional number of characters of the initial code. Note: You don't have to reveal any characters, but remember that revealing characters might make it harder for the robbers as they must use the same character in the same position. You can choose which character you use to denote unrevealed characters (for instance underscore), but make sure to specify this.

Cops can provide the uncracked code after one week and call the submission "SAFE". The winning submission will be the shortest uncracked submission that produces the number 10. If no uncracked submissions are able to print 10, the shortest code that produces 9 will win, and so on. Note that the robbers don't have to make the same changes as you do, and they don't have to reproduce the exact code (unless you reveal all characters). They must only reproduce the output.

Submissions posted later than November 24th are welcome but not eligible for the win (because there will likely be fewer robbers around).

Example post:

The following post is a submission in the language MyLang, it is 9 bytes long, and it works for numbers 1 - 8.

MyLang, 9 bytes, 8 numbers

This submission works for 1 - 8. Unrevealed characters are indicated with an underscore: _.

```<code>abc____i
</code>```

Leaderboard

Disclaimer: The leaderboard is not tested and uncracked submissions might not appear in the list.

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea">

Uncracked submissions

 Language	 Score	 User

Sort by: score creation

Safe submissions

 Language	 Score	 User

```

Body:
Befunge-93, 11 bytes, 10+ numbers, Cracked

This submission works for at least 1 - 10. Unrevealed characters are indicated with □.

□□5:**-□-.@

Try it online

I must say I was impressed that two people could come up with independent solutions for this, neither of which were what I was expecting. While Martin got there first, I'm giving the "win" to Sp3000 as their solution is more portable.

This was my intended solution though:

g45:**-2-.@

g45:**-1-.@

g45:**-1\.@

g45:**-1\+.@

g45:**-2\+.@

...

g45:**-7\+.@

Because a stack underflow in Befunge is interpreted as 0, the g just reads from 0,0 returning the ASCII value of 'g', namely 103. 45:**- subtracts 100, giving you 3. Then 2- gives you 1.

For the third iteration, the - (subtract) is changed to a \ (swap) instruction, so the 3 becomes the topmost stack entry. And in iteration four, a + (add) instruction is inserted, thus adding the 3 to the 1 giving 4.


答:
Befunge-93, 11 bytes, 10 numbers, James Holderness

```<code>905:**-8-.@
905:**-7-.@
905:**-6-.@
905:**-5-.@
905:**-4-.@
905:**-3-.@
905:**-2-.@
905:**-1-.@
905:**-0-.@
905:**-~-.@
</code>```

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.

Title: Code ladder, Robbers

Body:
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.


问:
Quine Anagrams! (Cops' Thread)
This is the cops' thread. For the robbers' thread, click here.

Cops' Task

First, write a quine in a language of your choosing.

Next, scramble the quine. Make sure to do this well as the robbers will be trying to unscramble it and find the original source code! Note that the scrambled code does not need to work.

Post an answer on this thread. Include the language, the byte count, and the scrambled code.

Your program may not print to STDERR.

Here is an example of a cop submission:

Python, 29 bytes

```<code>nt _%=_r;_riinp;pr_='t _%%%_'
</code>```

Robbers' Task

For the robbers' thread, click here.

Safe Submissions

If your submission has not yet been cracked after a week of posting, you may add the solution and specify that it is safe. If you do not, your submission may still be cracked.

Scoring

This is code-golf, so the user with the safe submission with the fewest bytes will be the winner of this section.

Leaderboard

Here is a stack snippet to generate a learderboard for this challenge. For it to display properly, please format your submission like this:

```<code># Language Name, N bytes

... other stuff ...
</code>```

If your submission gets cracked, please format like this:

```<code># Language Name, N bytes, [Cracked!](link)

... other stuff ...
</code>```

If your submission is safe, format like this:

```<code># Language Name, N bytes, Safe!

... other stuff ...
</code>```

```

答:
Jelly, 3 bytes, Cracked!

```<code>Ṙ”Ṙ
</code>```

Try it online!

Here is the solution:

What, you want the solution? Find it!

Title: Quine Anagrams! (Cops' Thread)

Body:
Jelly, 3 bytes, Cracked!

Ṙ”Ṙ

Try it online!

Here is the solution:

What, you want the solution? Find it!


答:
Jelly, 3 bytes, Erik the Golfer

```<code>”ṘṘ
</code>```

Try it online!

There aren't really that many options... (Plus, this is the standard quine.)

Title: Quine Anagrams! (Robbers' Thread)

Body:
This is the robbers' thread. For the cops' thread, click here.

Cops' Task

For the cops' thread, click here.

Robbers' Task

Find an uncracked submission on the cops' thread. (A submission may only be cracked once.)

Unscramble the code to find a working quine.

Post an answer on the robbers' thread. Include the language, the byte count, the user who posted the scrambled code, a link to that answer, and the unscrambled code.

Here is an example of a robber submission:

Python, 29 bytes, Oliver

```<code>_='_=%r;print _%%_';print _%_
</code>```

Scoring

The user with the most cracks will be the winner of this section.

Body:
Jelly, 3 bytes, Erik the Golfer

”ṘṘ

Try it online!

There aren't really that many options... (Plus, this is the standard quine.)


答:
Python 2, 105 bytes, Cracked!

```<code>    ######%%%%''(((((((())))))))****--0011::::;;==@@@@@@@@@@[[[[]]]]aaaaaaggggggiiiiiiiinnpprrrrrrrrrtt~~
</code>```

The other one was cracked, so this one is more difficult.

```print'To find the solution, get to work!'```

Title: Quine Anagrams! (Cops' Thread)

Body:
This is the cops' thread. For the robbers' thread, click here.

Cops' Task

First, write a quine in a language of your choosing.

Next, scramble the quine. Make sure to do this well as the robbers will be trying to unscramble it and find the original source code! Note that the scrambled code does not need to work.

Post an answer on this thread. Include the language, the byte count, and the scrambled code.

Your program may not print to STDERR.

Here is an example of a cop submission:

Python, 29 bytes

```<code>nt _%=_r;_riinp;pr_='t _%%%_'
</code>```

Robbers' Task

For the robbers' thread, click here.

Safe Submissions

If your submission has not yet been cracked after a week of posting, you may add the solution and specify that it is safe. If you do not, your submission may still be cracked.

Scoring

This is code-golf, so the user with the safe submission with the fewest bytes will be the winner of this section.

Leaderboard

Here is a stack snippet to generate a learderboard for this challenge. For it to display properly, please format your submission like this:

```<code># Language Name, N bytes

... other stuff ...
</code>```

If your submission gets cracked, please format like this:

```<code># Language Name, N bytes, [Cracked!](link)

... other stuff ...
</code>```

If your submission is safe, format like this:

```<code># Language Name, N bytes, Safe!

... other stuff ...
</code>```

```

Body:
Python 2, 105 bytes, Cracked!

    ######%%%%''(((((((())))))))****--0011::::;;==@@@@@@@@@@[[[[]]]]aaaaaaggggggiiiiiiiinnpprrrrrrrrrtt~~

The other one was cracked, so this one is more difficult.

print'To find the solution, get to work!'


答:
Octave, 21 bytes, 10 numbers, Cracked

```<code>disp(fpr___f__e_(_'_)
</code>```

This works for 1-10. _ are hidden characters. This will be my last and hopefully best post.

Intended solution:

 disp(fpr= -fopen('')) and disp(fpr=1-fopen('')) for 2...10

Explanation:

 disp(fprintf('_')) will actually print _1 if executed, so fpr___f was chosen to throw people off. The f was needed in fopen so there was only one additional space. fopen('') returns -1 since it fails to open a file with an empty name. fpr= -fopen('') makes fpr = 1.

Title: Code ladder, Cops

Body:
Octave, 21 bytes, 10 numbers, Cracked

disp(fpr___f__e_(_'_)

This works for 1-10. _ are hidden characters. This will be my last and hopefully best post.

Intended solution:

 disp(fpr= -fopen('')) and disp(fpr=1-fopen('')) for 2...10

Explanation:

 disp(fprintf('_')) will actually print _1 if executed, so fpr___f was chosen to throw people off. The f was needed in fopen so there was only one additional space. fopen('') returns -1 since it fails to open a file with an empty name. fpr= -fopen('') makes fpr = 1.


Title: Quine Anagrams! (Cops' Thread)

Body:
><>, 36 bytes, Cracked!

!!!'''***+...00002333:::;???dddforrr


答:
05AB1E, 5 bytes, 10 numbers, cracked!

Not very hard, but a fun one :)

```<code>_[==_
</code>```

_ is a random character. Uses the CP-1252 encoding. Try it online!

Title: Code ladder, Cops

Body:
05AB1E, 5 bytes, 10 numbers, cracked!

Not very hard, but a fun one :)

_[==_

_ is a random character. Uses the CP-1252 encoding. Try it online!


答:
05AB1E, 5 bytes, 10 numbers, by Adnan.

Original code:

```<code>…[==1
</code>```

1-10:

```<code>…[==1
…[==2
…[==3
…[==4
…[==5
…[==6
…[==7
…[==8
…[==9
…[==T
</code>```

Explanation:

```<code>…[==   3 char string
    1  Push number
</code>```

Title: Code ladder, Robbers

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


答:
Pyth, 4 bytes, 9 numbers -  Cracked

```<code>.__Q
</code>```

Not super difficult, but should hopefully be fun.

Title: Code ladder, Cops

Body:
Pyth, 4 bytes, 9 numbers -  Cracked

.__Q

Not super difficult, but should hopefully be fun.


答:
><>, 36 bytes, Erik the Golfer

```<code>'''000**rd3*:::?!;od0.!!+..233??dfrr
</code>```

Try it online!

I'm quite sure that this is not the intended solution. However, ><> quines make it fairly easy to get rid of most unwanted characters, except the '. Fortunately, the : made it quite easy to take care of those as well.

Explanation

```<code>'''                                    Push everything except these quotes onto the stack.
   000**                               In effect, pushes a zero.
        r                              Reverse the stack.
         d3*                           Push 39 (the quote character).
            ::                         Make two copies. The stack now holds
                                       a null-terminated representation of the
                                       entire code.
                                       The print loop begins here...
              :                        Duplicate top of stack.
               ?!;                     Terminate if zero.
                  o                    Otherwise, print.
                   d0.                 Jump back to position 13, i.e. the
                                       beginning of the print loop.
                      !!+..233??dfrr   Unused characters.
</code>```

Title: Quine Anagrams! (Robbers' Thread)

Body:
><>, 36 bytes, Erik the Golfer

'''000**rd3*:::?!;od0.!!+..233??dfrr

Try it online!

I'm quite sure that this is not the intended solution. However, ><> quines make it fairly easy to get rid of most unwanted characters, except the '. Fortunately, the : made it quite easy to take care of those as well.

Explanation

'''                                    Push everything except these quotes onto the stack.
   000**                               In effect, pushes a zero.
        r                              Reverse the stack.
         d3*                           Push 39 (the quote character).
            ::                         Make two copies. The stack now holds
                                       a null-terminated representation of the
                                       entire code.
                                       The print loop begins here...
              :                        Duplicate top of stack.
               ?!;                     Terminate if zero.
                  o                    Otherwise, print.
                   d0.                 Jump back to position 13, i.e. the
                                       beginning of the print loop.
                      !!+..233??dfrr   Unused characters.


答:
C, 216 bytes, 10 numbers, by Joshua

Original code :

```<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;}
</code>```

Cracked code :

```<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;}
</code>```

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.

Title: Code ladder, Robbers

Body:
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.


答:
Pyth, 4 bytes, 9 numbers, isaacg

Original code:

```<code>."1Q
</code>```

Which is a packed string containing the character 1. The other programs:

```<code>."2Q
."3Q
."4Q
."5Q
."6Q
."7Q
."8Q
."9Q
</code>```

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

Title: Code ladder, Robbers

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

```<code>abc1efghi
</code>```

Code that produces 1 - 8:

```<code>1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi
</code>```

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

Body:
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).


问:
Code close to the challenge: Sum of integers
This is a simple challenge:
Given a sequence of integers, find the sum of all integers in it.

But with a twist.
Your score is the Levenshtein distance between your code and the following phrase (The challenge):

Given a set of integers, find the sum of all integers in it.

You may assume there are no newlines or trailing spaces in the input.

Example input/output:

```<code>Input: 1 5 -6 2 4 5
Output: 11
Input: 1 -2 10
Output: 9
</code>```

An online calculator for Levenshtein distance can be found here: http://planetcalc.com/1721/

答:
C++17, distance <s>44</s> 29

Variadic Generic Lambda FTW

[](auto...t){return(t+...);}//the sum of all integers in it.
```
<p>Previous solution</p>
<pre class="lang-c++ prettyprint-override"><code>template<class...t>int s(t...l){return(...+l);}//gers in it.
</code>```

Body:
C++17, distance <s>44</s> 29

Variadic Generic Lambda FTW

[](auto...t){return(t+...);}//the sum of all integers in it.

Previous solution

template<class...t>int s(t...l){return(...+l);}//gers in it.


答:
TI-Basic, 13 tokens, 10 numbers, cracked

```<code>DelVar A1→θ
__>A
θ
</code>```

_ represents a hidden token. Hopefully this isn't too easy xD

Title: Code ladder, Cops

Body:
Note: This challenge is finished. Submissions are still welcome but can not win.

This is the cops' thread. The robbers' thread goes here.

Write a code that outputs the integer 1. If you add, remove or substitute a single character (of your choosing), the code should output the integer 2. Change one more character (the same or another), and the code should output 3. Continue like this as far as you can, but maximum up to 10. Default output formats such as ans = 1 are accepted. You can ignore output to STDERR (or equivalent).

You must reveal the language, byte count of your initial code, the number of integers it works for, as well as an optional number of characters of the initial code. Note: You don't have to reveal any characters, but remember that revealing characters might make it harder for the robbers as they must use the same character in the same position. You can choose which character you use to denote unrevealed characters (for instance underscore), but make sure to specify this.

Cops can provide the uncracked code after one week and call the submission "SAFE". The winning submission will be the shortest uncracked submission that produces the number 10. If no uncracked submissions are able to print 10, the shortest code that produces 9 will win, and so on. Note that the robbers don't have to make the same changes as you do, and they don't have to reproduce the exact code (unless you reveal all characters). They must only reproduce the output.

Submissions posted later than November 24th are welcome but not eligible for the win (because there will likely be fewer robbers around).

Example post:

The following post is a submission in the language MyLang, it is 9 bytes long, and it works for numbers 1 - 8.

MyLang, 9 bytes, 8 numbers

This submission works for 1 - 8. Unrevealed characters are indicated with an underscore: _.

```<code>abc____i
</code>```

Leaderboard

Disclaimer: The leaderboard is not tested and uncracked submissions might not appear in the list.

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea">

Uncracked submissions

 Language	 Score	 User

Sort by: score creation

Safe submissions

 Language	 Score	 User

```

Body:
TI-Basic, 13 tokens, 10 numbers, cracked

DelVar A1→θ
__>A
θ

_ represents a hidden token. Hopefully this isn't too easy xD


Title: Build me a brick wall!

Body:
Challenge

I need help building a brick wall! Throw together some code for me
 using no input and produce the following output wall shown below:

```<code>_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
</code>```

Now, this wall is exactly 10 characters high and 70 characters
 wide.

As stated above, no inputs, only code. Least amount of bytes, we have
 to efficiently build this brick wall. Obviously, this program has to
 function to get the wall built..? or it obviously won't build itself!
 Good luck!

Winner

The winner goes to Marinus using the APL language, requiring a whole 12 bytes!
https://codegolf.stackexchange.com/a/99028/61857

Thank you everyone for participating!

Body:
Python 3 - 41 chars

s="_|__"*17
print((s+"_|\n__"+s+"\n")*5)


答:
JavaScript, 22 bytes, 10 numbers, cracked

```<code>alert(0_6_4_>_0_2_0_7)
</code>```

_ is the hidden character.

Hint about the intended solution

The character that needs to be changed to generate all numbers is always the same.

Title: Code ladder, Cops

Body:
JavaScript, 22 bytes, 10 numbers, cracked

alert(0_6_4_>_0_2_0_7)

_ is the hidden character.

Hint about the intended solution

The character that needs to be changed to generate all numbers is always the same.


答:
Jelly, 7 bytes, 10 numbers, Jonathan Allan

Original code:

```<code>“1‘ỌȮḊ‘
</code>```

Then:

```<code>“1‘‘ỌȮḊ‘
“1‘‘‘ỌȮḊ‘
“1‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌvḊ‘
</code>```

You can check the last one on TryItOnline!

Another way would be

```<code>“2‘ỌȮḊ‘
“3‘ỌȮḊ‘
...
“9‘ỌȮḊ‘
“9‘ỌvḊ‘
</code>```

Title: Code ladder, Robbers

Body:
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Ḋ‘


答:
05AB1E, 6 bytes, 10 numbers, cracked

Attempt 2, this time without the three-char string :p.

```<code>_ [==_
</code>```

_ is a random character. Uses the CP-1252 encoding. Try it online!

Title: Code ladder, Cops

Body:
05AB1E, 6 bytes, 10 numbers, cracked

Attempt 2, this time without the three-char string :p.

_ [==_

_ is a random character. Uses the CP-1252 encoding. Try it online!


答:
C++ 14, 482 bytes

include<iostream>#include<string>#include<math.h>usingnamespacestd;intmain(){stringa,b,c,d;intj=0;inte[2];getline(cin,a);getline(cin,b);getline(cin,c);for(inti=0;i<a.size();i){if(isdigit(a.at(i))){while(ir)e[1]=l/l2;elsee[0]=r/l1;cout<<e[0]<<s<<e[1]<<endl;cout<<b<<endl;cout<<c;return0;}
```

<p>more readable version:</p>

<pre class="lang-c++ prettyprint-override"><code>#include <iostream>
#include <string>
#include <math.h>
using namespace std;
int main() {
    string a,b,c,d;
    int j=0;
    int e[2];
    // input
    getline(cin,a);// 1st line
    getline(cin,b);// 2nd line
    getline(cin,c);// 3rd line
    for (int i=0;i<a.size();i++) {
        if(isdigit(a.at(i))){
            while(i<a.size() && isdigit(a.at(i))){
                d+=a.at(i);
                i++;
            }
            e[j++]=stoi(d);
            d="";
        }
    }
    // amount of white space in between 2 numbers
    string s(b.size()-(int)log10(e[0])-(int)log10(e[1])-2,' ');
    int l1 = (c.size()-1);
    int l2 = (b.size()-c.size());
    int l = e[0]*l1;
    int r = e[1]*l2;
    // change the side with smaller torque
    if (l>r)
        e[1]=l/l2;
    else
        e[0]=r/l1;
    // output
    cout<<e[0]<<s<<e[1]<<endl;// 1st line
    cout<<b<<endl;// 2nd line
    cout<<c;// 3rd line
    return 0;
}
</code>```

Title: Add weight to one side of a see-saw to balance it

Body:
Balancing Act

A see-saw (supposedly from the French 'ci-ça', meaning 'this-that') forms a third of the holy trinity of playground equipment, along with the similarly ubiquitous slide and swing. A see-saw is in perfect balance if, and only if, the sum of the moments on each side are equivalent. A see-saw can therefore be balanced by adding a specific quantity of weight to the side with the lower moment sum; achieving this is your goal for this challenge.

Challenge

Your challenge is to take a depiction of a see-saw as input and output it again, with weight added to one end of the see-saw to balance it.

Input

Your program must take, in any reasonable format, an ASCII see-saw such as the following:

```<code>100             100
-------------------
         ^
</code>```

The first line contains two numbers, each representing weights on the see-saw. Exactly one weight is present on each side, each acting on the very end of its side of the plank. Weights are guaranteed to be integers, and always align with their corresponding end of the plank. These numbers will never overlap the fulcrum (^).

The second line represents the 'plank' of the see-saw. Each dash (-) represents an equal length to each other dash, with the sole exception of the dash directly over the fulcrum (^), which has no length.

The third line represents the fulcrum of the see-saw. This fulcrum is marked by the only character that is not a space on this line, a circumflex ('^'). The fulcrum can be positioned anywhere along the length of the plank in a valid input so long as enough space is left so that the numbers representing weights do not overlap the fulcrum in either the input or the output.

The input is guaranteed to have three lines, and have no white-space prior to or after the characters that constitute the see-saw (excepting, of course, the third line, which requires it).

Output

For output, the same see-saw depiction should be printed to stdout, but with one (and only one) of the weights replaced with a larger weight, so as to balance the see-saw. Inputs are guaranteed to make this possible using integers alone. Therefore, weights must be shown without decimal points or any other similar notations. If your language does not use stdout you should go by community / meta consensus on output. Trailing newlines are fine but any other changes to the depiction format are probably not OK.

Exemplification

Test Inputs and Corresponding Outputs

Input 1

```<code>12                22
--------------------
             ^
</code>```

Output 1

```<code>12                26
--------------------
             ^
</code>```

Input 2

```<code>42       42
-----------
     ^
</code>```

Output 2

```<code>42       42
-----------
     ^
</code>```

Input 3

```<code>3             16
----------------
        ^
</code>```

Output 3

```<code>14            16
----------------
        ^
</code>```

Input 4

```<code>1                56
-------------------
    ^
</code>```

Output 4

```<code>196              56
-------------------
    ^
</code>```

Reference Implementation - Python 3

```<code># Takes a list of strings as input
def balance_seesaw(lines):
    weights = [int(w.strip()) for w in lines[0].split()]

    length  = len(lines[1])
    pivot   = lines[2].find("^")
    left_length    = pivot
    right_length   = length - 1 - pivot

    left_torque  = weights[0] * left_length
    right_torque = weights[1] * right_length

    if left_torque > right_torque:
        weights[1] = left_torque // right_length
    elif right_torque > left_torque:
        weights[0] = right_torque // left_length

    weights = [str(w) for w in weights]

    string_gap = " " * (length - sum(len(w) for w in weights))
    lines[0] = weights[0] + string_gap + weights[1]

    print("\n".join(lines))

balance_seesaw(["1                56",
                "-------------------",
                "    ^              "])
</code>```

Rules

This is code-golf, so the shortest code wins counted in bytes. Check meta if counting bytes is awkward in your language.

Standard rules/loopholes apply.

Input must be taken in a reasonable format. A non-exhaustive list of appropriate formats are given as follows:

A single string with lines separated by newline characters

A list of strings, each string represented a line

A 2D Array or Matrix of characters

Related Challenges

Balance a set of weights on a see-saw - Proposed Aug 2015 by samgak

Body:
C++ 14, 482 bytes

include<iostream>#include<string>#include<math.h>usingnamespacestd;intmain(){stringa,b,c,d;intj=0;inte[2];getline(cin,a);getline(cin,b);getline(cin,c);for(inti=0;i<a.size();i){if(isdigit(a.at(i))){while(i<a.size()&&isdigit(a.at(i))){d=a.at(i);i;}e[j]=stoi(d);d="";}}strings(b.size()-(int)log10(e[0])-(int)log10(e[1])-2,'');intl1=(c.size()-1);intl2=(b.size()-c.size());intl=e[0]*l1;intr=e[1]*l2;if(l>r)e[1]=l/l2;elsee[0]=r/l1;cout<<e[0]<<s<<e[1]<<endl;cout<<b<<endl;cout<<c;return0;}

more readable version:

#include <iostream>
#include <string>
#include <math.h>
using namespace std;
int main() {
    string a,b,c,d;
    int j=0;
    int e[2];
    // input
    getline(cin,a);// 1st line
    getline(cin,b);// 2nd line
    getline(cin,c);// 3rd line
    for (int i=0;i<a.size();i++) {
        if(isdigit(a.at(i))){
            while(i<a.size() && isdigit(a.at(i))){
                d+=a.at(i);
                i++;
            }
            e[j++]=stoi(d);
            d="";
        }
    }
    // amount of white space in between 2 numbers
    string s(b.size()-(int)log10(e[0])-(int)log10(e[1])-2,' ');
    int l1 = (c.size()-1);
    int l2 = (b.size()-c.size());
    int l = e[0]*l1;
    int r = e[1]*l2;
    // change the side with smaller torque
    if (l>r)
        e[1]=l/l2;
    else
        e[0]=r/l1;
    // output
    cout<<e[0]<<s<<e[1]<<endl;// 1st line
    cout<<b<<endl;// 2nd line
    cout<<c;// 3rd line
    return 0;
}


答:
Octave, 55 bytes, 10 numbers, cracked

```<code>(o__(O_o_(@(__o)o__-O}_)_(0<O,{_(_o_O-1)+1_@(_1}_)(__o_
</code>```

_ is the unknown character.

Solution

 (o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o) %then changing the very last 0 to 1,2,3 e.t.c.

 Given x, this does recursively calculate x+1. It is mainly composed of two anonymous functions. One provides an if statement to anchor the recursion:

 if_ = @( boolean, outcomes) outcomes{ 2 - boolean}();

 This is just abusing the fact that a boolean values evaluates to 0 or 1. This function accepts a boolean value, and a cell array of two functions, and evaluates one or the other of these two functiosn depending on the boolean value. The second part is the actual recursion:

 plus_one = @(n,f) if_(0<n ,{@()f(n-1)+1, @()1})

 As an anyonmous function is anonymous, you cannot directly access it from itsefl. That why we need a second argument f first. Later we will provide  a handle to the function instelf as a second argument, so a final function would looks like so:

  plus_one_final = @(n)plus_one(n,plus_one);

 So in this notation my submission becomes:

 (plus_one=@(n,f)(@(boolean,outcomes)outcomes{2-boolean}())(0<n,{@()f(n-1)+1,@()1}))(n,f)

 I asked about recursion anchors for anonymous functions in MATLAB a while ago on stackoverflow.

Title: Code ladder, Cops

Body:
Octave, 55 bytes, 10 numbers, cracked

(o__(O_o_(@(__o)o__-O}_)_(0<O,{_(_o_O-1)+1_@(_1}_)(__o_

_ is the unknown character.

Solution

 (o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o) %then changing the very last 0 to 1,2,3 e.t.c.

 Given x, this does recursively calculate x+1. It is mainly composed of two anonymous functions. One provides an if statement to anchor the recursion:

 if_ = @( boolean, outcomes) outcomes{ 2 - boolean}();

 This is just abusing the fact that a boolean values evaluates to 0 or 1. This function accepts a boolean value, and a cell array of two functions, and evaluates one or the other of these two functiosn depending on the boolean value. The second part is the actual recursion:

 plus_one = @(n,f) if_(0<n ,{@()f(n-1)+1, @()1})

 As an anyonmous function is anonymous, you cannot directly access it from itsefl. That why we need a second argument f first. Later we will provide  a handle to the function instelf as a second argument, so a final function would looks like so:

  plus_one_final = @(n)plus_one(n,plus_one);

 So in this notation my submission becomes:

 (plus_one=@(n,f)(@(boolean,outcomes)outcomes{2-boolean}())(0<n,{@()f(n-1)+1,@()1}))(n,f)

 I asked about recursion anchors for anonymous functions in MATLAB a while ago on stackoverflow.


答:
05AB1E, 6 bytes, 10 numbers, Adnan

Original code:

```<code>¼ [==q
</code>```

Keep adding ¼'s to output up to 10:

```<code>¼¼ [==q
¼¼¼ [==q
¼¼¼¼ [==q
¼¼¼¼¼ [==q
¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼¼ [==q
</code>```

Try it online

How it works:

```<code>¼        # Increment counter_variable to count_of(¼), it's printed at some point...
  [      # Infinite loop start
   ==    # Print nothing because stack is empty
     q   # Quit
</code>```

Title: Code ladder, Robbers

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


答:
Befunge-93, 15 bytes, Cracked!

```<code>:::@#%+-_,<910g
</code>```

Try it online!

Title: Quine Anagrams! (Cops' Thread)

Body:
This is the cops' thread. For the robbers' thread, click here.

Cops' Task

First, write a quine in a language of your choosing.

Next, scramble the quine. Make sure to do this well as the robbers will be trying to unscramble it and find the original source code! Note that the scrambled code does not need to work.

Post an answer on this thread. Include the language, the byte count, and the scrambled code.

Your program may not print to STDERR.

Here is an example of a cop submission:

Python, 29 bytes

```<code>nt _%=_r;_riinp;pr_='t _%%%_'
</code>```

Robbers' Task

For the robbers' thread, click here.

Safe Submissions

If your submission has not yet been cracked after a week of posting, you may add the solution and specify that it is safe. If you do not, your submission may still be cracked.

Scoring

This is code-golf, so the user with the safe submission with the fewest bytes will be the winner of this section.

Leaderboard

Here is a stack snippet to generate a learderboard for this challenge. For it to display properly, please format your submission like this:

```<code># Language Name, N bytes

... other stuff ...
</code>```

If your submission gets cracked, please format like this:

```<code># Language Name, N bytes, [Cracked!](link)

... other stuff ...
</code>```

If your submission is safe, format like this:

```<code># Language Name, N bytes, Safe!

... other stuff ...
</code>```

```

Body:
Befunge-93, 15 bytes, Cracked!

:::@#%+-_,<910g

Try it online!


答:
Haskell, distance 11

No comments!

```<code>const sum"Given a set of integers, find the sum of all integers in it."
</code>```

Usage:

```<code>> const sum"Given a set of integers, find the sum of all integers in it." $ [1..10]
55
</code>```

Title: Code close to the challenge: Sum of integers

Body:
This is a simple challenge:
Given a sequence of integers, find the sum of all integers in it.

But with a twist.
Your score is the Levenshtein distance between your code and the following phrase (The challenge):

Given a set of integers, find the sum of all integers in it.

You may assume there are no newlines or trailing spaces in the input.

Example input/output:

```<code>Input: 1 5 -6 2 4 5
Output: 11
Input: 1 -2 10
Output: 9
</code>```

An online calculator for Levenshtein distance can be found here: http://planetcalc.com/1721/

Body:
Haskell, distance 11

No comments!

const sum"Given a set of integers, find the sum of all integers in it."

Usage:

> const sum"Given a set of integers, find the sum of all integers in it." $ [1..10]
55