text:
Printing ascending ASCII, Cops
This is the cops' thread. The robbers' thread goes here.
Write a program or function consisting only of printable ASCII characters (that excludes tab and newline) that outputs at least 5 printable ASCII characters in ascending order (from space to tilde / 32 to 126). Characters can be outputted several times, as long as they are adjacent to each other. A single trailing newline is accepted. You must provide the full output, and for every 6 characters in your code you must provide one character in your code, at the position it appears. If your code has 5 or less characters, then you have to reveal only the length. You shall not reveal more than 1 character per 6 in your code.
So if your code alphaprinter outputs the alphabet from a-z, then you need to reveal 2 characters of your code (use underscore for the others), for instance:
al__________  // or
__p__p______  // or
__________er

Rules / specifications:

You cannot append trailing white spaces that doesn't have a function.
You can not use comments (but the robbers can use comments when cracking the code)
Built-in cryptographic primitives (includes any rng, encryption, decryption, and hash) aren't allowed.
In languages where the default output are like in MATLAB: ans =, then that's accepted, as long as it's clearly stated and shown that ans = is outputted. It should also be clearly stated whether this is part of the "ascending output" or not.
The output must be deterministic
Using a non-free language is not accepted
The output doesn't have to be consecutive characters. Both abcde and abcdg are valid outputs.
The characters do not need to be distinct as long as the output contains at least 5 characters. aaaaa and aaacc are valid.
Answers that assumes a REPL environment are not considered to be valid programs or functions and are therefore not allowed.
STDERR is not considered valid output, but data may written to STDERR.

If the revealed characters are underscores, then you must identify it as shown below.
In this case, the second and sixth character are revealed underscores, while the others are unknown.
_____________
 |   |

Note: The robbers only need to find a code that produces the same output. The language, the length of the robbers solution, and the position of the revealed characters must also match.
Your score is the number of characters in your code. The winner will be the submission with the lowest score that hasn't been cracked in 7 days.
Only submissions that are posted in 2015 (UTC) are eligible for the win. Submissions that are posted later than this are welcome, but can not win.
In order to claim the win you need to reveal the full code (after 7 days).
Your post should be formatted like this (nn is the number of characters):

Language, nn characters
Output:
abcdefghijklmnopqrstuvwxyz

Code (12 characters):
al__________

If the code is cracked, insert [Cracked](link to cracker) in the header.
If the submission is safe, insert "Safe" in the header and reveal the full code in your answer. Only answers that have revealed the full code will be eligible for the win.

Does this mean that if my code is print ( "abcde" ), I can reveal three whitespaces?

@Adnan, technically yes, you can.

When somebody makes a seed answer, we might not even know the length of the code.

@wizzwizz4 Seed isn't allowed

@Adnan I suppose it doesn't require any brainpower, only brute-force power.

@wizzwizz4 yes, and RNGs are not allowed

What's the tie breaker for the cops?

@Martin I think it will be number of votes followed by submission date/time if the votes are equal.

I just had the same idea as @Adnan and that seems really unfriendly to the robbers :/

Can I return the text rather than printing it?

@RikerW it's not enough to return the text. See cat's comment on your answer.

I saw it, I just needed verification.  But okay.

Can I stipulate there are no comments in my code?

Hexagony, 8 characters, safe
_______.

prints
123456

You can try Hexagony online
Solution
`&)!."@.

The ` is just misdirection to make the code look like it requires side-length 3. Unless the interpreter is executed with -d the backtick is simply stripped from the source code before determining the layout. Afterwards, the code fits into side-length 2:
 & )
! . "
 @ .

This moves the memory pointer (MP) around one hexagon of the memory grid, while copying the value to the next edge, incrementing it and printing it.
This is what the memory grid looks like, with the MP starting the marked position:

Initially all edges are zero. The first & is a no-op, but ) increments the edge and ! prints the 1. Then " moves back to the left (the edge labelled 2). There, & copies a value. Since the edge is currently zero, the left neighbour (in the direction of the MP) will be copied which is the 1 we just printed. ) increments it, ! prints the 2. This continues as long as we're visiting new edges and we print all digits up to 6. When we hit the edge we started on, & will copy the right neighbour instead (because the edge value is positive), so the edge becomes 0 again, and control flow jumps to the last row, where @ terminates the program.
Try it online.

I got 123456, but it only doesn't stop running and needs to be killed. Is that allowed?

@Adnan I don't think it is. My program terminates.

Perl, 46 characters (safe)
Output:
((()))*++,---../00011123445556667779::;;<<==??@@AAACEFGHHHIKKMMNOOOPPQQQRRSSSVWXXYY[[[\]]]^^^```aaeeffggghjjjnpppqqrttuwxxyzz{{{

Code:
print _______________________________________;

I somehow managed to delete the original in the space of a week, but I think this is right:

 print chr()x(($i=($i*41+7)%97)&3)for(40..123);

Well done. You turned it into a mystery string printer. ಠ_ಠ +1

watch it include some homebrew random number generator :P

I strongly suspect the output is sorted characters from a short list of error messages from eval'ing something.

Brainfuck, 48 characters, cracked by Mitch Schwartz
I made this one for the robbers. It is definitely not going to be the winning submission :)
____[_____[_______]__]___[___________]___[_____]

This outputs:
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Solution:

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

I tested it here.
Hint: Don't try to find programs generated by online generators haha. This was handwritten and can only be solved by logical thinking :)

Cracked.

Noisy 3SP, 89 characters (safe)
0 _____________________________ _ _ _ _ _ _ _ _ _ __2_2__________________________________

Original program:
0 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 3 2 2 2 2 0 3 0 1

This program prints
 !"#$$

(note the leading space), and nothing else!
Explanation (*n refers to the nth cell in memory):
0 0 0                                Increment *0 to 3 (via the 0s in *0, *1, and *2)
2 (32 times)                         Increment *3 to 32 (via the 0 in *2 and the 3 in *0)
                                      (Note that *3 mod 256 is the character that prints)
0                                    Increment *32 (via the 3 in *0 and the 32 in *3)
3                                    Increment *1 (via the 32 in *3 and the 1 in *32)
                                      (Note that printing is on when *1 mod 2 is 1,
                                       which means " " prints right here)
2 (4 times)                          Increment *3 to 36 (printing '!"#$')
0                                    Increment *36 (via *3) (printing "$" again)
3                                    Increment *1 to 2 (via *36) (printing turns off)
0                                    Increment *36 to 2 (via *3)
1                                    Increment *0 to 4 (via *2)

The last two commands turn out to be sufficient to prevent 1 from ever being incremented again on subsequent passes through the program, which means nothing is ever again printed, though it will go on setting all memory addresses from *36 onward to the value 36 forever.

an esolang in which structured programming is impossible and every program has to be written from scratch. 0_0 plus one from me.

Don't be intimidated. It does go on to say This is probably not that language. If you sit down and try to write a program that gives that output, you'll probably get something very similar.

Thanks, but no thanks ^_^ the specs made me lose my mind. It's like brainf*** all over again, except worse,

Looking forward to seeing your program revealed. I can't think of a way to modify my answer so that I get 2's in those places instead of 5's. You've bested me! Cool language :)

Aww...always sad to see someone give up :/

Aaah, nice use of *32 for starting the print. I got too stuck on using the low end registers and setting everything up early. I think it was the fact that our programs were the same length that threw me off. Your program would have been 85 chars if you had terminated it. Congrats on making it safe!

CJam, 13 characters
_____________
  ||

prints
7LLMYahnsuv

You can try CJam online.
Solution
{`__Jf^er$}_~

I thought basing a cop on a generalised quine was pretty clever and novel. The moment I posted this, I realised that __ and er are completely useless, which is why I posted the 8-byte CJam cop for a more competitive score. Pietu cracked that one rather quickly, so I was afraid he'd figure out this one as well. I suppose the unnecessarily convoluted character transliteration saved it.
Anyway, the code takes its own characters (except the _~), XORs each one with 19 for obfuscation and then sorts them.
This cop led me to the "discovery" of xorting, although I'm not actually using it here (and it would probably be near impossible to make use of it with a short generalised quine).

Matlab Octave, 27 characters, safe
Challenge
Regarding the new language restrictions: It also works in Octave.
____________3_3___4_3______

Output (in Octave): (ans = is not part of the output, the first character of the output is ")
ans = """""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq

Output (in Matlab): (ans = \n\n is not part of the output, the output is just the last line)
ans =

"""""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq

Solution

 [fix((0:.07/3:3).^4+34),'']

  We are basically looking at this function, converted to ASCII values.

Could this be the floored y-values of a quintic?

http://meta.codegolf.stackexchange.com/a/7212/8478

@LegionMammal978 I do not understand what you mean, but because you are asking I think it might very well be=)

@MartinBüttner I was not aware of this recent restriction, should perhaps be pointed added to the question.

+1 for It also works in Octave.

JavaScript (ES6), 60 characters, Cracked by user81655
Not promising to win, but hopefully fun to crack:
e_e_______a__a____e___e________e__o___________o______o______

This is a function that returns:
    :ERacddeeeeeeffiinnnoorrrrst
^^^^ -> 4 whitespaces

Edit
user81655 cracked it character by character:

 e=e=>{try{a}catch(e){return[...e.toString()].sort().join``}}

Fortran, 45 characters, safe
Complete Output:
 !"$)0<Ka|

Cat attempted to cracked it here
Code (45 characters):
pr_gr_m____________________/___3____________

Program code:

 program t;print*,(char(i**3/8+33),i=1,9);end

Cracked.

@Cat No, not cracked. Incorrect output: there is no trailing /!

Evidently, I am blind, sorry.

This is quite a challenge. (Well, I don't know Fortran, but it's a fairly easy language to get the hang of)

@cat I'm glad you like it ;-)

A few of the SO answers I've found while trying to crack this were answered by you :)

I give up; I've tried everything from variables to concatenation to a do/end loop. Nice submission!

It's "program" something

@cat I posted the program code...

