[Question]
  [
**This is the companion thread to the main [Unscramble the Source Code](https://codegolf.stackexchange.com/q/40932/2867) challenge.** If you think you have managed to unscramble one of the cop answers, you should post your solution as the answer to this thread.
As a reminder, you have one attempt at cracking each submission. Your cracking attempt will be an unscrambled version of the source code. If your guess matches the description (same characters, output, and of course language), and you are the first correct guess, then you win a point. It is important to note that your program does not have to exactly match the original, simply use the same characters and have the same functionality. This means there could be more than one correct answer.
The robber with the most points (successful cracks) wins.
## Leaderboard
**Too many solves**
* Martin Büttner: [(Python 3, 16, matsjoyce)](https://codegolf.stackexchange.com/a/40946/21487), [(CJam, 15, Ypnypn)](https://codegolf.stackexchange.com/a/40952/21487), [(Mathematica, 29, Fox Wilson)](https://codegolf.stackexchange.com/a/40957/21487), [(JavaScript, 15, Caridorc)](https://codegolf.stackexchange.com/a/40964/21487), [(CJam, 52, user23013)](https://codegolf.stackexchange.com/a/41025/21487), [(Pyth, 11, isaacg)](https://codegolf.stackexchange.com/a/41038/21487), [(PHP, 22, kenorb)](https://codegolf.stackexchange.com/a/41054/21487), [(PHP, 13, kenorb)](https://codegolf.stackexchange.com/a/41058/21487), [(Ruby, 17, Doorknob)](https://codegolf.stackexchange.com/a/41082/21487), [(PHP, 49, bwoebi)](https://codegolf.stackexchange.com/a/41115/21487), [(Mathematica, 35, Tally)](https://codegolf.stackexchange.com/a/41120/21487), [(GolfScript, 13, Peter Taylor)](https://codegolf.stackexchange.com/a/41143/21487), [(JavaScript, 25, Cris)](https://codegolf.stackexchange.com/a/41147/21487), [(JavaScript, 29, Cris)](https://codegolf.stackexchange.com/a/41149/21487), [(JavaScript, 26, Cris)](https://codegolf.stackexchange.com/a/41176/21487), [(Bash, 33, Debasis)](https://codegolf.stackexchange.com/a/41186/21487), [(JavaScript, 10, Cris)](https://codegolf.stackexchange.com/a/41187/21487), [(Lua, 28, ChipperNickel)](https://codegolf.stackexchange.com/a/41236/21487), [(Mathematica, 18, Arcinde)](https://codegolf.stackexchange.com/a/41241/21487), [(JavaScript, 30, Qwertiy)](https://codegolf.stackexchange.com/a/41258/21487), [(CJam, 13, user23013)](https://codegolf.stackexchange.com/a/41264/21487), [(JavaScript, 41, Ismael Miguel)](https://codegolf.stackexchange.com/a/41296/8478), [(Ruby, 38, Doorknob)](https://codegolf.stackexchange.com/a/41301/8478), [(Marbelous, 36, es1024)](https://codegolf.stackexchange.com/a/41319/8478), [(PHP, 33, Ismael Miguel)](https://codegolf.stackexchange.com/a/41344/8478), [(JavaScript, 29, Joe)](https://codegolf.stackexchange.com/a/41374/8478), [(JavaScript, 28, Shawn Holzworth)](https://codegolf.stackexchange.com/a/41383/8478), [(Ruby, 35, histocrat)](https://codegolf.stackexchange.com/a/41436/8478), [(CJam, 19, Ypnypn)](https://codegolf.stackexchange.com/a/41440/8478), [(Ruby, 17, Stephen Touset)](https://codegolf.stackexchange.com/a/41453/8478), [(JavaScript, 36, MegaTom)](https://codegolf.stackexchange.com/a/42201/8478), [(JavaScript, 24, fogcityben)](https://codegolf.stackexchange.com/a/43130/8478), [(Python 3, 21, Reticality)](https://codegolf.stackexchange.com/a/43179/8478), [(JavaScript, 10, Jamie Barker)](https://codegolf.stackexchange.com/a/44302/8478), [(JavaScript, 15, Jamie Barker)](https://codegolf.stackexchange.com/a/44304/8478)
**20 solves**
* feersum: [(Python 3, 44, Sp3000)](https://codegolf.stackexchange.com/a/41049/21487), [(C, 70, es1024)](https://codegolf.stackexchange.com/a/41130/21487), [(MATLAB, 41, COTO)](https://codegolf.stackexchange.com/a/41131/21487), [(Brainfuck, 118, Sp3000)](https://codegolf.stackexchange.com/a/41134/21487), [(C, 30, Ethiraric)](https://codegolf.stackexchange.com/a/41157/21487), [(C, 28, Mig)](https://codegolf.stackexchange.com/a/41163/21487), [(Python 3, 46, hosch250)](https://codegolf.stackexchange.com/a/41196/21487), [(Java, 70, Rodolvertice)](https://codegolf.stackexchange.com/a/41209/21487), [(C, 29, imallett)](https://codegolf.stackexchange.com/a/41210/21487), [(Java, 226, nhahtdh)](https://codegolf.stackexchange.com/a/41218/21487), [(Little Man Computer, 63, The Wolf)](https://codegolf.stackexchange.com/a/41226/21487), [(Python 2, 89, Beta Decay)](https://codegolf.stackexchange.com/a/41229/21487), [(Python 2, 41, muddyfish)](https://codegolf.stackexchange.com/a/41265/21487), [(C, 63, es1024)](https://codegolf.stackexchange.com/a/41298/8478), [(C++, 192, Arcinde)](https://codegolf.stackexchange.com/a/41300/8478), [(Java, 108, durron597)](https://codegolf.stackexchange.com/a/41311/8478), [(C#, 604, eshansingh1)](https://codegolf.stackexchange.com/a/41327/8478), [(C, 44, Art)](https://codegolf.stackexchange.com/a/41405/8478), [(Java, 134, Olavi Mustanoja)](https://codegolf.stackexchange.com/a/41424/8478), [(Bash, 47, Vi.)](https://codegolf.stackexchange.com/a/41426/8478)
**15 solves**
* user23013: [(CJam, 18, Ypnypn)](https://codegolf.stackexchange.com/a/40969/21487), [(JavaScript, 26, hsl)](https://codegolf.stackexchange.com/a/40972/21487), [(CJam, 12, COTO)](https://codegolf.stackexchange.com/a/41002/21487), [(PHP, 23, bwoebi)](https://codegolf.stackexchange.com/a/41075/21487), [(PHP, 54, Steve Robbins)](https://codegolf.stackexchange.com/a/41079/21487), [(CJam, 32, Dennis)](https://codegolf.stackexchange.com/a/41148/21487), [(CJam, 19, Martin Büttner)](https://codegolf.stackexchange.com/a/41159/21487), [(Bash, 23, The Wolf)](https://codegolf.stackexchange.com/a/41235/21487), [(Ruby, 33, Doorknob)](https://codegolf.stackexchange.com/a/41248/21487), [(CJam, 34, Dennis)](https://codegolf.stackexchange.com/a/41294/8478), [(JavaScript, 82, Ismael Miguel)](https://codegolf.stackexchange.com/a/41305/8478), [(PHP, 80, Ismael Miguel)](https://codegolf.stackexchange.com/a/41318/8478), [(QBasic, 43, DLosc)](https://codegolf.stackexchange.com/a/41328/25180), [(QBasic, 42, DLosc)](https://codegolf.stackexchange.com/a/41331/25180), [(ECMAScript, 90, Cris)](https://codegolf.stackexchange.com/a/41338/8478)
**10 solves**
* squeamish ossifrage: [(Python, 44, Caridorc)](https://codegolf.stackexchange.com/a/40967/21487), [(PHP, 52, PleaseStand)](https://codegolf.stackexchange.com/a/40979/21487), [(Befunge-93, 17, user23013)](https://codegolf.stackexchange.com/a/41034/21487), [(BBC BASIC, 187, Beta Decay)](https://codegolf.stackexchange.com/a/41053/21487), [(C, 43, Allbeert)](https://codegolf.stackexchange.com/a/41069/21487), [(Ruby, 58, Rodolvertice)](https://codegolf.stackexchange.com/a/41108/21487), [(JavaScript, 32, hsl)](https://codegolf.stackexchange.com/a/41136/21487), [(PHP, 33, kenorb)](https://codegolf.stackexchange.com/a/41151/21487), [(Python 2, 16, imallett)](https://codegolf.stackexchange.com/a/41220/21487), [(PHP, 53, PleaseStand)](https://codegolf.stackexchange.com/a/41304/8478)
* Sp3000: [(Python, 154, Fox Wilson)](https://codegolf.stackexchange.com/a/41003/21487), [(Python, 48, kgull)](https://codegolf.stackexchange.com/a/41016/21487), [(Python, 68, horns)](https://codegolf.stackexchange.com/a/41020/21487), [(Python 2, 38, FryAmTheEggman)](https://codegolf.stackexchange.com/a/41059/21487), [(Python 2, 57, FryAmTheEggman)](https://codegolf.stackexchange.com/a/41091/21487), [(Python, 74, xnor)](https://codegolf.stackexchange.com/a/41194/21487), [(JavaScript, 66, Cris)](https://codegolf.stackexchange.com/a/41302/8478), [(JavaScript, 70, Cris)](https://codegolf.stackexchange.com/a/41302/8478), [(Python 2, 37, muddyfish)](https://codegolf.stackexchange.com/a/41308/8478), [(Python, 55, FireFly)](https://codegolf.stackexchange.com/a/41394/8478)
**7 solves**
* grc: [(Python 2, 61, FryAmTheEggman)](https://codegolf.stackexchange.com/a/40996/21487), [(Perl 5, 47, chilemagic)](https://codegolf.stackexchange.com/a/41015/21487), [(Python, 69, Sp3000)](https://codegolf.stackexchange.com/a/41040/21487), [(Perl, 39, GentlePurpleRain)](https://codegolf.stackexchange.com/a/41121/21487), [(Perl, 36, squeamish ossifrage)](https://codegolf.stackexchange.com/a/41137/21487), [(Python 3, 110, Sp3000)](https://codegolf.stackexchange.com/a/41142/21487), [(C, 53, FireFly)](https://codegolf.stackexchange.com/a/41279/21487)
**5 solves**
* hsl: [(CoffeeScript, 25, Martin Büttner)](https://codegolf.stackexchange.com/a/40959/21487), [(Golfscript, 20, Josiah Winslow)](https://codegolf.stackexchange.com/a/40985/21487), [(Lua, 18, user3155415)](https://codegolf.stackexchange.com/a/41001/21487), [(Python, 54, kgull)](https://codegolf.stackexchange.com/a/41006/21487), [(Arithmetic, 31, Cris)](https://codegolf.stackexchange.com/a/41285/21487)
* PleaseStand: [(PHP, 14, Tryth)](https://codegolf.stackexchange.com/a/41014/21487), [(C++, 56, hosch250)](https://codegolf.stackexchange.com/a/41024/21487), [(PHP, 21, kenorb)](https://codegolf.stackexchange.com/a/41168/21487), [(QBasic, 37, DLosc)](https://codegolf.stackexchange.com/a/41361/163), [(JavaScript, 46, FireFly)](https://codegolf.stackexchange.com/a/41382/8478)
**4 solves**
* bwoebi: [(PHP, 52, kenorb)](https://codegolf.stackexchange.com/a/41074/21487), [(PHP, 30, Tryth)](https://codegolf.stackexchange.com/a/41105/21487), [(PHP, 27, kenorb)](https://codegolf.stackexchange.com/a/41112/21487), [(PHP, 44, kenorb)](https://codegolf.stackexchange.com/a/41154/21487)
* FireFly: [(JavaScript, 94, Shawn Holzworth)](https://codegolf.stackexchange.com/a/41364/8478), [(Python, 34, Sp3000)](https://codegolf.stackexchange.com/a/41390/8478), [(Brainfuck, 39, Mig)](https://codegolf.stackexchange.com/a/41500/3918), [(JavaScript, 69, Shawn Holzworth)](https://codegolf.stackexchange.com/a/41517/3918)
**3 solves**
* Optimizer: [(JavaScript, 61, jsh)](https://codegolf.stackexchange.com/a/41042/21487), [(JavaScript, 47, palerdot)](https://codegolf.stackexchange.com/a/41141/21487), [(JavaScript, 42, Shawn Holzworth)](https://codegolf.stackexchange.com/a/41410/8478)
* es1024: [(PHP, 46, Ismael Miguel)](https://codegolf.stackexchange.com/a/41363/29611), [(Python shell, 15, xnor)](https://codegolf.stackexchange.com/a/41533/29611), [(Python shell, 21, xnor)](https://codegolf.stackexchange.com/a/41561/29611)
* DLosc: [(Python, 41, Sp3000)](https://codegolf.stackexchange.com/a/41292/21487), [(Ruby, 37, Rodolvertice)](https://codegolf.stackexchange.com/a/41316/8478), [(CJam, 14, User23013)](https://codegolf.stackexchange.com/a/41885/16766)
**2 solves**
* xnor: [(Python 3, 37, matsjoyce)](https://codegolf.stackexchange.com/a/40954/21487), [(Python 2, 29, Dennis)](https://codegolf.stackexchange.com/a/40968/21487)
* Daniel Wagner: [(Haskell, size 34, Petr Pudlák)](https://codegolf.stackexchange.com/a/41222/21487), [(Haskell, 42, proud haskeller)](https://codegolf.stackexchange.com/a/41230/21487)
* nneonneo: [(Python, 41, Sp3000)](https://codegolf.stackexchange.com/a/41259/21487), [(C, 43, FryAmTheEggman)](https://codegolf.stackexchange.com/a/41268/21487)
* Art: [(C, 51, es1024)](https://codegolf.stackexchange.com/a/41242/21487), [(C, 48, es1024)](https://codegolf.stackexchange.com/a/41402/8478)
* n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳: [(Java 6+, 101, Rodolvertice)](https://codegolf.stackexchange.com/a/41028/21487), [(Java, 97, Olavi Mustanoja)](https://codegolf.stackexchange.com/a/41413/8478)
**1 solve**
* Ypnypn: [(Python 2, 50, Geobits)](https://codegolf.stackexchange.com/a/40940/21487)
* matsjoyce: [(Python 3, 12, xnor)](https://codegolf.stackexchange.com/a/40942/21487)
* user1354557: [(Python, 56, Fox Wilson)](https://codegolf.stackexchange.com/a/40973/21487)
* Dennis: [(CJam, 20, Martin Büttner)](https://codegolf.stackexchange.com/a/41122/21487)
* isaacg: [(Pyth, 71, FryAmTheEggman)](https://codegolf.stackexchange.com/a/41123/21487)
* ConMan: [(SAS, 17, user3490)](https://codegolf.stackexchange.com/a/41199/21487)
* Arcinde: [(JavaScript, 285, Beta Decay)](https://codegolf.stackexchange.com/a/41239/21487)
* Shawn Hotazworth: [(Javascript, 82, TrungDQ)](https://codegolf.stackexchange.com/a/41252/21487)
* nooodl: [(Ruby, 49, Doorknob)](https://codegolf.stackexchange.com/a/41255/21487)
* Bhante Nandiya: [(Python 3, 37, Sp3000)](https://codegolf.stackexchange.com/a/41274/21487)
* Geobits: [(APL, 17, user23013)](https://codegolf.stackexchange.com/a/41306/8478)
* histocrat: [(Ruby, 23, MegaTom)](https://codegolf.stackexchange.com/a/41421/8478)
* ProgramFOX: [(Python, 13, Reticality)](https://codegolf.stackexchange.com/a/44444/9275)
  
[Answer]
# [CJam, size 20, by Martin Büttner](https://codegolf.stackexchange.com/a/41046)
```
Hi "petStorm!", mame
```
[Try it online.](http://cjam.aditsu.net/ "CJam interpreter")
### How it works
```
Hi                      "           int(17)                     ";
   "petStorm!",         "                    len('petStorm!')   ";
                ma      "     atan2(       ,                 )  ";
                  me    " exp(                                ) ";
                        " exp(atan2(int(17), len('petStorm!'))) ";
```
### Cracking the code
The desired output, `2.956177636986737`, is either a Double or a Double followed by a Long.
Using only the characters in `"Stop, Hammer time!"`, there are four builtin operators that return non-integer Doubles:
* `mS`, which is `asin`
* `ma`, which is `atan2`
* `me`, which is `exp`
* `mt`, which is `tan`
All of them contain an `m`, so we can use at most three of them. There is only one `S` and one `a`.
All of those operators need input, and `ma` is the only one that consumes two inputs. We have only three ways to push Longs:
* `"...",`, which pushes the string's length (strictly less than 18).
* `H`, which pushes 17.
* `...!`, which pushes the logical NOT of `...`.
We have no way of pushing something falsy as `...`, so the last option will always push 0.
The output doesn't begin or end with `17` or `0`. Since 15 decimal digits is the usual number of digits for a Double, it seemed likely that the output was a simple Double. 
Assuming this, the code has to fall in one of the following categories:
* `<Long> <mS|me|mt>{1,3}`
* `<Long> <mS|me|mt>{x} <Long> <mS|me|mt>{y} ma <mS|me|mt>{z}`.
* Any of the above, with some cast to Long (`i`) or rounding (`mo`) applied to a Double.
In the second case, `x + y + z` is either 1 or 2 and one of the Longs is 0 or 17.
The rest was basically brute force. After a few tries,
```
18 , {H \ ma me 2.956177636986737 =} =
```
returned `9`, meaning that
```
H 9 ma me
```
produces the desired output.
All that's left is to eliminate all but 9 characters from the string. Spaces are noops and `i` is a noop on Longs, so `"petStorm!"` is one of the possible choices.
[Answer]
# [Python 3, size 12, by xnor](https://codegolf.stackexchange.com/a/40939/30630)
```
()and bciprt
```
Does nothing (expression produces an empty tuple, which is not printed). This works due to short-circuit evaluation.
[Answer]
# [Python, size 74, by xnor](https://codegolf.stackexchange.com/a/41184/21487)
```
any(print(set is
set)for i in oct(chr is
map))and aeeeeeggiilnnpprrrrrstvw
```
Well that was fun. Thanks to FryAmTheEggman, hosch250 and isaacg for suggestions/helping out.
[Answer]
## [Python 2, size 50, by Geobits](https://codegolf.stackexchange.com/a/40934/16294)
```
print 2**2**2*2**2-22-2**2**2**2/2**2**2**2**2/2/2
```
Outputs 42.
[Answer]
# [GolfScript, size 13, by Peter Taylor](https://codegolf.stackexchange.com/a/41092/8478)
```
,22,{.4&?+.}/
```
[Test it here.](http://golfscript.apphb.com/?c=LDIyLHsuNCY%2FKy59Lw%3D%3D)
Another one, that I only cracked with big help from Sp3000. Thanks!
So here's how we got there. Sp3000 noticed a bunch of runs of consecutive numbers in the output:
```
1,2,3,4,[2608852181],4582,4583,4584,4585,4586,[253225388392299],
142924,142925,142926,142927,142928,[302928],497409,497409
```
Based on that we made the assumption, that this was an increasing sequence, which only allowed for one possible splitting of the remaining numbers:
```
1,2,3,4,260,885,2181,4582,4583,4584,4585,4586,25322,53883,92299,
142924,142925,142926,142927,142928,302928,497409,497409
```
That's 23 numbers, which was a strong indicator for repeating the block 22 times, as well as ending the block with `.` (duplicate top stack element), such that the previous result got left behind on the stack and such that the final iteration would appear on the stack twice. That's `22,{____.}/`.
Now looking at the gaps, those turn out to be 4th powers (which is nice, because we have `4` and `?`). More precisely, they are the fourth power of the index of the current number. So next we looked at which indices created a gap:
```
4,5,6,7, 12,13,14,15, 20,21,..?
```
In binary those are
```
00100
00101
00110
00111
01100
01101
01110
01111
10100
10101
```
They all have the third bit set, which means that the index is probably just bitwise-and'ed with `4` (which is nice again, because we can make another `4` with `.` and have a `&`). This works particularly well, because this operation results in either `0` or `4`, and if we use that as the exponent we get either `1` or a fourth power, which is exactly what we need. So let's put that together:
```
22,{.4&?+.}/
```
Here is what the block does:
```
.      # Duplicate current index
 4     # Push a 4
  &    # Bitwise and
   ?   # Raise index to resulting power
    +  # Add to previous result
     . # Duplicate for use in next iteration
```
Now there were two problems left: we had a stray `,` we didn't use yet, and the first iteration is a special case, in that there is no value from a previous iteration which we could add things to when encountering `+`. We found that thanks to an unrelated comment by user23013 who casually mentioned that GolfScript starts out with an empty string on the stack (if there's nothing on STDIN). So we could use that other `,` right at the beginning to turn that string into a `0`, which was just what we needed as the start of the iteration.
[Answer]
# [Python 3, size 16, by matsjoyce](https://codegolf.stackexchange.com/a/40945/8478)
```
import __hello__
```
[Answer]
# [Ruby, size 17, by Doorknob](https://codegolf.stackexchange.com/a/40994/8478)
```
p 2,%r~n~i=~'*tN'
```
That was great fun. Thanks to Sp3000 for helping me out with this! And I learned that `%r?...?` literals can have any delimiters. :)
[Answer]
# [PHP, size 49, by bwoebi](https://codegolf.stackexchange.com/a/41096/8478)
```
print@substr(new exception,+~$$a+=++$$m+$$i+2+n);
```
That was absolutely *mental*.
It got to
```
print@substr(new exception,);
```
fairly quickly, at which point I needed something that gives `-6` after the comma, having `$++$++$++$+=$~main$2` left.
The main catch is that `$a`, `$m` and `$i` are all `NULL`, so using them indirectly in [variable variables](http://php.net/manual/en/language.variables.variable.php), means they all point to the same variable. However, PHP seems to be doing some weird things about resolving variable variables. With normal variables you can do things like
```
echo $a+$a=2;
```
which prints `4` (the `2` is assigned to `$a` and then added to itself). But if I do the same with variable variables:
```
echo $$a+$$a=2;
```
I get `2`, because now the first `$$a` is evaluate before the assignment.
In the end I managed to force some order by putting some increments on the RHS of the `+=` which had to be evaluated before that addition-assignment. That way I got to `5` which I could then just bit-complement. Still... there are some mysterious things going on, and I have no idea why half the things I tried worked and didn't work.
[Answer]
# [Ruby, size 38, by Doorknob](https://codegolf.stackexchange.com/a/40970/8478)
```
[$><<(!$pece60).to_s[rand($win)].succ]
```
I'm pretty sure this is nowhere near the original source. It's deterministic despite using `rand`.
Here is how this one works. `$><<` is just output. `$pece60` and `$win` are undefined global variables, which therefore are just `nil` (and they allowed me to get rid of some extraneous characters). `!$pece60` makes a `true` and `to_s` gives the string `"true"`.
For ages, I tried getting a `2` or `-2` to access that `u` in there, but then I realised I could just take the `t`, and call `.succ`(essor) on it to make a `u`.
`rand` with a `nil` parameter returns a random float in the interval [0,1). When using floats to index into strings, they get truncated to integers, so this will always return the first character.
Finally, I had a spare pair of `[]` so I just wrapped everything in it, because thankfully everything is an expression in Ruby.
Thanks to Sp3000 for throwing some ideas around in chat.
[Answer]
# [C, 51 by es1024](https://codegolf.stackexchange.com/questions/40932/unscramble-the-source-code/41132#41132)
```
c=0xf.cp9,hhtaglfor;main() {;; printf("%d",(++c));}
```
After 20 years of programming C today I learned about hexadecimal floating point constants.
[Answer]
# [Ruby, 45 (histocrat)](https://codegolf.stackexchange.com/a/41269/3918)
```
%q[zyfnhvjkwudebgmaclprs x].to_i(36)/51074892
```
Woohoo! This is my first crack at a code golf problem, and I don't have enough rep to comment on the original post. I immediately recognized the trick used, since I've actually found use for it in production code often. It took about 5 minutes to figure out most of the structure and a few hours to come up with the complete answer.
Explanation:
* `%q[]` is an alternative method for creating strings. Parenthesis and curly braces may also be used.
* `String#to_i` in Ruby accepts numbers in any base from 2 to 36. It will ignore the first character in the string which is not part of the number, so any extra characters can be "thrown away" after the space.
And here's the code I used to crack it:
```
require 'set'
# return true if the string is made up of unique characters
def uniq(s)
  a = s.each_char.to_a
  return a == a.uniq
end
def uniq_while_same(a,b)
  s = Set.new
  a.each_char.zip(b.each_char).each do |ai, bi|
    return true if ai != bi
    return false if s.include? ai
    s << ai
  end
  return true
end
def ungolf(answer)
  # For each base that even makes sense
  [            36, 35, 34,     32, 31, 30,
   29, 28, 27, 26, 25, 24, 23,     21, 20,
   19, 18, 17, 16, 15, 14, 13, 12,     10].each do |base|
    # Ignore bases where it is not possible to create a unique-string number greater than answer
    next if answer > base ** base
    # Pick digits for the denominator that are not duplicates of the digits in base
    denominator_digits = ('1234567890'.each_char.to_a - base.to_s.each_char.to_a)
    # For each permutation of those digits for the denominator
    (1..10).each do |denominator_length|
      denominator_digits.permutation(denominator_length) do |denominator_s|
        # Maybe the denominator is in octal
        denominator_base = 10
        if denominator_s[0] == '0'
          next if denominator_s.include?('8') || denominator_s.include?('9')
          denominator_base = 8
        end
        denominator_s = denominator_s.join
        denominator = denominator_s.to_i denominator_base
        print "#{"\b"*64}(%q[#{(answer * denominator).to_s(base).ljust(36)}].to_i #{base})/#{denominator_s.ljust(10)}" if rand < 0.01
        # Ignore denominators that are definitely impossible to have answers for
        next unless uniq_while_same "qtoi#{base}#{denominator_s}#{(answer * denominator).to_s(base)}",
                                    "qtoi#{base}#{denominator_s}#{((answer + 1) * denominator).to_s(base)}"
        # For each numerator that gives answer when divided by the denominator
        (answer * denominator...(answer + 1) * denominator).each do |numerator|
          print "#{"\b"*64}%q[#{numerator.to_s(base).ljust(36)}].to_i(#{base})/#{denominator_s.ljust(10)}" if rand < 0.01
          # Remove any that are still not unique
          s = "#{numerator.to_s(base)}#{base}#{denominator_s}qtoi"
          next unless uniq s
          # Done. Compute which characters need to be thrown away to fill the remaining space
          remains = ('0123456789abcdefghijklmnopqrstuvwxyz'.each_char.to_a - s.each_char.to_a).join
          print "#{"\b"*64}#{" "*64}#{"\b"*64}"
          return "%q[#{numerator.to_s(base)} #{remains}].to_i(#{base})/#{denominator_s}"
        end
      end
    end
  end
  print "#{"\b"*64}"
  puts "\nnone"
  return nil
end
print ungolf 9410663329978946297999932
```
Way to go embedding an NP problem inside a riddle. I have been thoroughly nerd-sniped. Good job!
[Answer]
# [Python [any] shell size 44, by Caridorc](https://codegolf.stackexchange.com/a/40962/11006)
```
__name__[3]  or (enfin_____[42], manager[1])
```
I'm sure there was supposed to be more to it than this, but since `__name__` equates to `__main__`, the 4th character 'a' is selected and the rest of the line is never evaluated.
[Answer]
## [Perl, size 36, by squeamish ossifrage](https://codegolf.stackexchange.com/a/40963/4020)
```
$_=rof;for$i(1..2129<<7){$_++}print;
```
Another difficult one.
[Answer]
# [CJam, size 13, by user23013](https://codegolf.stackexchange.com/a/41213/8478)
```
G,Cf#If/sE*K%
```
[Test it here.](http://cjam.aditsu.net/)
Solved by hand, like so:
First, some background for non-CJammers:
* `CEGIK` are all variables, which are pre-initialised to `12`, `14`, `16`, `18`, `20`, respectively.
* `s` converts the top stack element to a string.
* Strings are technically just arrays of characters.
* `f` is pretty magic. For the purpose of this answer, the simplified version is that, for an array `a`, some other value `b` and an operator `g`, the sequence `abfg` maps `g(_,b)` onto `a` (where each element of `a` goes into the `_` slot).
* `/` is division and splitting arrays (amongst other things).
* `*` is multiplication and array repetition (amongst other things).
* `%` is modulo and some weird operation, which in the form `ad%` for array `a` and integer `d` takes every `d`th element of `a` (like Python's slicing with step width `d`).
* `#` is exponentiation (amongst other things).
* `,` turns numbers into ranges (from `0` to `n-1`) and returns the length of an array.
Okay, that out of the way...
It was fairly obvious that we needed `,` to turn a number into a range, because the only other way to get an array would have been to build a larger number and turn it into a character array with `s` - but then we couldn't have done any further arithmetic on it. And we need an array to do something with the `f`s.
I first assumed that the `f`s were used with `#` and `%`, but that would mean we would have needed a number around 90 to get the right amount of digits in the end. And also, this didn't explain what to do with `s`, and since the answer looked really golfy, I doubted user23013 just appended an `s` as an effective no-op somewhere to throw people off.
So I figured, maybe he isn't even keeping the numbers small with `%`, but instead he builds an array of huge numbers, concatenates their string representation with `s`, but then only picks some odd slice out of it with `%`. So I played around a bit with the following framework:
```
__*,_f#_f/s_%
```
(You can't do `_f/` first, because that would yield zero for at least the first 12 elements.)
Where the `_` are some permutation of the variables. I didn't try all of them before I got bored, and the main problem with this was that the resulting sequence of digits as always way too long.
At some point it occurred to me, that we wouldn't need such a large range (i.e. the product of two numbers), if instead we used the `*` to repeat the resulting string. Due to the mismatch of the parameters of `*` and `%` this would yield no repetition in the result:
```
_,_f#_f/s_*_%
```
This yielded results of a length very close to what I was looking for. I would have actually tried all 240 of them, but fairly quickly (third or fourth attempt), I stumbled upon
```
E,Cf#If/sG*K%
```
which yields
```
03081942753650251594592190492275006661328850322159030034930530649722385533653290754678977
```
And I figured a match of the first six digits wouldn't be a coincidence. So the question was how to rearrange it without upsetting the actual computation:
* I couldn't change `K` because that would pick out different digits altogether.
* I couldn't change `C` or `I` because that would change the numbers resulting from the two map operations.
* If I changed `G` that would only change the number of repetitions, which would do nothing but change the length of the result. (Which is good.)
* If I changed `E` that would change the range of the array, but the range would still start with `[0 1 2 3 ...]`, so it wouldn't affect the calculation. It *would* affect the length of the base string returned by `s`, which would also mean that `K%` would pick out different digits upon additional repetitions.
So I just tried swapping `E` and `G` and voila:
```
030819828850379075460427536222159187897761502517030034671154875945928930530907551421904962649729
```
In summary, here is what the code does:
```
G,            "Push [0 1 2 3 ... 13 14 15].";
  Cf#         "Raise each element to the 12th power.";
     If/      "Divide each element by 18.";
        s     "Concatenate all numbers into a string.";
         E*   "Repeat 14 times.";
           K% "Pick every 20th digit.";
```
[Answer]
# [APL, size 17, by user23013](https://codegolf.stackexchange.com/a/41037/14215)
```
+(3*3)3,(***)\3 3
```
I spent *far* too long trying to crack this. It probably would've gone quicker if I knew APL going in.
[Try it out here](http://ngn.github.io/apl/web/index.html)
[Answer]
# [Pyth, size 11, by isaacg](https://codegolf.stackexchange.com/a/41007/8478)
```
:\\w$ ",d,N
```
That's some mean bug abuse right there. This compiles to:
```
Pprint("\n",at_slice("\",input(), ",d,N))
```
The relevant bug is that `\\` compiles to `"\"` instead of `"\\"`, which lets you compile Pyth into a string.
[Answer]
# [Python, size 69, by Sp3000](https://codegolf.stackexchange.com/a/41012/4020)
```
print(sum(list(map(ord,str((dict(((str(dict()),list()),)),str()))))))
```
That was hard...
[Answer]
[Python 3, 37 bytes, by Sp3000](https://codegolf.stackexchange.com/a/41081/32690)
```
print(sum(b"a".zfill(len(str(...)))))
```
Embarrassingly by far the hardest part was figuring out to convert the string into bytes. I had to sleep on it, and in the night realized 'duh, it's a bytes literal!'
[Answer]
# [PHP, 53, by PleaseStand](https://codegolf.stackexchange.com/a/40990/11006)
Cracked it at last:
```
for($d=57,$o=35;$o+$d<999;)$o+=printf("$d%o",$d+=$o);
```
The solution came quite quickly when I noticed that the sequence consists of alternating decimal and octal numbers:
```
Dec: 57...92...132...177...228...285...348...417...492....573....661....756....858....
     571349220413226117734422843528553434864141775449210755731225661136475615328581707
Oct: ..134..204...261...344...435...534...641...754...1075...1225...1364...1532...1707
==Dec:  92  132   177   228   285   348   417   492    573    661    756    858    967
```
Also, the intervals between each set of numbers grew at a rate equal to the value returned by `printf()` (i.e., the number of characters written).
[Answer]
# [Python 2, size 132, by Vi.](https://codegolf.stackexchange.com/a/41155/32353)
```
exec('from string import printable as e\nprint "cqance"\x2Ereplace("q",e[len("fgiillmmooprrsstt")])or ",,,\016:::S[]____tuuvyy" ""')
```
Thanks for all the backslashes and quotation marks :)
---
Edit: The updated 96-char version:
```
exec "try:exec'from __future__ import braces\\nt(12)'\nexcept SyntaxError as q:print(q[0][6:])"
```
This is taken entirely from Alex's solution in <https://codegolf.stackexchange.com/a/41451/32353>
[Answer]
# [CJam, size 15, by Ypnypn](https://codegolf.stackexchange.com/a/40936/8478)
```
98,{7%}%{6+}%:+
```
From the given characters, I guessed it had to be one of the three following forms:
```
__,{_%}%{_+}%:+
_,{_%}%{__+}%:+
__,{_+}%{_%}%:+
```
which creates a two-digit range, then maps an addition and modulo operation (in either order) onto the range, before summing it. So I just started with the first one, and systematically tried permutations of `6789` in the gaps.
[Answer]
# [PHP, size 52, by PleaseStand](https://codegolf.stackexchange.com/a/40978/11006)
```
for(mt_srand($i=46);$i--;)echo chr(mt_rand()%95+32);
```
This turned out to be quite easy in the end. The output looks very random, and the characters `m`, `t`, `_`, `r`, `a`, `n` and `d` all appeared twice...
[Answer]
## [Python 2, size 61, by FryAmTheEggman](https://codegolf.stackexchange.com/a/40947/4020)
```
print(dir('~s]l.c:st_''-p_tp.l]-~.:o:Te[_u[.i_')[10][2:][:3])
```
I'd be very surprised if this matches the original.
[Answer]
# [Python 3, Sp3000, size 44](https://codegolf.stackexchange.com/a/41048/30688)
```
print(~(~(()<((),))<<(()<((),))))<<((()<()))
```
Python 3 helped me here as I was able to cause an error (left-shifting `None` by something) after printing the answer.
[Answer]
# [PHP, size 52, by kenorb](https://codegolf.stackexchange.com/a/41062/9409)
```
_:@print_r(chr(@++$i+pow(3<<5,1)));if($i<2*4)goto _;
```
(God, how long it took me to figure what to do with the remaining `_r` suffix. Until I noticed it was not `print`, but `print_r`...)
[Answer]
# [PHP, size 54, by Steve Robbins](https://codegolf.stackexchange.com/a/41077/25180)
```
echo(21<<($$$$$$${$aaaabbbbbbehi==$l&$w^2}^1==1));;;;
```
Not the original solution, I think.
[Answer]
# [C, es1024, length 70](https://codegolf.stackexchange.com/a/41127/30688)
```
e='C',f;main(g){Chorkil:f=printf("40%.d",e+e-  -g);}hAx;*hotpoCkats();
```
The hard part ended up being to keep track of all the unneeded characters...seriously...I had to redo them about 10 times. The only one that worried me was the `.` but somehow I stuck it in the middle of the `printf` format string and it became invisible!
[Answer]
## [Python 3, size 110, by Sp3000](https://codegolf.stackexchange.com/a/41139/4020)
```
import sys,io
u=sys.stdout;sys.stdout=_=io.StringIO()
import this
u.write(" ".join(_.getvalue().split()[::9]))
```
This was a fun one :)
[Answer]
# [Haskell, size 34, by Petr Pudlák](https://codegolf.stackexchange.com/a/41084/21457)
```
main=print(0xb2f3d5^0x7f1f27::Int)
```
Note that this program must be run on a 32-bit machine. If you want to check that this is the correct program and you have a 64-bit machine, you can use this instead:
```
import Data.Int
main=print(0xb2f3d5^0x7f1f27::Int32)
```
It was pretty easy to guess the "frame" of the program `main=print(0x<hex digits>^0x<hex digits>::Int)`. All the magic was in searching for the right way to partition and order the digits. I didn't do very much smart here, just a brute-force search... though I did take care to abuse the fact that some digits were duplicated, there were probably about an equal number of digits in the base and exponent, and the last digit of the base almost certainly wasn't even. The complete search code is included below; it uses the [multiset-comb](http://hackage.haskell.org/package/multiset-comb) package. The full search takes about 10:33 on my machine (and produces only one right answer, of course).
```
{-# LANGUAGE NoMonomorphismRestriction #-}
import Control.Monad
import Data.Int
import Data.List (inits, tails, group)
import Numeric
import Math.Combinatorics.Multiset
main = print (searchFor (-1121766947))
searchFor n = do
    nl <- [6,5,7,4,8,3,9,2,10,1,11]
    (l_, r_)  <- chooseSubbag nl digits
    l <- perms l_
    guard (last l /= '2')
    r <- perms r_
    guard ((fromString l :: Int32) ^ (fromString r :: Integer) == n)
    return (l, r)
chooseSubbag n = chooseSubbag' n . group
chooseSubbag' n xss = go (drop (n-1) (concat xss)) n xss where
    go _  n xss | n < 0 = []
    go _  0 xss = [([],concat xss)]
    go [] n xss = []
    go m  n (xs:xss) = do
        (kx, tx) <- zip (tails xs) (inits xs)
        (k , t ) <- go (drop (length tx) m) (n-length kx) xss
        return (kx++k, tx++t)
digits = "1223577bdfff"
fromString = fst . head . readHex
perms = permutations . fromList
```
[Answer]
# [Javascript, 82, by TrungDQ](https://codegolf.stackexchange.com/a/41192/32628)
```
b=/v/[0]+' ';b[0]+b[9]+b[6]+b[7]+'v'+b[7]+((0==0)+b)[1]+b[9]+b[4]+b[5]+b[6]+b[2];
```
Took forever to get the indexes right.
]