Unscramble the Source Code [robber thread for cracking attempts]

Question

This is the companion thread to the main Unscramble the Source Code 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), (CJam, 15, Ypnypn), (Mathematica, 29, Fox Wilson), (JavaScript, 15, Caridorc), (CJam, 52, user23013), (Pyth, 11, isaacg), (PHP, 22, kenorb), (PHP, 13, kenorb), (Ruby, 17, Doorknob), (PHP, 49, bwoebi), (Mathematica, 35, Tally), (GolfScript, 13, Peter Taylor), (JavaScript, 25, Cris), (JavaScript, 29, Cris), (JavaScript, 26, Cris), (Bash, 33, Debasis), (JavaScript, 10, Cris), (Lua, 28, ChipperNickel), (Mathematica, 18, Arcinde), (JavaScript, 30, Qwertiy), (CJam, 13, user23013), (JavaScript, 41, Ismael Miguel), (Ruby, 38, Doorknob), (Marbelous, 36, es1024), (PHP, 33, Ismael Miguel), (JavaScript, 29, Joe), (JavaScript, 28, Shawn Holzworth), (Ruby, 35, histocrat), (CJam, 19, Ypnypn), (Ruby, 17, Stephen Touset), (JavaScript, 36, MegaTom), (JavaScript, 24, fogcityben), (Python 3, 21, Reticality), (JavaScript, 10, Jamie Barker), (JavaScript, 15, Jamie Barker)

20 solves