`$ gfortran test.f
test.f:1:1:
program a;print*,(char(i**3/8+33),i=1,9);end
1
Error: Non-numeric character in statement label at (1)
test.f:1:1:
program a;print*,(char(i**3/8+33),i=1,9);end
1
Error: Unclassifiable statement at (1)
`

It's Fortran 90... You need to call the file test.f90.

I think you should have specified a certain compiler in your post because obviously, the one you used isn't gfortran, the most common one.

I used gfortran! And I specified the Standard (Fortran 95) - you complained about that one ;-)

Why does a two character difference in the filename make it uncompilable? You say in the post Fortran 95+ yet this only compiles with a certain filename?

Because gfortran will interpret *.f files as fixed-format (~FORTRAN 77) code. This is a usual convention, similar to .c/.cpp.

I would like to point out that gfortran --help doesn't mention anything of this sort.

man gfortran does. See the section below -ffree-form and -ffixed-form.

Jolf, 27 characters, Cracked by Adnan
________W___________--_____
                         |

prints
abcdefghijklmnopqrst

Interpreter.
Original code:
on*2toHEWn)oH+H `pl$--$n}_H
on                          set n
  *2t                        to twenty
     oHE                    set H to the empty string
        Wn)                 while(n){
           oH+H             append to H
                `pl$--$n     get the nth character of the alphabet, decrement n before
                        }   }
                         _H print H reversed

Congrats to Adnan! You scare me.

Here, you can test your submission, to see how many characters must be removed.

setInterval(function(){r=document.querySelector("textarea").value;document.getElementById("output").innerHTML=r.length/6-r.split("").filter(function(x){return x=="_"}).length|0},20)
*{font-family:Consolas,monospace}textarea{width:100%;resize:none;height:auto;min-height:1.2em;}b{color:red;}
<textarea>Example Program</textarea>
You must reveal n characters.

http://cdn.meme.am/instances2/500x/3556122.jpg

Cracked

PHP, 46 characters, safe
Source:
for(_______________________=________________);

Outputs a 84 characters long string:
!!"#$%&'()*+,-./0123456789::;<=>?@AABCDEEFGHIIJKLLMNNOPPQRRSTTUUVWWXXYYZZ[[\\]]^^__`

Hint

 What'd you say? My cousine is involved?

Revealed code

 This method is relatively simply as it prints up to 64 characters starting at chr(32). The obscuring part is, that the iterator i is not incremented linearly. It's incremented by it's own cosine value which will result in repeated and missing characters.
for(;$i<64;)echo chr(32+$i+=cos(deg2rad($i)));
for(_______________________=________________);

R, 60 bytes, cracked by plannapus
Output:
0123456789ABCDEFGHTUVWXYZdefghijklmnopqrstuvw

Code:
___(_(_:_____________]_____________6]_______s_4_____,___=___

I think this will not be so hard. We will see.

Cracked

@plannapus Good job! :)

Python 3.4, 127 characters - SAFE
This is my first coppers-post. I think/hope it's not too hard or too obvious.
The obfuscated code:
_______inspect__________________getsource_____________________________________________print__________c*s_______________________

creates this output (there are 5 spaces at the beginning; total length is 7740 characters):
     """"""""""""(((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))**********************...................................................................................................................;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;==============================[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppprrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Edit 25 sept 2021, the answer in Python 3
import inspect;s=sorted(inspect.getsource(inspect.getmodule(inspect.currentframe())));print("".join([c*s.index(c) for c in s]))

Try it online!
The code gets the code itself as a string and then repeaths every i-th character i times. Finally the resulting string is sorted.
Funny thing is thus that all the characters of the solution are in the output! ;-)

You are already safe.

@nrgmsbki4spot1 : thanks for pointing that out. Luckily I found the code I made almost 6 years ago. I updated the answer.

05AB1E, 13 characters, cracked by quintopia
I'm an idiot. I forgot to implement power function (-_-｡). Here is the obfuscated code:
__D____<_____

My original code was:
99DF2}r<F*}bR

Explanation:
99DF2}r<F*}bR

99            # Pushes 99
  D           # Duplicates the top item
   F }        # Creates a for loop: For N in range(0, 99)
    2         # Pushes 2 (this will be done 99 times)
      r       # Reverses the stack
       <      # Decrement on the last item
        F }   # Creates a for loop: For N in range(0, 98)
         *    # Multiplies the last two item of the stack, which now looks like
              # [2, 2, 2, 2, 2, 2, 2, 2, ...]. Basically we're calculating 2^99
           b  # Converts the last item to binary
            R # Reverses the last item of the stack

This will output:
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Yes, that is 99 zeroes followed by a 1.

Note, I have a power function implemented right now. So this could be done in six bytes:
Y99mbR

Is it pronounced like "Osabie"?

@cat Some say "Osabie", others say "Usable", they're all correct haha :)

@Adnan Sorry, you forgot me. I say it like "three hundred seventy-one thousand, four hundred eighty-six" ;)

String times number doesn't work as string repetition. :(

@CᴏɴᴏʀO'Bʀɪᴇɴ Hehehe :) (that's for cases when the string itself is also a number, e.g. "4"3* = 12)

Cracked

Pyth, 17 characters, cracked by Pietu1998
Output:
""''''''''''''''''''''0000000000111111111122222222223333333333XXXXXXXXXX[[[[[[]]]]]]

Code:
___________#____1

My solution:
Sjkm^dT%"'%#X"291

Pietu1998's solution:
S`u]G6*T`t"#X0231

Cracked.

I really like your code. I was thinking about hexadecimal for some time when cracking this, but I didn't know enough about Python's string formatting to get the same code. (Particularly, the # alternate form was new to me.)

MATL, 8 characters, safe
Stable version of the compiler working in Octave hopefully coming soon. Meanwhile, this GitHub commit works, and in particular runs the original code that produces the indicated output
This submission counts as posted on December 28, 2015, 15:30 UTC
Output:
$**0016688??@HHQ

Code (8 characters):
_:______

Solution
6:9tX*Sc

What it does:
6:9          % numeric vector [6 7 8 9]
t            % duplicate
X*           % Kronecker tensor product
S            % sort in ascending order
c            % convert to char. Implicit display

I'm not sure this is legitimate, since MATL seems to require Matlab to be interpreted. (http://meta.codegolf.stackexchange.com/a/7212/8478)

As @MartinBüttner pointed out, this language is ineligible for Cops and Robbers due to the paywall.

@cat I suppose the question is whether the interpreter works in Octave.

@MartinBüttner, I've looked through most of the source code in the compiler and I can't find anything that shouldn't run in Octave, but I may have missed something. I don't have Octave on my laptop. Luis must confirm, but I'm quite sure the interpreter should run in Octave.

I didn't know about that restriction in Cops and Robbers (but it totally makes sense). I haven't tested the compiler in Octave. It may work, but it probably needs some tweaking first. I'll add a disclaimer in my answer saying it's not eligible for winning @MartinBüttner

While I prepare a stable version of the compiler for Octave, this GitHub commit works, where "works" means it compiles and runs all examples I've tried, and in particular runs the original code that produces the output indicated here. Does this qualify now, or is it too late? @MartinBüttner

@LuisMendo well, normally interpreter changes after the challenge are disallowed, but since this doesn't actually affect how the language works, making an exception might be fine. Ultimately, it's Stewie's call. But I think at the very least the deadline for cracking this should be extended.

Yes, it should count as newly posted. What do you think, @StewieGriffin?

@Luis i agree. It can be counted as newly posted. :-)

@StewieGriffin Great! I've updated the answer to include that

Well I guess we're tied for the win now. It's Stewie's call which of your two timestamps counts for the tie breaker, I suppose. ;)

@MartinBüttner Nah, your answer has more votes, and definitely involved more work. That Hexagony language of yours sounds impressive!

@LuisMendo, I'm sorry to say Martin's answer won, based on number of votes. Great answer though =)

@StewieGriffin Thanks! I'd have picked his too :-)

Mathematica 10.1, 98 characters, safe
Output is here. The entire output has 838,316 characters and a trailing newline.
Code:
Print[""<>Chara__________________________________________________________________________________]

Yes, this must be run in 10.1. (hint) The original program:
Print[""<>Characters@ToCamelCase@ExampleData@{"Text","DonQuixoteIEnglish"}~SortBy~ToCharacterCode]

At first I was quizzical as to which ASCII standard contains a hundred thousand codepoints, but now I understand,

Since when is Mathematica free?

@mbomb007 You would have to ask Martin Buettner.

@LegionMammal978 no need to. You can use the Wolfram Cloud.

CJam, 8 bytes, Cracked by Pietu1998
__:_____

prints
%*;a|~

You can try CJam online.

Cracked.

Malbolge, 254 characters, cracked by Adnan
Code:
_____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ __

Output:
`AB\cd`

I kinda cheated by putting a space for every 6th character. Oh well...

Adnan's cracked code:
('&%: ^"!65 4Xzyx w4-Qs rpo'K mlk"' ~Dfdc ba}v< ::8[Z XnVlq }0/mO ,*MbK JH^6# 4`C|0 ?U=Sw uPsaq L4on2 Mjjh, ged)c '<$$p ]!};Y WiVxS eRQ>= ).K]l Ij"Fh gfedc b,=;z L\q%H X3E2C /ng-k N*KJI 8%6#D ~2^Ai >g<<d tUr`6 oJ"!1 /|{CU f)d>b <A_^! \};Yj yUxTS dtsr` ML

The original code:
bCBA@ ?>=<; :9876 54321 0/.-, +*)(' &%$#" !~}|{ zyxwv utsrq ponml kjihg fedcb a`_^] \[ZYX WVUTS RQPON MLKJI HGFED CBA@? >=<;: 9y165 43210 /.-,+ *)('& }C#"! ~wv<z \xwvu tsrqp onmlk jihgf e^$ba `_^W\ UyYXW VUTSR QPONM FKJIH GFEDC BA@9] =<;:9 27654 3210) M:

I cheated again by using a text-to-Malbolge generator for this code.

Cracked

Labyrinth, 5 bytes, Cracked by Adnan
_____

prints
000000

My original code was:
<!!@

Note the trailing space.
I suppose I should have gone for more characters and revealed one of the !, because Adnan's solution only grows linearly when adding more !, while mine grows quadratically.

Cracked

CJam, 12 characters, Cracked by jimmy23013
Output
#$%&'()*+,-./:;<=>?@[\]^_`

Code
_:____#_____

Cracked.

Because I majorly f'ed up my last answer.

Mouse-2002, 23 chars, safe
Code:
________9<^___________

Output:
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab

ES6, 17 characters, cracked by Cᴏɴᴏʀ O'Bʀɪᴇɴ
__=____=_________

This is a function that will return the string
11233

I assume you mean JavaScript?

Cracked?

FYI the original code was (i=106)=>i*i-3+''

PHP, 28 characters
<?=________________________;

Outputs the string
abcdefghijklmnopqrstuvwxyz

You should add that this was cracked.

@LegionMammal978 How would the OP know that if you delete your comment linking to the crack?

@MartinBüttner My crack was a duplicate.

JavaScript, 83 chars, Cracked by Martin Büttner
Output
Hi~~~

Code
_=____r____=u____=__s__=_________=__________________u_______A__________e______"_~_"

Output is in the JS console of a browser like Chrome/Firefox.

Original code (which might be invalid):
q=w=e=r=t=y=u=i=o=p=s=d=f=g=h=j=k=l=z=x=c=v=b=n=m="Huh"[0]+"Alarms in here"[7]+"~~~"

Cracked?

MirBSD Korn Shell, 57 characters, safe
Output:
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Code (57 characters):

___________32____________127_____________________echo$s

Revealed code:

 local -i1 x=32;while((++x<127));do s+=${x:2};done;echo $s

Pyth, 6 characters, cracked by Pietu1998
Code:
S_____

Output:
.0113345678888999

You can try Pyth here

Cracked.

Pyth, 15 characters (safe)
Code:
_CM____________

Output:
"$%'()+-./013456789:;=?BCEFGIKLOPRSTUWXYZ[]^`abcdefghjklmoqsuvxy{|

You can try Pyth online.

I wonder if you can find out the criteria for the characters. :3

Additional hint:

One could have a computers firm like Captor's Fermium totally messed up on just this one puzzle, and still they wouldn't fully solve it. Even the actor Frump Mise couldn't solve it.

Original code

sCMf%sPT3rCN127

Explanation:

rCN127 generates all numbers from 34 (CN = ord('"')) to 127. f%sPT3 finds all the ones that satisfy the following: the sum of the prime factors of n is not divisible by 3. s concatenates the results.

The first hint has the number 3, and it refers to filtering the characters/numbers. The additional hint contains 3 anagrams of prime factor sum.

Octave, 18 bytes:
Output in Octave:
ans =  $'())**+,,--../0011233

Note that ans =_ (replace _ with space) is how Octave prints output by default and is not part of the output string. The output string alone starts with a single leading space like this:
 $'())**+,,--../0011233

Code:
[________:_______]

Disclaimer: If this miraculously should end up being the shortest uncracked submission, I'll award the win to the runner-up. This won't be a winning submission, I just wanted to have some fun too. And I figured a relatively short MATLAB/Octave submission could be fun for others. The other one was too hard for me at least.

Befunge, 11 characters, cracked (in funge-98) by MegaTom
Output:
1223788

Obfuscated code:
________.__

All one line, since the rules prohibit newlines. Tested using http://www.quirkster.com/iano/js/befunge.html .
Edit: This is legally cracked since I didn't specify a version, but note that there's a Befunge-93 solution still out there.

Cracked

JavaScript ES6, 134 characters
Huh boy, that was fun. Good luck!
_=_=_____l____.______.________(___}__;___=______ru____"_____+_[________]______!____]__[_________e________.__U_________)__________\_____

Outputs:
((((((()))))))+...000000000000000000002233=>AAAAAAAAAAABBBBBCCCCCCCCCCCCCCCCCCDDDDDDDEEEEEEEEEEEEEEEEEEEFFFFFFFGHIIIIIIIIIIIIIIIIJJJJLLMMNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOPRRRRRRRSSSSTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUVVVVVVXXY[[[[[[[[]]]]]]]]````ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiinnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu{{{{{{}}}}}}

You are already safe.

Seriously, 7 bytes, Cracked by Martin Büttner
______S

Output:
   deeknnoow

Shouldn't be too difficult, even if the result is not exactly what you'd expect.

Cracked.

Python 3, 58 characters, cracked by Mitch Schwartz
Code:
______________print(_______(_______________________)_____)

    import string;print(''.join(sorted(string.printable))[5:])

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

Cracked.

Cracked.

Oh, wait, Mitch's comment never loaded for me till now... that makes me really sad.

Ruby, 32 characters, safe
Output (with no trailing newline):
!"#$%&'(+,./567;<HKLUVWnouvw

Obfuscated code:
________{|c|___________________}

Revealed code:

 95.times{|c|c&5*c<7&&putc(c+33)}

Explanation:

 Actually pretty straight-forward, just too arbitrary to easily guess or brute-force. For each number c from 0 to 94, bitwise-and c and 5*c. If the result is less than 7, add 33 and output as an ASCII character.

Perl 5, 30 bytes, cracked by Adnan
Code:
print_________________________

