PHP, 33 bytes, by Ismael Miguel

echo 0X1^BXcdeilnu08DFHTTTgk467; 

Tested on ideone.

This might actually also work on Windows. All it does is xor a hexadecimal 1 with an undefined constant which yields 0.

For the Windows one you can use

echo 7^'6cdeilnudBXX4'; 

which should also work on both platforms, because the string is simply coerced into an integer (being 6), and then we xor that with 7.

I'm curious what those were supposed to be.

QBasic, 79 bytes, by DLosc

print"Iodine" if f then scReen BLaaabbefgghhhiiiiiiiikkllnnossstt,u-u.u 

Bash, 47, Vi.

If you saw a $100 bill lying on the ground, wouldn't you pick it up?

Don't know much about bash, but I tested it and it works.

printf pp;o='${cel-sr(xe\ pp/pp/) fec1/; }' 

DC, 28 bytes, by MichaelT

[ls+dn11ls1+dss<n]sn1ss0lnx 

But I counted 27 bytes. Maybe there is a newline...

CJam, 51, by Optimizer

"JamesBdo,"YZ+/)BA*c+Y*Y%:BS@SB)))[JW:Z____)ci+*]U* 

Brainfuck, 39, by Mig

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

Python shell, size 15, xnor

1215954^1548696 

Obtained by brute force in 1.42 seconds.

Code used to find solution:

#include <iostream> #include <algorithm> int main(){ int digits[] = {1,1,1,2,4,4,5,5,5,6,6,8,9,9}; int ndigits = sizeof(digits)/sizeof(digits[0]); do{ int n1 = 0, n2 = 0; for(int i = 0; i < ndigits - 1; ++i){ n1 = (n1 * 10) + digits[i]; n2 = 0; for(int j = i+1; j < ndigits; ++j) n2 = (n2 * 10) + digits[j]; if((n1 ^ n2) == 339018){ std::cout << n1 << ' ' << n2 << std::endl; return 0; } } }while(std::next_permutation(&digits[0], &digits[ndigits])); } 

Python shell, size 21, xnor

6446781078^9350512293 

Obtained by brute force in ~27 minutes.

Code used:

#include <iostream> #include <cinttypes> #include <cmath> inline bool check(int64_t a, int64_t b){ int used[10] = {}; do{ auto r = std::div(a,10ll); ++used[r.rem]; a = r.quot; }while(a); do{ auto r = std::div(b,10ll); ++used[r.rem]; b = r.quot; }while(b); if(used[0] > 2) return false; for(int i = 1; i < 10; ++i) if(used[i] != 2) return false; return true; } int main(int argc, char **argv){ int64_t i = 1ll << 32; while(!check(i,i ^ 15788895283ll)) ++i; std::cout << i << ' ' << (i^15788895283ll) << std::endl; } 

This checks every integer starting from 2^32 until it and its matching integer use up all the characters provided.

C++, 244 bytes^?, by Gabe Evans

#include<iostream> int main(){int(CCDD)='%';char(a)[14]={'h','e','l','l','o',22+20/2,'w','o','r','l','d','!'};CCDD+=CCDD<=a[0];{{}};aa:adffillllllnnnnnnnnnnnnooooooooooooorrrrrrrrrssstttttttttttttttuuuuuuuuuuuuwwwwww:cout<<a;} 

It was a bit of a struggle getting all those spare characters out of the way. You can see the code working here.

Insomnia, 14, by n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

e9-i|yig9s pre 

C, size 62, by Olavi Mustanoja

#include<stdio.h> #define _ +8 int*main(){printf("%d",1 _ _);} 

Python, 28, by user3863227

print(int(bin(1234)[2:])**2) 

Factorizing the output gave this one away quite easily:

100220321420320200100 = 2² × 5² × 457² × 2190593² sqrt(100220321420320200100) = 10011010010 int('10011010010',2) = 1234 

Perl - 26 bytes by primo

f:print po=>glob q$t{a,o}$ 

The q was easy to recognise. I took the potato letters away and shuffled the rest to discover glob suddenly. Then, I realised $$ will be used instead of {} and that => can be created. The last thing was f:, it took me a while to think of a label.

CJam, 14, by User23013

92e8.17 5e6.3% 