• feersum: (Python 3, 44, Sp3000), (C, 70, es1024), (MATLAB, 41, COTO), (Brainfuck, 118, Sp3000), (C, 30, Ethiraric), (C, 28, Mig), (Python 3, 46, hosch250), (Java, 70, Rodolvertice), (C, 29, imallett), (Java, 226, nhahtdh), (Little Man Computer, 63, The Wolf), (Python 2, 89, Beta Decay), (Python 2, 41, muddyfish), (C, 63, es1024), (C++, 192, Arcinde), (Java, 108, durron597), (C#, 604, eshansingh1), (C, 44, Art), (Java, 134, Olavi Mustanoja), (Bash, 47, Vi.)

15 solves

• user23013: (CJam, 18, Ypnypn), (JavaScript, 26, hsl), (CJam, 12, COTO), (PHP, 23, bwoebi), (PHP, 54, Steve Robbins), (CJam, 32, Dennis), (CJam, 19, Martin Büttner), (Bash, 23, The Wolf), (Ruby, 33, Doorknob), (CJam, 34, Dennis), (JavaScript, 82, Ismael Miguel), (PHP, 80, Ismael Miguel), (QBasic, 43, DLosc), (QBasic, 42, DLosc), (ECMAScript, 90, Cris)

10 solves

• squeamish ossifrage: (Python, 44, Caridorc), (PHP, 52, PleaseStand), (Befunge-93, 17, user23013), (BBC BASIC, 187, Beta Decay), (C, 43, Allbeert), (Ruby, 58, Rodolvertice), (JavaScript, 32, hsl), (PHP, 33, kenorb), (Python 2, 16, imallett), (PHP, 53, PleaseStand)
• Sp3000: (Python, 154, Fox Wilson), (Python, 48, kgull), (Python, 68, horns), (Python 2, 38, FryAmTheEggman), (Python 2, 57, FryAmTheEggman), (Python, 74, xnor), (JavaScript, 66, Cris), (JavaScript, 70, Cris), (Python 2, 37, muddyfish), (Python, 55, FireFly)

7 solves

• grc: (Python 2, 61, FryAmTheEggman), (Perl 5, 47, chilemagic), (Python, 69, Sp3000), (Perl, 39, GentlePurpleRain), (Perl, 36, squeamish ossifrage), (Python 3, 110, Sp3000), (C, 53, FireFly)

5 solves

• hsl: (CoffeeScript, 25, Martin Büttner), (Golfscript, 20, Josiah Winslow), (Lua, 18, user3155415), (Python, 54, kgull), (Arithmetic, 31, Cris)
• PleaseStand: (PHP, 14, Tryth), (C++, 56, hosch250), (PHP, 21, kenorb), (QBasic, 37, DLosc), (JavaScript, 46, FireFly)

4 solves

• bwoebi: (PHP, 52, kenorb), (PHP, 30, Tryth), (PHP, 27, kenorb), (PHP, 44, kenorb)
• FireFly: (JavaScript, 94, Shawn Holzworth), (Python, 34, Sp3000), (Brainfuck, 39, Mig), (JavaScript, 69, Shawn Holzworth)

3 solves

• Optimizer: (JavaScript, 61, jsh), (JavaScript, 47, palerdot), (JavaScript, 42, Shawn Holzworth)
• es1024: (PHP, 46, Ismael Miguel), (Python shell, 15, xnor), (Python shell, 21, xnor)
• DLosc: (Python, 41, Sp3000), (Ruby, 37, Rodolvertice), (CJam, 14, User23013)

2 solves

• xnor: (Python 3, 37, matsjoyce), (Python 2, 29, Dennis)
• Daniel Wagner: (Haskell, size 34, Petr Pudlák), (Haskell, 42, proud haskeller)
• nneonneo: (Python, 41, Sp3000), (C, 43, FryAmTheEggman)
• Art: (C, 51, es1024), (C, 48, es1024)
• n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳: (Java 6+, 101, Rodolvertice), (Java, 97, Olavi Mustanoja)

1 solve

• Ypnypn: (Python 2, 50, Geobits)
• matsjoyce: (Python 3, 12, xnor)
• user1354557: (Python, 56, Fox Wilson)
• Dennis: (CJam, 20, Martin Büttner)
• isaacg: (Pyth, 71, FryAmTheEggman)
• ConMan: (SAS, 17, user3490)
• Arcinde: (JavaScript, 285, Beta Decay)
• Shawn Hotazworth: (Javascript, 82, TrungDQ)
• nooodl: (Ruby, 49, Doorknob)
• Bhante Nandiya: (Python 3, 37, Sp3000)
• Geobits: (APL, 17, user23013)
• histocrat: (Ruby, 23, MegaTom)
• ProgramFOX: (Python, 13, Reticality)

Answer 1

CJam, size 20, by Martin Büttner

Hi "petStorm!", mame

Try it online.

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 2

Python 3, size 12, by xnor

()and bciprt

Does nothing (expression produces an empty tuple, which is not printed). This works due to short-circuit evaluation.

Answer 3

Python, size 74, by xnor

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 4

Python 2, size 50, by Geobits

print 2**2**2*2**2-22-2**2**2**2/2**2**2**2**2/2/2

Outputs 42.

Answer 5

GolfScript, size 13, by Peter Taylor

,22,{.4&?+.}/

Test it here.

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 6

Python 3, size 16, by matsjoyce

import __hello__

Answer 7

Ruby, size 17, by Doorknob

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 8

PHP, size 49, by bwoebi

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

Ruby, size 38, by Doorknob

[$><<(!$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 10

C, 51 by es1024

c=0xf.cp9,hhtaglfor;main() {;; printf("%d",(++c));}

After 20 years of programming C today I learned about hexadecimal floating point constants.

Answer 11

Ruby, 45 (histocrat)

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

Python [any] shell size 44, by Caridorc

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

Perl, size 36, by squeamish ossifrage

$_=rof;for$i(1..2129<<7){$_++}print;

Another difficult one.

Answer 14

CJam, size 13, by user23013

G,Cf#If/sE*K%

Test it here.

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 dth 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 fs.

I first assumed that the fs 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 15

APL, size 17, by user23013

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

Answer 16

Pyth, size 11, by isaacg

:\\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 17

Python, size 69, by Sp3000

print(sum(list(map(ord,str((dict(((str(dict()),list()),)),str()))))))

That was hard...

Answer 18

Python 3, 37 bytes, by Sp3000

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 19

PHP, 53, by PleaseStand

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 20

Python 2, size 132, by Vi.

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 21

CJam, size 15, by Ypnypn

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 22

PHP, size 52, by PleaseStand

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 23

Python 2, size 61, by FryAmTheEggman

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 24

Python 3, Sp3000, size 44

print(~(~(()<((),))<<(()<((),))))<<((()<()))

Python 3 helped me here as I was able to cause an error (left-shifting None by something) after printing the answer.

Answer 25

PHP, size 52, by kenorb

_:@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 26

PHP, size 54, by Steve Robbins

echo(21<<($$$$$$${$aaaabbbbbbehi==$l&$w^2}^1==1));;;;

Not the original solution, I think.

Answer 27

C, es1024, length 70

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 28

Python 3, size 110, by Sp3000

import sys,io
u=sys.stdout;sys.stdout=_=io.StringIO()
import this
u.write(" ".join(_.getvalue().split()[::9]))

This was a fun one :)

Answer 29

Haskell, size 34, by Petr Pudlák

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

Javascript, 82, by TrungDQ

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.