Output:
9:;@AFGHLMNRSTYZ_`a

Cracked:
Adnan found a trivial crack: obviously, I didn't think this puzzle through well enough. I've composed another instead.

Python 2, 62 chars, Cracked by Adnan
______________________________________________________________
         | |   ||                  |  |  ||

It kinda looks like a table.
This outputs the string abcde.
Adnan's code:

 print "ab_c_de___".replace("_","")#___________________________

My code:

 f=lamda _,__,___:"abcde"+'f'*sum(_,__,___)*000;print f(1,2,3);

Cracked

I am allowed to use comments, right?

I don't know.  I specifically said when I posted it there were no comments.  I don't know if I can do that though.  I commented on the OP and asked.  We'll see what he says.

You can not use comments (but the robbers can use comments when cracking the code) (CC @Adnan)

Awww. @Rikerw is sad now.

Octave,  22 characters, Safe
Code:
__A____________A___V__

Output:
ans = ABCDFGHHIJLMNNOPRSTTUV

ans = is not part of the output. The output starts with an A.
Real code:

 [(A=66:86)+sin(A),'V']

Explanation:

 In Octave, variable assignments can be done in the same line they are used. So, the variable A is created starting from 66 (corresponds to A in ASCII) to 86 (corresponds to V in ASCII). +sin(A) creates a small sine wave noise. 'V converts the vector to chars and adds a V at the end. The variable name A and the last letter V was of course chosen to throw people of track =)

This one was made for the robbers. Hope it's neither too hard nor too easy. Good luck :-)

Marbelous, 39 characters (safe)
_ is an unknown character: it may or may not be a newline.
* represents a newline character.
__^__________*__<___________@___/_*____

Output:
%,:>?@@BBFFNN^^~~

Code:
@0^5FF
0101FC
\\<ZEE
<</\+S
@0+Z//
25--

Online interpreter. None of the options should be checked.

Unfortunately, the code can only consist of printable ASCII.

OP's comment: This is a valid post, although it says in the challenge that only printable ASCII characters should be used in the code. I confirmed to es1024 that newlines could be used. This will be the only exception to this rule.

@StewieGriffin Do you mean than nobody else can use newlines; only es1024 in this answer is allowed to use them?

Not allowing newlines effectively excludes Marbelous from these challenges. No non-trivial program can be written in mbl without vertical movement of marbles.

@Sparr I don't see how the comments on this answer are agreeing with you. If nobody else can use newlines, then you can't either.

@cat es1024 was told by the author of the question that newlines can be used in this answer. it is unclear whether "this will be the only exception" applies to just this answer, or just to es1024, or just to Marbelous.

Recall, 64 characters
Output:
ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Code:
_D_0__0_M__________0__0___0_________Z___0____0_____________M____

Pretty straightforward in theory. I made a sandbox here, so you can try things. Keep in mind that infinite loops or deep recursion will crash your tab/browser, so keep a copy elsewhere when trying. You can also download recall.min.js from the link in the title and run it with node.js.

PHP, 68 characters, safe
As usual, don't expect anything short from PHP:
______________________________1_________________________________[1_;
 |    |    |           |               |           |    |      |

Outputs this 252 character long string:
AAAAAAAABCCDDEEEEEEEGIIIIIKLMNNOOOOOOOOOPPPPRSSTTTUUUUUXYYZaaaaaaaaaaaaaabbbbccccccccccccdddddddeeeeeeeeeeeeeffffffggghhhhiiiiiiiiiiiklllllllllllllllmmmmmmnnnnnnnnnnooooooooooooooopppppppppppppqrrrrrrrrrrrrrrsssssssssssssssssstttttttttuuuuuuuuuwxyyyzzz

Hint 1

 Sometimes you have to "translate" things.

Hint 2

 Luckily PHP stores all those helpful "translations" for you internally.

Revealed code

 There aren't too many built in functions, that return long strings or arrays with predefined values. One exception is get_html_translation_table. I sorted this array and returned the first character after the & from all escape sequences, e.g. the A from Ä. It has a nice distribution which looks random because the amount of entities related to a letter varies a lot.
$_=get_html_translation_table(1);sort($_);foreach($_ as$_)echo$_[1];
______________________________1_________________________________[1_;
>|    |    |           |               |           |    |      |

Unexpected T_PAAMAYIM_NEKUDOTAYIM?

@cat Hihi. But it might be a different kind of translation. ;)

Milky Way 1.6.1, 24 characters, Safe
Output:
jklmnopqrt

Code (24 characters):
^_"_________________"__!

Solution
^^"pqrjklmno"C=<<<"t"JG!

PHP, 61 characters
Gonna try again, if that's okay :p I wasn't expecting range('a','z') to be particularly well-known, but I should have known better around here ;)
Code:
<?p___________++<_______h__________e______1____p_____________

Outputs:
AAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBCCCCCCCCDDDDDDEEEEEEFFFFFGGGGGHHHHHIIIIJJJJKKKKLLLMMMNNNNOOOPPP

Python 2, 76 characters, Cracked by Adnan
print __________h______________________v_____________,___)_________)_______)

Outputs
BKT]f

Full Code

print "".join([chr(x) for x in list(reversed(range(32,126)[70:5:-9]))[3:8]])

Cracked

05AB1E, 7 characters, cracked by quintopia
Obfuscated code:
___T___

Original code:
576T*uH

576      # Pushes 576
   T     # Pushes 10
    *    # Multiply the last two items of the stack
     u   # To uppercase, this just returns 576 in string format
      H  # Convert from hexadecimal to decimal

Note: I used the uppercase command to convert the int to a string. This however is a bug and has already been fixed.
Output:
22368

Cracked

Seriously, 7 characters, (uncracked and noncompeting)
I was inspired by trying to find an answer to Adnan's latest cop, by how close this number was to their number:
___P___

Output:
22366

 22366 is the 211th triangular number. The original program was 8PτPurΣ but it is disqualified for containing two non-ASCII characters. It simply takes the 8th prime (23), doubles it (46), finds the 46th prime (211), then pushes the 0-211 range (ur) and sums it.

Just to confirm, this code contains only printable ASCII?

No. Guess I missed that requirement. Thought only the output had to be printable ascii. Well I can tell you it consists only of printable CP-437 characters.

Since this doesn't meet the criteria, I suggest you [edit] it to note that it and its robbers are noncompeting.

But I don't want it's robbers to be noncompeting! Can't the robbers get credit for cracking it even when it is not a legal cop?

Marbelous, 19 characters
_1
___0
____
_____1

Outputs
39?E(

"Write a program or function consisting only of printable ASCII characters (that excludes tab and newline)..."

@cat check the comments on the other Marbelous submission

Purple, 31 characters (safe)
__A_____________o______b__1___b

Full program:

a1AbA1iib{bi1b1Bo1aaa1bbab1Bi1b

Output:
abcdefghijklmnopqrstuvwxyz

Explanation:

It's about the shortest way to print the alphabet in Purple.

1.  a1A    Set to 1-"a" == -96
2.  bA1    Set b to -1 (using the fact that a is always negative)
3.  iib{   Set i=i-b, i.e. i+1. This skips over the "{"
4.  bi1    Set b = i-1 (the cell before the current command, containing "{")
5.  b1B    Set b = 1-"{" == -122
6.  o1a    Output 1-a (which will be the current character)
7.  aa1    Subtract 1 from a (i.e. move to the next character)
8.  bba    Set b=b-a. It will be negative until a==-122, when it will be zero
9.  b1B    Set b=1-what b points to. It will be 0 until a==-122, when it will be -96.
10. i1b    Jump to 1-b. This goes to line 2 until a==-122, when it jumps outside
           the program and halts.

Pyth, 6 characters (cracked by isaacg)
Output:
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

Code:
S_____

Let's try a simpler one.

Cracked

Unefunge-98, 16
Output:
&),/258;>ADGJMPSVY\_behknqtwz}

Code:
_#_________3____

Perl 5, 31 bytes, safe
Code:
print__________________________

Output:
$%&&'+,,-1223478899:>??@DEEFJKKLLMPQRRSWXXY]^^_

Code:

print+(chr)x(1.2+cos)for 36..95

JavaScript (ES6), 59 characters
Output:
   """'''(((((())))))+++++++++,,,,,,---------...............123:::===>>>???NNNNNNOOO[[[[[[\\\]]]]]]^^^______````````````aaabbbbbbccccccddeeeeeeeefgggggggggggghhhiiiijjjjjjjjjkkklllllllllnnnnnooooooooorrrssstttttttttu{{{}}}

The first 3 characters in the output are spaces.
Code:
(_____________________________________________.join``_____)

Note: The original version of this produced a much greater variation in characters with the exact same code hint, but I thought the output was unreasonably long so I decided that I'd at least give someone a chance at cracking this. :P Good luck!

You are already safe.

Forth, 29 chars
You're gonna need a very special version of Forth for this one: one that doesn't require newlines after function definitions.
Code
_______ __ _________ ____ ___

(Yes, that's whitespace, and yes, it has to be there or else one gets Error: Unknown word)
Output:
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Note the leading space.

CJam, 9 chars
Code:
'_{___2__

Output:
abcdefghijklmnopqrstuvwxyz

Cracked.

Brainfuck, 51 chars
Code
_____[________________]>.>_____[________]>[_______]

Output:
ABCDEFGHIJKLMNOPQRSTUVWXYZ

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

@Mitch Schwartz wow, it's exactly the same as real code

Python2, 72 chars
Code:
___(___(___(___((_____)_(____)_)______________(______)________________)

Full output (63,769,891 bytes) as compressed by zlib (use import zlib; zlib.decompress(...) to get the actual string, which I recommend writing to a file)

Shouldn't this reveal 12 characters?

@Dennis it absolutely should, I pasted the wrong version (after I added bytes.)

can you provide a run-length-encoded version of the output for easier analysis?

yeah, sure, gimmie a sec

@quintopia here ya go

@cat how many of each digit is there? I assume that one really large number would say, but I'm not sure how to partition it.

@quintopia sorry, here, this might make it clearer

@quintopia did the second link help?

Yes, but I haven't had time to work on it yet.

CLC-INTERCAL 1.-98.-2, 198 bytes, safe.
33 bytes are revealed:
__#3__#9__,1_____________________________3__3__-_3__3__________-_33_D_______&_________-_____________-___D_#4__#28D______________-________B#__-_V________________-_V_______________________________U___

Output is:
!->Ma

Should I post shorter one next time?
Try it online!
Answer
Sorry for irrationally difficult problem.

 DO#3<-#9DO,1<-#3DO,1SUB#3<-#3~#3DO,1SUB'#3~#3'<-#3~#3DO,1SUB#5<-#338DO,1SUB"&'#3~#3'"<-#27DO,1SUB#4<-#27DO#4<-#28DO,1SUB'#4~#4'<-#4DO,1SUB#6<-"V'#V4'"DO,1SUB#8<-'V"V'#V4'"'DO,1SUB#2<-#333DOREADOUT,1

How it works

 DO#3<-#9 changes meaning of the constant.

 DO,1<-#3 lets array to have nine item; note previous statement.

 DO,1SUB#3<-#3~#3 is equivalent to DO,1SUB#9<-#9~#9, which is equivalent to DO,1SUB#9<-#3.

 DO,1SUB'#3~#3'<-#3~#3 does ,1SUB#3<-#3.

 DO,1SUB#5<-#338 is equal to DO,1SUB#5<-#18 when READing OUT; this is how Baudot character set works; it cares for only lower five octets.

 DO,1SUB"&'#3~#3'"<-#27 does ,1SUB#1<-#27.

 DO,1SUB#4<-#27 is obvious, as none of those constants are not overloaded yet.

 DO#4<-#28 now overloads the operand.

 DO,1SUB'#4~#4'<-#4 now does ,1SUB#7<-#28.

 DO,1SUB#6<-"V'#V4'" is actually DO,1SUB#6<-#30.

 DO,1SUB#8<-'V"V'#V4'"' does ,1SUB#8<-#31

 DO,1SUB#2<-#333 does what it says.

 Finally, output is done by DOREADOUT,1.

By the way the reason why an array requires 9 items to output 5 characters is: tail arrays adopt extended Baudot character set. The character set has a concept of "state": uppercase, lowercase, figures, and symbols. When a same value is READ OUT with different state, the different character is READ OUT

CLC-INTERCAL, 38 bytes, safe.
This is much easier than previous.
Six bytes are revealed:
____<-___________<-________DO_________

Outputs:
BCDLX

Try it online!
The answer

 DO;1<-#1DO;1SUB#1<-#17DOREADOUT;1+#460

 Please note output is "B" and "CDLX".

Sorry for having made problems that nobody really cares.


text:
Printing ascending ASCII, Robbers
This is the robbers' thread. The cops' thread goes here.
In the cops thread, the task was to create a program that outputs printable ASCII characters in ascending order. The robbers task is to unscramble the code the cops used to produce this output.
The cracked code doesn't have to be identical, as long as it has the same length and any revealed characters are in the correct positions. The language must also be the same (version numbers can be different). The output must of course be identical. Cops can not use comments in their code, but robbers are free to use them.
The winner of the robbers thread will be the user who has cracked the
most submissions by January 7th 2016. If there's a tie, the user who has cracked submissions with the longest combined code will win.
The submission should be formatted like this:
Language, nn characters (including link to answer), Cop's username
Code:
alphaprinter

Output
abcdefghijklmnopqrstuvwxyz

Optional explanation and comments.
Leaderboard:
A crushing victory by Adnan!
Adnan: 7
Pietu1998: 3
Mitch Schwartz: 2
Quintopia: 2
Martin Büttner: 2
cat: 1
Dennis: 1
insertusernamehere: 1
isaacg: 1
jimmy23013: 1
MegaTom: 1
plannapus: 1
user81655: 1

Python 2, 76 characters, wnnmaw
Code, with obfuscated version below:
print "BKT]f"#__h______________________v_____________,___)_________)_______)
print __________h______________________v_____________,___)_________)_______)

This outputs BKT]f. Not the intended version, that's for sure haha.
Tested here

Sneaky comments :)

That'll teach you to post a program whose output is shorter than the length of the program in a language that has print unless you have revealed characters in exactly the places the string would have to sit.

Brainfuck, 48 bytes, Adnan
++++[>++++[>++++<-]<-]+++[>++++++++<-]>++[>+.<-]

Pretty straightforward, generating 64 and then 26. It might be a little red herring that
++++[>++++[>++++<-]<-]>>+

is a way to get 65, so you might try to do something like
++++[>++++[>++++<-]<-]>>+[>+++++>++<<-----]>>[<.+>-]

before noticing that it's a dead end.

Ahhh, well done :)

CJam, 12 characters, Dennis
":0[Aa#":,:^

It's in the tips...

Right, I had forgotten about the tips...

CJam, 8 characters, Martin Büttner
Code (with blanked code):
{`:)$}_~
__:_____