I started by making some assumptions: that the exponent in each case was a floating point number, and that it had at least one digit after the dot (otherwise it's just the same as using an integer) and one or two before it (otherwise the result would be too small or too large). Then I used Python's itertools library to do some permutations. I got a result in under a minute.

Here's my cracking code:

from itertools import permutations target = 108183.05975155532 def e(mantissa, exponent): return mantissa * 10 ** exponent def ePartition(digits): """Generator function: gives every way to partition digits into an integer mantissa and a floating point exponent that is > 1 and < 100.""" for eIndex in range(1, len(digits) - 1): for dotIndex in range(eIndex + 1, min(len(digits), eIndex + 3)): yield (digits[:eIndex], digits[eIndex:dotIndex] + "." + digits[dotIndex:]) for p in permutations("12356789"): for spIndex in range(3,6): digList1 = "".join(p[:spIndex]) digList2 = "".join(p[spIndex:]) for mant1, expt1 in ePartition(digList1): for mant2, expt2 in ePartition(digList2): value = eval("e(%s,%s)%%e(%s,%s)" % (mant1, expt1, mant2, expt2)) if value == target: print("%se%s %se%s%% -> %s" % (mant1, expt1, mant2, expt2, value)) 

JavaScript, 36, by MegaTom

x=alert;x(("x"+x)["substring"](6,9)) 

Tested in Chrome's console.

Python 2, 13, by mbomb007

71e0//36/0x92 

The output is 0.00684931506849315 on my machine. But it worked on http://repl.it/.

Python, 39 bytes, Reticality

print("{0}{2}{1}{1}{1}".format(0,5,6,)) 

You could also swap the {0} & {2} and the 0 and 6.

JavaScript, 15, by Jamie Barker

Math.sin(1)+'O' 

EZ PZ, as you said. ;)

Python, 13 bytes, by Reticality

To be run on an interactive Python console:

len("printi") 

Outputs 6.

CMD, 9, by unclemeat

set/a!!!0 

There are too few possibilities here. The 4 alphabet characters are most likely command name, so I attack in that direction.

Bash, size 23, by The Wolf

q=echo;_(){ $q $q;};""_ 

I think the original solution (or red herring) should be:

q(){ q=;};q ""echo;$_ $_ 

which is invalid because it has one more space character.

C, size 63, es1024

main(_){int __=_;_<<=_;__=_<<_<<__;printf("%d",_<<__|__);_|__;} 

What I'm trying to get is 2 << 16 | 16. Three leftover underscores, woohoo.                                    

Rust, size 123, by Vi.

fn x(r:int)->int{for i in range(0,2){if i==r/r{{}}else if i==0{}}r%222*912}fn main(){print!("{}",x(993+2))} 

This shouldn't be the intended solution because of the no-op for loop, but it produces no warning in play-pen anyway.

(I'll leave the Clojure part for others.)

PHP, 62, aks.

for($i=1;$i<3.;)echo"$i. ".((($i++==2))?'Tues':'Mon').'day '; 

Quite easy compared to other crazy PHP submissions.

JavaScript, 24 bytes (by fogcityben)

'.+';console.log( 'hi' ) 

Not sure what he really did with that . and +.

Python 3, 21 bytes, Reticality

print(str(...)[4::2]) 

Prints the p and final i from Ellipsis.

Python, size 26, by Oliver

print 2 * 3 * 37037, print 

The 2 prints threw me off a bit.

Python, size 15, by mbomb007

There are at least 5 permutations that work. This is one of them:

`3*.7/50`[::~4] 

It was pretty obvious that the original code was something of the form `«expression»`[«range»], so it wasn't difficult to place the backticks, colons and square brackets. On a hunch, I assumed that the range specifier was [::~i] for some value of i, leaving only 8 characters to permute. This took only a fraction of a second. Here's the code I used:

from itertools import permutations perms = [''.join(p) for p in permutations('03457*./')] for p in perms: try: e = '`'+p[:-1]+'`[::~'+p[-1:]+']' if eval(e)=='6991': print e except: continue 

(The original code is actually a bit flakey, since the result of 3*.7/50 isn't guaranteed to be 0.041999999999999996 all of the time.)

Python, size 30, by mbomb007

Didn't need much unscrambling:

' rsin[~(ddf) 0]rot13'[9+6: :] 

CMD, 21, by unclemeat

set /a!!"echo>>tfile" 

Repeating the set /a trick and ! operator is reducing the search space for otherwise a tough nut to crack.

I'm not too sure how set /a works, but when I evaluate set /a "tfile", it returns 0. Not sure if all strings evaluates to 0, but in this case, we end up evaluating (!!0) >> 0, which is 0.