Output:
%*;a|~

Try it online.
I sort of had a feeling about this from the moment I saw it. And I thought I didn't know CJam...

Labyrinth, 5 characters, Martin Büttner
Code:
!!!>@

Test it here
Output:
000000

JavaScript (ES6), 17 characters, Neil
As the OP posted a function, here's a solution using a function:
()=>xxx=11000+233
__=____=_________

The anonymous function can be invoked like:
(()=>xxx=11000+233)();

A more ridiculous solution I had at first:
xx=yyyy=z=11230+3
__=____=_________

When run in the console, it will print the number 11233.

Ninja'd me. I got fx=asdf=>  "11233"

@CᴏɴᴏʀO'Bʀɪᴇɴ Thought, I had to be fast on this one. :D

Well, kudos to you on your fastest gun in the west. +1

-1 for no strings :P

@BlockCoder1392 Hehe. I refactored my solutions. At first I had xx=yyyy=z="11233" which will literally return "11233" which is not the same as 11233. That's why I took the addition approach. :)

However, +1 for xx=yyyy=z=11230+3

@CᴏɴᴏʀO'Bʀɪᴇɴ's version seems to be the only one that's a function that returns a string.

@Neil I can easily adopt that to be a real string, If you read the comment to BlockCoder you can see, why I changed it. Is it really necessary on PPCG for JavaScript to return an explicit string? If so, I'm happy to change that.

If I didn't think it had to return a string I wouldn't have made my function return a string.

PHP, 28 characters, Niet the Dark Absol
I found several versions for this task:
Original version:
<?=@implode(range('a','z'));

My version:
<?=join('',range('a', 'z'));

23 character version:
<?=join('',range(a,z));

26 character version:
<?=implode('',range(a,z));

Of course, you can just add several whitespaces to get to the 28 character mark.
Tested here

Dang, you beat me :P The shortest I can do: <?=join(range(a,z));

You got me - maybe I should have made it more restrictive by putting one of the letters of a function name as the revealed characters... Anyway, for the record, here's the original: <?=@implode(range('a','z'));

Jolf, 27 characters, Cᴏɴᴏʀ O'Bʀɪᴇɴ
After a few hours of trial and error, I got it haha:
on-pl'u'Wa-n"vwxyz"`--'01_2

Including obfuscated code:
on-pl'u'Wa-n"vwxyz"`--'01_2
________W___________--_____
                         |

Try it here (step run seems to be the only one working with alert)

Explanation
First thing I got stuck on was the placement of the while loop. I didn't seem to get it on the right place haha. After getting it right, the second thing I noticed was the placement of the underscore. I thought I almost got it, until I got stuck on the underscore (gg Cᴏɴᴏʀ O'Bʀɪᴇɴ).
Here is full explanation of the code:
on-pl'u'Wa-n"vwxyz"`--'01_2

o                           # assign
 n                          # n / standard variable
   pl                       # pl = "abcdefghijklmnopqrstuvwxyz"
  -  'u                     # pl - "u" = "abcdefghijklmnopqrstvwxyz"
       'W                   # a string in the middle doing nothing
          -n"vwxyz"         # n - "vwxyz"
         a                  # alert(
                   `        # is an extra semicolon
                     -'01   # "0" - 1
                    -    _2 # ("0" - 1) - negative 2

In pseudocode:
n = minus("abcdefghijklmnopqrstuvwxyz", "u");
"W";
alert(minus(n,"vwxyz"));
;
minus(minus("0", 1), negative(2));

I'm interested to see what the actual solution was :)

holy mother of God not what I intended o______o but nice job, anyhow! I posted the actual code on my answer.

Python 3, 58 bytes, Mathias Ettinger
import string;print(''.join(sorted(string.printable))[5:])

Basic use of string module.

I didn't see that you'd cracked this before me, I tried using string but didn't think of using sorted (because I forget it exists). I don't know if I should leave my crack up, since it's nowhere near the same method but it works.

@cat I don't know what Stewie Griffin's opinion would be about that, but anyway I gave you +1 and think it makes sense to keep your answer up since it's not the same answer as mine.

05AB1E, 13 characters, Adnan
Code (and blanked code):
1TD*<F3<*}bRJ
__D____<_____

Output:
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Explanation:
1                       Push 1
 TD*<                   Push 99
     F   }              For loop
      3<*               multiply top of stack by 3-1 (e.g. double it)
          b             convert to list of binary digits (note we have just computed 2^99)
           R            reverse it
            J           join it into a string.
                        (top of stack implicitly printed)

Woooww!! Amazing job :)

Pyth, 6 bytes, Pietu1998
Ssy>TG

Take the last 10 letters of the alphabet, form all subsets, concatenate, sort.

R, 60 bytes, Fax Machine
Code:
cat(c(0:9,LETTERS[1:8],LETTERS[20:26],letters[4:23]),sep="")

Output:
0123456789ABCDEFGHTUVWXYZdefghijklmnopqrstuvw

Seriously, 7 characters, by quintopia
2'aNsES

Tested here.
Splits 99 bottles of beer around as and sorts the third chunk.

I used the 7th chunk, but the result is the same. Knew this one would be a cinch ;)

JavaScript, 83 characters, BlockCoder1392
a=aaaaraaaa=uaaaa=aasaa=console;b=0;a.log("Hi~~~");auaaaaaaaAaaaaaaaa =aeaaaa="^~^"

A bit too many characters for such a short string.

JavaScript (ES6), 60 characters, insertusernamehere
Code:
e=e=>{try{a}catch(e){return[...e.toString()].sort().join``}}
e_e_______a__a____e___e________e__o___________o______o______

Output (in Chrome):
    :ERacddeeeeeeffiinnnoorrrrst

I knew this immediately because I was about to do the same thing! xD

Nice one - character by character. :D

@insertusernamehere You could have done [...e+''] to make it a bit shorter. That threw me off at the start. ;)

What does return[...e.toString()] actually do? I only know a lil JS...

@cat It just puts each letter of the error message into an array. It needs to do this because sort only works on arrays, not strings.

Pyth, 6 characters, Adnan
Code (with blanked code):
S`.n 3
S_____

Output
.0113345678888999

Try it online.
It's φ's representation, sorted. This could've been done in 5, if you remove the space.

Awww, I forgot about the backticks :p. My original code was S+.n3"

Malbolge, 254 characters, frederick
Obfuscated version:
_____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ __

My version:
('&%: ^"!65 4Xzyx w4-Qs rpo'K mlk"' ~Dfdc ba}v< ::8[Z XnVlq }0/mO ,*MbK JH^6# 4`C|0 ?U=Sw uPsaq L4on2 Mjjh, ged)c '<$$p ]!};Y WiVxS eRQ>= ).K]l Ij"Fh gfedc b,=;z L\q%H X3E2C /ng-k N*KJI 8%6#D ~2^Ai >g<<d tUr`6 oJ"!1 /|{CU f)d>b <A_^! \};Yj yUxTS dtsr` ML

This will output:
`AB\cd`

You can try it here.

This answer is invalid and shouldn't count towards my score (not that I'm anywhere near winning anyways) because I didn't see it had already been cracked.
Python 3, 58 characters, Mathias Ettinger
Code, with original code below:
x=range(95);  print(''.join((chr(i+32) for i in x  )    ))
______________print(_______(_______________________)_____)

Clearly not the intended solution, which was:
import string;print(''.join(sorted(string.printable))[5:])

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

(Note the leading space.)
A fun one to crack: it took me a while to figure how to get the genexpr to work properly. :)

Befunge, 11 characters, histocrat
Code:
89'**'z...@

Output:
1223788

That was fun. This is an alternate solution I also found:
8]..@#37.z'

Oh, cool, funge-98 solutions.

05AB1E, 7 characters Adnan
Code and blanked code:
576T*uH
___T___

Output:
22368

Explanation:
576       Push this number.
   T      Push ten.
    *     Multiply. (5760)
     u    Convert to string.
      H   Interpret as a hex number and push decimal (22368) (implicit output).

I almost positive this wasn't the original program, but thanks to Adnan for providing the one bit of information that made it possible (the u command).

I think this was the original program haha. Well done :)

Pyth, 17 characters, Luke
Code (with blanked code):
S`u]G6*T`t"#X0231
___________#____1

Output:
""''''''''''''''''''''0000000000111111111122222222223333333333XXXXXXXXXX[[[[[[]]]]]]

Try it online.
This was fun. I got it to 18 bytes multiple times using # as the filter operator, but then I figured out I could just discard it from the string. If you remove the t and the # the result would probably be the shortest Pyth code for that output.
Basically:

"#X0231 makes the string #X0231
t"#X0231 removes the #: X0231
`t"#X0231 gets the string representation: 'X0231'
*T`t"#X0231 multiplies it by 10: 'X0231''X0231''X0231'…
u]G6*T`t"#X0231 wraps it in an array 6 times
`u]G6*T`t"#X0231 gets the string representation: [[[[[['X0231'…'X0231']]]]]]
S`u]G6*T`t"#X0231 sorts it to get the output

Very nice! And pretty different from what I had done.

CJam, 9 characters, by username.ak
'a{_)}25*

Try it online!
How it works
'a         e# Push the character 'a'.
  {  }25*  e# Do 25 times.
   _       e# Copy the character on the stack.
    )      e# Increment the copy.

Perl 5, 30 characters, msh210
Obfuscated + my version:
print_________________________
print "9:;\@AFGHLMNRSTYZ_`a"

This will output:
9:;@AFGHLMNRSTYZ_`a

Tested here

Python 2, 62 characters, RikerW
Obfuscated version:
______________________________________________________________
         | |   ||                  |  |  ||

My version:
print "ab_c_de___".replace("_","")#___________________________

This simply removes all the underscores and outputs abcde.
Tried it here

source: Stack Exchange

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

sort: votes


text:
Co-primality and the number pi
Introduction
Number theory is full of wonders, in the form of unexpected connections. Here's one of them.
Two integers are co-prime if they have no factors in common other than 1. Given a number \$N\$, consider all integers from 1 to \$N\$. Draw two such integers at random (all integers have the same probability of being selected at each draw; draws are independent and with replacement). Let \$p\$ denote the probability that the two selected integers are co-prime. Then \$p\$ tends to \${6} / {\pi^2} \approx 0.6079...\$ as \$N\$ tends to infinity.
The challenge
The purpose of this challenge is to compute \$p\$ as a function of \$N\$.
As an example, consider \$N = 4\$. There are 16 possible pairs obtained from the integers 1,2,3,4. 11 of those pairs are co-prime, namely \$(1,1)\$, \$(1,2)\$, \$(1,3)\$, \$(1,4)\$, \$(2,1)\$, \$(3,1)\$, \$(4,1)\$, \$(2,3)\$, \$(3,2)\$, \$(3,4)\$, \$(4,3)\$. Thus \$p = {11} / {16} = 0.6875\$ for \$N = 4\$.
The exact value of \$p\$ needs to be computed with at least \$4\$ decimals. This implies that the computation has to be deterministic (as opposed to Monte Carlo). But it need not be a direct enumeration of all pairs as above; any method can be used.
Function arguments or stdin/stdout may be used. If displaying the output, trailing zeros may be omitted. So for example \$0.6300\$ can be displayed as 0.63. It should be displayed as a decimal number, not as a fraction (displaying the string 63/100 is not allowed).
Winning criterion is fewest bytes. There are no restrictions on the use of built-in functions.
Test cases
Input / output (only four decimals are mandatory, as indicated above):
1    / 1.000000000000000
2    / 0.750000000000000
4    / 0.687500000000000
10   / 0.630000000000000
100  / 0.608700000000000
1000 / 0.608383000000000

Are there any bounds on the range of inputs?

@EricTowers The program should work for any reasonable size up to limitations of memory and data type. At least 1000

Are rational numbers as return values (not strings) allowed? My language has a native rational type, in which 63/100 is a valid literal, usable in computation. (Langs I'm talking about: Factor, Racket)

@cat Sure, go ahead! Take into account the required precision, though

Jelly, 12 8 bytes
RÆṪSḤ’÷²

Try it online!
The following binary code works with this version of the Jelly interpreter.
0000000: 52 91 b0 53 aa b7 9a 8a  R..S....

Idea
Clearly, the number of pairs (j, k) such that j ≤ k and j and k are co-prime equals the number of pairs (k, j) that satisfy the same conditions. Also, if j = k, j = 1 = k.
Thus, to count the number of co-prime pairs with coordinates between 1 and n, it suffices to calculate the amount m of pairs (j, k) such that j ≤ k, then compute 2m - 1.
Finally, since Euler's totient function φ(k) yields the number integers between between 1 and k that are co-prime to k, we can calculate m as φ(1) + … + φ(n).
Code
RÆṪSḤ’÷²    Input: n

R           Yield [1, ..., n].
 ÆṪ         Apply Euler's totient function to each k in [1, ..., n].
   S        Compute the sum of all results.
    Ḥ       Multiply the result by 2.
     ’      Subtract 1.
      ÷²    Divide the result by n².

Oh, Jelly includes the totient function!? Nice idea!

Countdown until MATL includes a totient command at T-1 day...

@quintopia (I finally included the totient function) :-D

Mathematica 43  42 bytes
I found Lattice points visible from the origin, from which the picture below is taken, to be helpful in reframing the problem through the following questions regarding a given square region of the unit lattice:

What fraction of the unit-lattice points have co-prime coordinates?
What fraction of unit-lattice points can be seen from the origin?

N@Mean[Mean/@Boole@Array[CoprimeQ,{#,#}]]&

Examples
Trailing zeros are omitted.
N@Mean[Mean/@Boole@Array[CoprimeQ,{#,#}]]&/@Range@10

{1., 0.75, 0.777778, 0.6875, 0.76, 0.638889, 0.714286, 0.671875,
  0.679012, 0.63}

Timing
The timing, in seconds, precedes the answer.
N@Mean[Mean/@Boole@Array[CoprimeQ,{#,#}]]&[1000]// AbsoluteTiming

{0.605571, 0.608383}

Pyth - 13 11 bytes
.OqR1iM^SQ2

Test Suite.

Mathematica, 42 32 bytes
Count[GCD~Array~{#,#},1,2]/#^2.&

Anonymous function, uses simple brute force. The last case runs in about .37 seconds on my machine. Explanation:
                               &   A function taking N and returning
Count[               , , ]           the number of
                      1               ones
                                     in the
                        2             second
                                     level of
         ~Array~                      a matrix of
      GCD                              the greatest common denominators of
                {#,#}                 all 2-tuples in [1..N]
                          /         divided by
                           #          N
                            ^2.      squared.

Can you post an example run and explanation, for those of us who don't have Mathematica?

This unites our submissions:  Count[Array[GCD,{#, #}],1,2]/#^2.&   Be my  guest.

Dyalog APL, 15 bytes
(+/÷⍴)∘∊1=⍳∘.∨⍳

Pretty straightforward. It's a monadic function train. Iota is the numbers from 1 to input, so we take the outer product by gcd, then count the proportion of ones.

Octave, 49 47 bytes
Just calculating the gcd of all pairs and counting.
@(n)mean(mean(gcd(c=kron(ones(n,1),1:n),c')<2))

The kronecker product is awesome.

kron! Good idea!

I first used meshgrid, but then I noticed I could do the same with kron inline! (->anonymous function)

Sage, 55 bytes
lambda a:n((sum(map(euler_phi,range(1,a+1)))*2-1)/a**2)

Thanks to Sage computing everything symbolically, machine epsilon and floating-point issues don't crop up. The tradeoff is, in order to follow the output format rule, an additional call to n() (the decimal approximation function) is needed.
Try it online

Very nice! You seem to be using Sage quite often lately :-)

@LuisMendo Sage is great and does all things. It's very nice to use on math-based challenges because it has a huge builtin library like Mathematica, but the syntax is better (by virtue of a) not being Mathematica, and b) being built on Python).

05AB1E, 8 bytes
LÕO·<sn/

Try it online!
Explanation:
L         Push inclusive range of (implicit) input (4 -> [1, 2, 3, 4])
 Õ        Perform Euler's Totient on each element ([1, 2, 3, 4] -> [1, 1, 2, 2])
  O       Sum list elements ([1, 1, 2, 2] -> 6)
   ·<     Double result and subtract 1 (2*6 - 1 = 11)
     sn   Square input (4 -> 16)
       /  Divide sum by input squared (11 / 16 = 0.6875)
          (Implicit output)

It might be golf-able, I just copied Dennis' Jelly method,
and I haven't really bothered trying to make it any smaller.

MATL, 20 17 bytes
This uses current version (5.0.0) of the language.
Approach based on @flawr's answer.
i:tg!X*t!Zd1=Y)Ym

Edit (April 28, 2015): Try it online! After this answer was posted, function Y) was renamed to  X:; the link includes that change.
Example
>> matl i:tg!X*t!Zd1=Y)Ym
> 100
0.6087

Explanation
i:         % vector 1, 2, ... up to input number
tg!        % copy, convert into ones, transpose
X*         % Kronecker product. Produces a matrix
t!         % copy, transpose
Zd         % gcd of all pairs
1=         % is it equal to 1?
Y)         % linearize into column array
Ym         % compute mean

Old answer: 20 bytes
Oi:t"t@Zd1=sb+w]n2^/

Explanation
O             % produce literal 0. Initiallizes count of co-prime pairs.
i             % input number, say N
:             % create vector 1, 2, ... N
t             % duplicate of vector
"             % for loop
    t         % duplicate of vector
    @         % loop variable: each element from vector
    Zd        % gcd of vector and loop variable. Produces a vector
    1=s       % number of "1" in result. Each "1" indicates co-primality
    b+w       % accumulate into count of co-prime pairs
]             % end
n2^/          % divide by N^2

Couldnt you be even shorter with an approach like the one I used in octave?

Indeed! Thank you! 3 bytes less. You should have done it yourself in MATL :-)

I would have tried if it wasn't way past my bedtime=)

JavaScript (ES6), 88 bytes
n=>eval(`p=0;for(i=n;i;i--)for(j=n;j;j--,p+=a)for(a=1,k=j;k>1;k--)a=i%k||j%k?a:0;p/n/n`)

Explanation
n=>
  eval(`                     // use eval to enable for loop without {} or return
    p=0;                     // p = number of pairs
    for(i=n;i;i--)           // i = 1 to n
      for(j=n;j;j--,p+=a)    // j = i to n, a will equal 1 if i and j are coprime, else 0
        for(a=1,k=j;k>1;k--) // for each number from 0 to j
          a=i%k||j%k?a:0;    // if i%k and j%k are both 0, this pair is not coprime
    p/n/n                    // return result (equivalent to p/(n*n))
  `)

Test
Takes a while for large (>100) values of n.

var solution = n=>eval(`p=0;for(i=n;i;i--)for(j=n;j;j--,p+=a)for(a=1,k=j;k>1;k--)a=i%k||j%k?a:0;p/n/n`)
N = <input type="text" id="input" value="100" />
<button onclick="result.textContent=solution(+input.value)">Go</button>

Seriously, 15 bytes
,;ª)u1x`▒`MΣτD/

Hex Dump:
2c3ba62975317860b1604de4e7442f

Try It Online
I'm not going to bother explaining it since it literally uses exactly the same algorithm as Dennis's Jelly solution (although I derived it independently).

Mathematica, 35 bytes
Implements @Dennis's algorithm.
(2`4Plus@@EulerPhi@Range[#]-1)/#^2&

Compute the sum of the totient (Euler's phi function) over the range from 1 to the input value.  Multiply by floating point two (with four digits of precision) and subtract one.  (More precision can be retained by using instead "2" and "1`4".)  This is the total number of coprime pairs, so divide by the square of the input to get the desired fraction.  Because the two is an approximate number, so is the result.
Testing (with timing data in the left column since at least one of us thinks that's interesting), with the function assigned to f so that the test line is more easily read.:
f=(2`4Plus@@EulerPhi@Range[#]-1)/#^2&
RepeatedTiming[f[#]] & /@ {1, 2, 4, 10, 100, 1000}
(* {{5.71*10^-6, 1.000},
    {5.98*10^-6, 0.750},
    {0.000010  , 0.6875},
    {0.0000235 , 0.6300},
    {0.00028   , 0.6087},
    {0.0033    , 0.6084} }  *)

Edit:  Showing extent of the range of inputs (swapping the precision to the one instead of the two because otherwise the results get rather monotonous) and challenging others to do the same...
f = (2 Plus @@ EulerPhi@Range[#] - 1`4)/#^2 &
{#}~Join~RepeatedTiming[f[#]] & /@ {1, 2, 4, 10, 100, 1000, 10^4, 10^5, 10^6, 10^7}
(*  Results are {input, wall time, output}
    {{       1,  5.3*10^-6, 1.000},
     {       2,  6.0*10^-6, 0.7500},
     {       4,  0.0000102, 0.68750},
     {      10,  0.000023 , 0.63000},
     {     100,  0.00028  , 0.6087000},
     {    1000,  0.0035   , 0.608383000},
     {   10000,  0.040    , 0.60794971000},
     {  100000,  0.438    , 0.6079301507000},
     { 1000000,  4.811    , 0.607927104783000},
     {10000000, 64.0      , 0.60792712854483000}}  *)

RepeatedTiming[] performs the calculation multiple times and takes an average of the times, attempting to ignore cold caches and other effects causing timing outliers.  The asymptotic limit is
N[6/Pi^2,30]
(*  0.607927101854026628663276779258  *)

so for arguments >10^4, we can just return "0.6079" and meet the specified precision and accuracy requirements.

Samau, 12 bytes
Disclaimer: Not competing because I updated the language after the question was posted.
▌;\φΣ2*($2^/

Hex dump (Samau uses CP737 encoding):
dd 3b 5c ad 91 32 2a 28 24 32 5e 2f

Using the same algorithm as Dennis's answer in Jelly.

J, 19 17 bytes
*:%~1-~5+/@p:|@i:

Usage:
   (*:%~1-~5+/@p:|@i:) 4
0.6875

Explanation:
*:%~1-~5+/@p:|@i:
               i: [-n..n]
             |@   absolute value of each element ([n..1,0,1,..n])
       5+/@p:     sum of the totient function for each element
    1-~           decreased by one, giving the number of co-prime pairs
*:%~              divided by N^2

Dennis' solution gives a nice explanation how can we use the totient function.
Try it online here.

Julia, 95 bytes
n->(c=combinations([1:n;1:n],2);((L=length)(collect(filter(x->gcd(x...)<2,c)))÷2+1)/L(∪(c)))

Just the straightforward approach for now; I'll look into shorter/more elegant solutions soon. This is an anonymous function that accepts an integer and returns a float. To call it, assign it to a variable.
Ungolfed:
function f(n::Integer)
    # Get all pairs of the integers from 1 to n
    c = combinations([1:n; 1:n], 2)

    # Get the coprime pairs
    p = filter(x -> gcd(x...) == 1, c)

    # Compute the probability
    return (length(collect(p)) ÷ 2 + 1) / length(unique(c))
end

Far as I can tell, you don't need to collect a lazy object to take its length.

@cat You do for some where length doesn't have a method defined, which is the case here for the filtered combinations iterator. Similarly endof wouldn't work because there's no method for that type to getindex.

But the language disagrees.

@cat range doesn't return the same kind of object as combinations. The latter returns an iterator over combinations which is a separate type with no defined length method. See here. (Also the : syntax is preferred over range for constructing ranges ;))

PARI/GP, 25 bytes
Making the function anonymous would save a byte, but then I'd have to use self making it more expensive overall.
f(n)=n^2-sum(j=2,n,f(n\j))

Python2/Pypy, 178 bytes
The x file:
N={1:set([1])}
n=0
c=1.0
e=input()
while n<e:
 n+=1
 for d in N[n]:
  m=n+d
  try:N[m].add(d)
  except:N[m]=set([d,m])
 for m in range(1,n):
  if N[m]&N[n]==N[1]:c+=2
print c/n/n

Running:
$ pypy x <<<1
1.0
$ pypy x <<<10
0.63
$ pypy x <<<100
0.6087
$ pypy x <<<1000
0.608383

The code counts the co-prime pairs (n,m) for m<n twice (c+=2). This ignores (i,i) for i=1..n which is ok except for (1,1), thus being corrected by initialising the counter with 1 (1.0 to prepare for float division later) to compensate.

Factor, 120 113 bytes
I've spent class golfing this and I can't get it shorter.
Translation of: Julia.
[ [a,b] dup append 2 <combinations> [ members ] keep [ first2 coprime? ] filter [ length ] bi@ 2 /i 1 + swap /f ]

Example runs on the first 5 test cases (a value of 1000 causes it to freeze the editor, and I can't be bothered to compile an executable right now):
! with floating point division
IN: scratchpad auto-use {
      1
      2
      4
      10
      100
    }
    [
      [1,b] dup append 2 <combinations> [ members ] keep
      [ first2 coprime? ] filter [ length ] bi@ 2 /i 1 + swap /f
    ]
    map

--- Data stack:
{ 1.0 0.75 0.6875 0.63 0.6087 }
! with rational division
IN: scratchpad auto-use {
      1
      2
      4
      10
      100
    }
    [
      [1,b] dup append 2 <combinations> [ members ] keep
      [ first2 coprime? ] filter [ length ] bi@ 2 /i 1 + swap /
    ]
    map

--- Data stack:
{ 1.0 0.75 0.6875 0.63 0.6087 }
{ 1 3/4 11/16 63/100 6087/10000 }

Add an example run maybe?

@LuisMendo done!

Whispers v2, 75 bytes
> 1
> Input
>> φ(L)
>> ∑ 1 2 3
>> 4+4
>> ≺5
>> 2²
>> 6÷7
>> Output 8

Try it online!
How it works
Implements Dennis's algorithm.
We calculate \$m = \sum_{k=1}^n\phi(k)\$. We then double \$m\$ and decrement it to get \$2m-1\$, before squaring \$n\$ and dividing by it, to output \$\frac{2m-1}{n^2}\$

R, 78 bytes
mean(mapply(function(x,y)sum(!x%%which(!y%%1:y))<2,1:(N=scan()),rep(1:N,e=N)))

Try it online!
Uses which(!y%%1:y) to calculate divisors of y (including 1), and !x%%divisors_of_y to count common divisors of x and y (including 1), so sum(common_divisors)<2 is TRUE for co-prime pairs.
The R mapply function applies a custom function to two (or more) sets of arguments, here specified as 1:N and rep(1:N,each=N) (which repeats each number in 1:N, N times).
Conveniently, R 'recycles' the shorter argument list to the length of the longer one, so 1:N gets repeated for us automaticaly.

That recycling feature is nice for golfing

You can save 3 bytes by replacing the end with N<-scan():1,rep(N,e=N).

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

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


text:
Print the QWERTY keyboard using keys that are as close together as possible

Normally, challenges are scored in bytes, or sometimes Levenshtein distance, but for this one we're using keyboard distance -- the number of keys between the keys used to type the program (use the above keyboard as the definitive reference). For example, the distance between A and F is 3, because the path is A=>S=>D=>F. The distance between N and 5 is 4, because no matter what path you take, it requires at least 4 steps. Your task is to output the following (not including trailing spaces), with as small a keyboard distance as possible:
Q W E R T Y U I O P
 A S D F G H J K L
  Z X C V B N M

Wrapping:
To make your life easier, certain keys can wrap around the keyboard. Left Shift wraps to Right Shift, Caps Lock wraps to Enter, Tab wraps to \ and ~ wraps to Backspace. For example, the distance between Q and P is 5, because Q=>Tab=>\=>]=>[=>P.
Note: Wrapping only works horizontally -- you can not step from, say, \ to Caps Lock
Scoring:
Score = Keyboard distance + byte count
Example Calculation:
print(5);

p=>r == 6
r=>i == 4
i=>n == 2
n=>t == 3
t=>( == 4
(=>5 == 4
5=>) == 5
)=>; == 2

Total: 30 + 9 = 39.
Notes:

Lowercase and uppercase letters count as the same key. If a key has two symbols on it (like 7 and &), they also count as the same key, no need to include pushing shift.
Unfortunately, if your code requires symbols that are not on the keyboard you cannot use it.
On the keyboard image, the top row can be ignored. The only key you can use on the bottom row is Space
Keys must be inputted in order, you can't use the arrow keys to move the caret and then input a key.

Score Calculator:

Updated on 12/27 to fix `=>] and related miscalculations. Check your scores again, and they will likely be smaller (hopefully not bigger!)

Paste in your code here to calculate the score. Let me know if you ever get an error or it prints out the wrong number.

var keys = ["~1234567890-=←","\tqwertyuiop[]\\","↑asdfghjkl;\'\n","Lzxcvbnm,./R",
"AB      CDEF"];
var con =["`!@#$%^&*()_+{}|:\"<>?","~1234567890-=[]\\;\',./"];
function hexagon(k) {
  if(k === " ") return ["x","c","v","b","n","m",","];
  var p = pos(k);
  if(p === -1) return false;
  var row = p[0],col = p[1];
  var hexagon = [char(row,col-1,1),char(row-1,col),char(row-1,col+1),char(row,col+1,1),char(row+1,col),char(row+1,col-1)];
  return hexagon;
}

function char(r,c,wrap) {
  if(r < 0 || r >= keys.length) return "";
  if(r === keys.length-1 && 1 < c && c < 8) return " ";
  if(wrap) {
    if(c === -1) c = keys[r].length-1;
    if(c === keys[r].length) c = 0;
  }
  return keys[r].charAt(c);
}

function pos(c) {
    var row = -1, col = -1;
  for(var i = 0;i<keys.length;i++) {
    col = keys[i].indexOf(c)
    if( col != -1) { row = i; break;}
  }
  if(row === -1) return -1;
  return [row,col];
}

function dist(a,b,s,w) {
  if(typeof a === "object") {
    var list = [];
    for(var i = 0;i<a.length;i++) {
      list[i] = dist(a[i],b,s,w);
    }
    return list;
  }

 if(a==="") return Infinity;
  if(a===b) return 0;

  var p = pos(a);
  var q = pos(b);

  if(!w && a!==" ") {
    var chars = keys[p[0]].length;
    var opp = char(p[0],p[1] < chars/2 ? chars-1 : 0);
    return Math.min(dist(a,b,s,true),dist(a,opp,s,true)+dist(opp,b,s,true));
  }

   if(!s) { return Math.min(dist(a,b,true,w),dist(a," ",true,w)+dist(" ",b,true,w));}

   var h = hexagon(a);
  if(a === " ") return 1 + Math.min(...dist(h,b,true,w));
 if(p[0]<q[0]) {
  return 1 + Math.min(dist(h[4],b,s,w),dist(h[5],b,s,w));
  }
  else if(p[0] > q[0]) {
  return 1 + Math.min(dist(h[1],b,s,w),dist(h[2],b,s,w));
    }
   if(b===" ") return Math.min(Math.abs(p[1]-7),Math.abs(2 - p[1]));
    var d = Math.abs(p[1]-q[1]);
    return Math.min(d,keys[p[0]].length-d);

}

function getTotalDistance(str) {
 for(var i = 0;i<con[0].length;i++)
   str = str.replace(new RegExp("\\"+con[0].charAt(i),"g"),con[1].charAt(i));
  str = str.toLowerCase();
  var total = 0;
  for(var i = 0;i<str.length-1;i++) {
   total += dist(str[i],str[i+1]);
  }
  return total;
}
enter.onclick = function() {
 var a = getTotalDistance(program.value);
 var b = program.value.length;
 len.textContent = a;
 count.textContent = b;
 total.textContent = a+b;
};
<textarea rows=15 cols=40 id="program"></textarea>
<input type="submit" id="enter"/>

Key distance:

Byte count:

Total:

Related:

The very weird word counter
Output the qwerty keyboard
DISARM THE B.O.M.B.!

we should make another challenge: shortest code to score answers like this. I think the scoring method is more interesting than the question.

Also, please for the love of god use === unless for some reason you want JS to sneakily coerce your types and suck up performance.

Any submission in Unary/Lenguage will have a score of 0.

@Dennis Is it possible to answer this in those languages? I can put a cap on the max program length.

Sure it is. I've done it in a few related challenges.

@Cyoce Yes, i was thinking about another challenge for the scoring. Also, just looked at the SO post with 3,700 score relating to what you mentioned.

And for the scoring, how about a minimum score of 1 per character? That should make unary et al. not nearly as viable.

@Cyoce sounds good.

The snippet says \]from my answer is 3 keys away, but according to the picture it can be done in 2 with`->->]`.

Are trailing spaces allowed?

@Pietu Theyre allowed as long as the output appears the same

@user81655 Fixed.

I think it's really not cool to change the rules to eliminate a very smart answer because you didn't like that answer.

@djechlin That's not what happened. We were talking about changing the rule from the very beginning, even before the answer was posted.

idk I think it's really not in the spirit of things to eliminate a creative, valid language on the ground that it... works? does the thing the language is good at? This doesn't seem any different from eliminate CJam or Pyth because their answers are just a bit too short or eliminating Retina for text-matching questions, and yeah it struck me as weird that the top answer became invalid sometime after being posted despite nailing the challenge. I really enjoy sharing answers like this when the language is really shown off.

@djechlin i told him right away the rule would change, and he was ok with with it. Maybe he didnt change the score for a while.

I understand that, I still don't think you should add on rules explicitly designed to make clever solutions invalid.

Pyth, score 107 106 102
:jd"QWERTYUIOP
ASDFGHJKL
]XCVBNM""]"" Z

Try it online.

Your score has gone down by 2!

Cngrt vry gd job.

Unary, score ~6.1*10618
6103247739090735580402225797524292167653462388595033897325606983093527722629493568418069722646005695215642120674994001348606253869287599178270707482456199630901069511698694317195626565008736452130034232375778047932461822258369348260249011643486476832847755830117284465136723525376668555270734061914837886192012601522703308221225195058283657800958507281265116257152529161080096092081620384043514820427911786442536988705847468796481108000358361636640985892696216392434604543586511103835032034494033598102606339253132146827455065586119645920456668064941286708686113567081095434338440184737976711767750474398662381256908308 zeros
Not the most "creative" solution but it took my computer ~3 minutes to convert the base 2 representation of this to base 10

This used to have a score of 0, but the scoring rules changed.
Code Length: ~6.1*10618
Key Distance: 0

Lol, i dont get how this works, but this is going to be invalid soon.

@geokavel aww :( but not invalid, it would just have a very high score

Yes, ill give you an upvote.

3 minutes? You need a better converter. :P

I think this is valid? how is it not valid?

Sorry to rain on your parade (I really like this answer), but look at the scoring section.

I scrolled to the end of your code block.  I thought the code was 61032477390907355804...., not 61032477390907355804... zeros.  :P

JavaScript (ES6), score 188
alert([...`QWERTYUIOP
ASDFGHJKL
`," Z",..."XCVBNM"].join` `)

Only just barely gets a better score than alerting the output string but it's the best approach I could find... : /
Bytes: 60
Key Distance: 128

I tried a modified version of this apporach: alert(`QWERTYUIOP<br>ASDFGHJKL<br> ZXCVBNM`.match(/\n| ?./g).join` `) While this works, it's 65 bytes (score 231).

Your score is 1 point smaller now..

Japt, score 123 119 118 116 106
42 41 40 bytes + 81 78 77 75 66 distance
"QWERTYUIOP
ASDFGHJKL
'ZXCVBNM"q qS r''"

(proper output in the "output" box)

Your score stays the same.

@geo already recalced :)

@geo Btw, you can edit the scores right away.

Nice again! You could do "QWERTYUIOP
ASDFGHJKL
ZXCVBNM"¬¸r'Z" Z (
 represents a line break), but that requires two non-keyboard chars, so I guess it isn't legal. But at least you can remove the comma, as it is automatically inserted.

@Eth Great, thanks! As for the line break, don't think I'm a noob in html ;D

@Eth Look, the shortest there now :)

Woah, awesome! Nice job optimizing for score rather than byte count. :)

Bash + Sed, 151
sed 'sb *.b& bg'<<<'QWERTYUIOP
 ASDFGHJKL
  ZXCVBNM'

Congrats, your score is 1 point lower with the new counting fix.

@geokavel Thanks - fixed.

Python, 157, 156, 211, 221 points
Key Distance: 157
Bytes: 64
Ergo, total score is 221.
l=' '.join('QWERTYUIOP\nASDFGHJKL\nZXCVBNM')
print l[:42],l[42:]

Prints the string but has to add an extra space. :(  now longer.
Why @Pietu, why did you do this to me?

Your score is 1 lower now.

Ooh, cool.  Thanks @geokavel.  What changed in the rules?

Not rules, there was a bug in the calculator

This prints one too many spaces in the start of the third line.

You have crushed my hopes with your true words.  But thanks for pointing that out.

JavaScript, score 156 187
[...`QWERTYUIOP
ASDFGHJKL`].join` `+`
  Z X C V B N M`

Not bad for JavaScript
Try it online

With alert, score 186

alert([...`QWERTYUIOP
ASDFGHJKL`].join` `+`
  Z X C V B N M`)

But it doesn't print the string, no?

@nicael I can claim I'm using this environment which has implicit printing/output.

Score is 1 lower now.

@geokavel thanks fixed

Inventing your own environment to get around output, hmm? Anyways, it's possible to to shorten this by a byte.

Oops, I guess that's 2 points more... Huh :/ Nice job minimizing the score!

Bash + sed, score 202 200
sed 's/\([^ ]\)/\1 /g'<<F
QWERTYUIOP
 ASDFGHJKL
  ZXCVBNM
F

Your score went down by 2!

@geokavel, thanks, and it's fixed now.

Jolf, 118 + 51 = 169
Try it here! (underscores in explanation used to denote a used space)
R m{"QWERTYUIOP'ASDFGHJKL'ZXCVBNM"#DN+*S' RH' }"\n"
 _m                                                 map
   {"QWERTYUIOP'ASDFGHJKL'ZXCVBNM"#                  that array
                                   DN         }      with this function
                                     +*S'_            that concats (index many) spaces
                                          RH'_         with the inner array joined by spaces
R                                                    and join that
                                                      "\n"  with newlines

Jolf, update post-question, 76 + 21 = 97
Try it here! Again, I don't often update my code until relevant. Still fun.
R mpHDN+*S' RH' }"\n"
 _m                   map
   pH                 the keyboard array [["Q","W",...,"P"],["A",...,"L"],["Z",...,"M"]]
     DN         }      with this function
       +*S'_            that concats (index many) spaces
            RH'_         with the inner array joined by spaces
R                     and join that
                 "\n"  with newlines

Python, score 185
print" ".join("QWERTYUIOP\nASDFGHJKL\n")+"  Z X C V B N M"