text:
Tips for golfing in Perl?
What general tips do you have for golfing in Perl? I'm looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to Perl (e.g. "remove comments" is not an answer). Please post one tip per answer.

TMTOWTDI
That's the most important Perl golfing tip you need to know. Whenever you're looking at some too-long sequence of characters you absolutely have to have in order to accomplish your task, ask yourself if there isn't some other way to get the same effect using a different feature. There usually is. Here are just a handful:

~~ enforces a scalar context and is 4 chars shorter than scalar.
y///c is one char shorter than length when getting the length of $_.
Need to iterate over the chars in $_? Replace split// with /./gs. (Or use /./g if you also want to skip newlines.) This works with other variables: replace split//,$x with $x=~/./gs.
Every Perl builtin returns something. print returns 1, for example, to indicate successful I/O. If you need to initialize $_ to a true value, for example, $_=print$foo allows you to kill two birds with one stone.
Almost every statement in Perl can be written as an expression, allowing it to be to used in a wider variety of contexts. Multiple statements can be become multiple expressions chained together with commas. Tests can be done with short-circuiting operators ?: && ||, and also with and and or, which do the same thing but with precedence lower than all other operators (including assignment). Loops can be done via map or grep. Even keywords like next, last and return can be used in an expression context, even though they don't return! Keeping these kinds of transformations in mind give you opportunities to replace code blocks with expressions that can be stuffed into a wider variety of contexts.

$_=print"" is shorter than $_=print$foo.

The idea is that you already need to print $foo. Otherwise, $_=1 is much shorter than $_=print"" and has the same effect.

For the third do you mean iterating over the chars in $x? Otherwise you could just do /./gs and /./g.

Abuse Perl's special variables!

As noted in a previous answer $/ and $" are initialized by default to "\n" and " ", respectively.
$, and $\ are both set to undef by default, and are 3 chars shorter.
Setting $\ to a value will cause it to be appended to every print. For example: perl -ple '$\="=".hex.$/' is a handy hex-to-decimal converter.
If you're not reading files from the command-line, you can use the -i command-line switch as an extra channel for inputting a string. Its value will be stored in $^I.
$= forces whatever is assigned to it to be an integer. Try running perl -ple '$_=$==$_' and giving it various inupts. Likewise, $- forces its value to be a non-negative integer (i.e. a leading dash is treated as a non-numeric character).
You can use $. as a boolean flag that is automatically reset to a true (nonzero) value on every iteration of a while(<>) loop.

-n and unmatched curly brackets
It is well known that the command line switch -n can be used to execute the script once for every line.
perl --help says:
  -n                assume "while (<>) { ... }" loop around program

What it doesn't say explicitly is that Perl doesn't just assume a loop around the program; it literally wraps while (<>) { ... } around it.
This way, the following commands are equivalent to each other:
 perl -e 'while(<>){code}morecode'
 perl -ne 'code;END{morecode}'
 perl -ne 'code}{morecode'

-p and unmatched curly brackets
Similarly to the above, the -p switch wraps while (<>) { ... ; print } around the program.
By using unmatched curly brackets, perl -p 'code}{morecode' will only print once after executing code for all lines of input, followed by morecode.
Since $_ is undefined when morecode;print is executed, the output record separator $\ can be abused to print the actual output.
For example
perl -pe '$\+=$_}{'

reads one number per line from STDIN and prints their sum.

I'm assuming you could accomplish this with #!perl -n on the first line, right?

@ASCIIThenANSI: Yes, that is correct. (Sorry for the late answer.)

Giving credit where credit is due, I think I saw the combination of these three tricks (unmatched curly brackets, -p and $\) for the first time in one of @primo's Perl answers. To read his answers is a good Perl tip on its own.

Throwing a }for(...){ in between the braces is often quite handy as well, e.g. http://codegolf.stackexchange.com/a/25632/

One thing I found useful in conjunction with -n is the ||= default value assignment operator. Gets around not being able to assign a value before the loop.

Use $_ to eliminate scalar references. It is the special variable that is used as a default by most functions, and just leaving out parameters is a shortcut to reference this variable.
By changing $n to $_, you can change $n=<>;chop$n;print$n to $_=<>;chop;print
Here, the print function prints the contents of $_ by default, and chop also works on $_.

Is $_=<>; required, doesn't <>; read the line into $_ automatically?

No, I don't think so.  I compared the programs $_=<>;print and <>;print.  The first one repeats back to me what I type, while the other one doesn't.

Oh, thanks, turns out that happens only in cases like print while(<>). Not sure if it's a special case or there's some coherent logic behind it, neither <>'s part in perlop nor while part of perlsyn seem to mention this behaviour.

@sundar while(<>) is a special case, documented in perlsyn, I/O Operators: 'If and only if the input symbol is the only thing inside the conditional of a "while" statement (even if disguised as a "for(;;)" loop), the value is automatically assigned to the global variable $_, destroying whatever was there previously."

Use Perl's special variables where-ever you can, eg:

Use $" instead of " "
Use $/ instead of "\n"

They have the added benefit of being a guaranteed one-character long identifier, with help from the lexer.  This makes it possible to glue it to the keyword following it, as in: print$.for@_
The list of all the special variables is available here: Special Variables

Don't use qw. This is waste of two characters that could be used in better way. For example, don't write the following.
@i=qw(unique value);

Instead use barewords.
@i=(unique,value);

Or if you cannot use barewords, use glob syntax.
@i=<unique value>;

glob syntax can also be used for interesting effects.
@i=<item{1,2,3}>;

Use statement modifiers instead of compound statements.
Compound statements tend to require parentheses for the argument and braces for the block, whereas statement modifiers need neither.
Compare:

$a++,$b++while$n-- vs while($n--){$a++;$b++}
chop$,if$c vs if($c){chop$,}

Note that the last example ties with $c&&chop$,, but starts really shining for most multi-statement operations.  Basically anything that loses operator precedence to &&.

I'm sure some of these have formal names and I'm just not aware of them.

If you have a while loop (or a for loop you can make into a while loop) you can define the "while" after the command: print $n++ while ($n < 10)
If you need to read everything from STDIN into a string: $var = join('',<>)
As CeilingSpy pointed out, using $/ instead of \n is faster in some situations: print ('X'*10) . "\n"; is longer than print ('X'*10) . $/;
Perl's say function is shorter than print, but you'll have to run the code with -E instead of -e
Use ranges like a..z or even aa..zz.  If needed as a string, use join.
Incrementing strings: $z = 'z'; print ++$z; will display aa

That's all I can think of right now.  I may add some more later.

What is print ('X'*10) . $/; supposed to do? For me it prints 0 and no newline.  For one thing, the parentheses become a function-style call argument to print, which binds tighter than ..  And did you mean x instead of * or something?

No parentheses needed in postfix while, join'',<>; also works without them.

Don't use strict.  (don't quote me on this, PCG.SE context kinda matters)  And, more importantly, don't code as if under strict.  The usual suspects:

don't my-declare variables if you can avoid it.  The only variables that really need my are those you want lexically scoped.  That's barely any of them when golfing, where you don't need scope protection and tend to fully control recursion.
don't quote one-word strings: (example).  Do ensure you don't have a function with the same name, though.

print hello won't work. It actually means print hello $_ (print $_ to filehandle hello).

@GlitchMr thanks! (and now I'm bummed, because my point is still valid, just not with print, and now I can't find a nice and short example)

@JB here's a good example: http://codegolf.stackexchange.com/a/8746/3348

Use non-word characters as variable names
Using $% instead of $a can allow you to place the variable name right next to an if, for or while construct as in:
@r=(1,2,3,4,5);$%=4;
print$_*$%for@r
Many can be used, but check the docs and @BreadBox's answer for which ones have magic effects!

Use map when you can't use statement modifiers
If you can't use statement modfiers as per @JB's answer, map might save a byte:
for(@c){} vs. map{}@c;
and is useful if you want to do nested iterations as you can put postfix for loops inside the map.

Use all the magic Regular Expression variables
Perl has magic variables for 'text before match' and 'text after match' so it is possible to split to groups of two with potentially fewer characters:
($x,$y)=split/,/,$_;
($x,$y)=/(.+),(.+)/;
/,/; # $x=$`, $y=$'
# Note: you will need to save the variables if you'll be using more regex matches!

This might also work well as a replacement for substr:
$s=substr$_,1;
/./;# $s=$'

$s=substr$_,4;
/.{4}/;# $s=$'

If you need the contents of the match, $& can be used, eg:
# assume input like '10 PRINT "Hello, World!"'
($n,$c,$x)=split/ /,$_;
/ .+ /; # $n=$`, $c=$&, $x=$'

Replace subs with long names with a shorter name
If you call say print four or more times in your code (this obviously varies with the length of the routine you're calling), replace it with a shorter sub name:
sub p{print@_}p;p;p;p

vs.
print;print;print;print

Replace conditional incrementors/decrementors
If you have code like:
$i--if$i>0

you can use:
$i-=$i>0

instead to save some bytes.

Convert to integer
If you aren't assigning to a variable and so can't use breadbox's tip, you can use the expression 0|:
rand 25 # random float eg. 19.3560355885212

int rand 25 # random int

0|rand 25 # random int

rand 25|0 # random int

~~rand 25 # random int

It's worth noting however than you don't need to use an integer to access an array index:
@letters = A..Z;
$letters[rand 26]; # random letter

redo adds loop behavior to a block without for or while.  {redo} is an infinite loop.

Don't parenthesize function calls.
Perl lets you call a known (core or predeclared) function using the NAME LIST syntax.  This lets you drop the & sigil (if you were still using it) as well as the parentheses.
For example: $v=join'',<>
Full documentation

You can run multiple different statements within nested ternary logic.
Suppose you have a big if-elsif statement. This could be any logic and any number of statements.
if( $_ < 1 ) {
    $a=1;
    $b=2;
    $c=3;
    say $a.$b.$c;
} elsif($_ < 2 ) {
    $a=3;
    $b=2;
    $c=1;
    say $a.$b.$c;
} elsif( $_ < 3) {
    $a=2;
    $b=2;
    $c=2;
    say $a.$b.$c;
}

You can use (cmd1, cmd2, cmd3) inside the ternary operator to run all of the commands.
$_ < 1 ?
    ($a=1,$b=2,$c=3,say$a.$b.$c):
$_ < 2 ?
    ($a=3,$b=2,$c=1,say$a.$b.$c):
$_ < 3 ?
    ($a=2,$b=2,$c=2,say$a.$b.$c):
0; #put the else here if we have one

Here's a dummy example:
perl -nE'$_<1?($a=1,$b=2,$c=3,say$a.$b.$c):$_<2?($a=3,$b=2,$c=1,say$a.$b.$c):$_<3?($a=2,$b=2,$c=2,say$a.$b.$c):0;' <(echo 2)

If you need an alternating boolean
Instead of doing something like $-++%2, use $|--.
Try it online!

Try to use the value of an assignment expression, like so:
# 14 characters
$n=pop;$o=$n&1

# 13 characters, saves 1
$o=($n=pop)&1

This works because $n is 2 characters in Perl. You may change $n to () at no cost, and save 1 semicolon by moving the assignment into the parentheses.

Use the free ; from -n/-p
Thanks to @Neil for letting me know this tip wasn't in the list!
Further to @Dennis' tip of using the implicit code added via -n/-p, a ; is inserted as well and using this to your advantage, you can sometimes save a byte:
Using $; as the final variable:
$a=$_*say$--1?"...":$_-1if$-=$_-1-$a vs. $;=$_*say$--1?"...":$_-1if$-=$_-1-$
Used with a quote-like operator:
s/(.)(.)/$2$1/ vs. s;(.)(.);$2$1
Or used with a list:
pop@a;push@a,/\w+/g;$,="/";/{/&&say@a vs.
pop@;;push@;,/\w+/g;$,="/";/{/&&say@
The only stipulation is that it needs to be the last statement.

Use select(undef,undef,undef,$timeout) instead of Time::HiRes
(Taken from https://stackoverflow.com/a/896928/4739548)
Many challenges require you to sleep with greater precision than integers. select()'s timeout argument can do just that.
select($u,$u,$u,0.1)

is much more efficient than:
import Time::HiRes qw(sleep);sleep(0.1)

The former is only 20 bytes, whereas the latter takes up 39. However, the former requires you aren't using $u and have never defined it.
If you're going to use it a lot importing Time::HiRes pays off, but if you only need it once, using select($u,$u,$u,0.1) saves 19 bytes, which is definitely an improvement in most cases.

I don't think this one applies now that the scoring has changed and one can use -MTime::HiRes=sleep for 0 byte cost instead of the previous import statement which had to be counted.

Use expression regexes.
Decent illustration of this is the following code shaping the input into sine wave:
s/./print" "x(sin($i+=.5)*5+5).$&/eg;

As you can see, it's a pretty compact way of iterating over characters in standard input. You could use other regex to change the way how things are matched.

Use globs like string literals
Occasionally (often when dealing with quine or restricted-source challenges) you benefit greatly from the ability to nest string literals. Normally, you'd do this with q(…). However, depending on what characters you need inside the string, you may be able to save a byte and use <…>, the glob operator. (Note that what's inside the angle brackets can't look like a filehandle, and can't look like it's meant to be expanded into a list of filenames, which means that quite a lot of characters won't work correctly.)

Useful escape sequences
See perlrebackslash, but you can potentially save a lot of bytes using these effectively.
In matches:
[A-Za-z]        \pl
[^A-Za-z]       \Pl
(?<=\w)         \B

In replacements (or double quoted strings):
\utext          Text            (e.g s/ (.)/uc$1/e vs. s/ (.)/\u$1/)
\Utext          TEXT
\lTEXT          tEXT
\LTEXT          text

Don't reassign $_ in nested for/maps
If you aren't using m// or s/// in the body of the loop, you can make the most of $' in a nested loop by performing an empty match (//) and using $' instead of assigning $_ to another variable:
$i=$_,say map{qw(0 * +)[max(abs,abs$i)%3]}@;for @;=- --$_..$_

vs.
//,say map{qw(0 * +)[max(abs,abs$')%3]}@;for@;=- --$_..$_

Use sub signatures
If you're submitting a function, using -Mfeature+signatures might save you 4 bytes vs. using @_:
sub{($a,$b)=@_;...}

sub($a,$b){...}

Use hash keys for random ordering.
If a set of items needs to be in a random order, or you need a (pseudo)random subset of items, storing them as hash keys will allow them to be ordered randomly without a call to rand.  The order will remain consistent within a program run as long as no insertions or deletions are made to the hash.
Hash keys can be defined quickly
If the information to be stored/randomized is already in an array, the hash can quickly be created with:
 @hash{@array}++;

The values of the hash are not particularly useful here, but then the array elements can be retrieved in a random order with:
@random_ordered_array = keys %hash;

Shorten your print statements
Unless the challenge specifies otherwise, you don't need trailing newlines.
Our 'challenge' says 'output a random number from 0 to 9 to STDOUT'. We can take this code (28 bytes):
$s=int(rand(10));print"$s\n"

And shorten it to this (25 bytes):
$s=int(rand(10));print $s

by simply printing the variable. This last one only applies to this challenge specifically (19 bytes):
print int(rand(10))

but that only works when you don't have to do anything to the variable in between assignment and printing.

The last one's already listed here.

@Sp3000 Thank you, I've updated my answer.

If you need a variable that is falsy on first call and truthy thereafter
Instead of something like !!$x++, use $|++.
Try it online!

Use s/// to set $_ instead of $_="..."
If you ever need to set an empty $_ to, or add a prefix of, a value that would otherwise require quoting, using s//<value to set>/ can save a byte:
$_="A'B"; # vs:
s//A'B/;

Chain transliterations and substitutions with the /r modifier instead of assigning to $_ first, and directly use the result, rather than using $_ (possibly implicitly) in a separate statement. For example, if your code does:
$_="complex_string";s/pat/repl/;print

# Or when $_ is in use, the even more verbose
$a="complex_string";$a=~/pat/repl/;print$a

you can shave two characters, and free up $_ for other uses, with:
print"complex_string"=~s/pat/repl/r

Arrays become strings become numbers
When needing to do math involving the first element of an array, "@array" will evaluate to the same value as $array[0] and is one byte shorter.  This assumes that the value of $" has not been modified in a way that would join the elements of the array into a single number when concatenated together.
This is because "@array" expands to  $array[0].$".$array[1].$".$array[2]....  When Perl parses a scalar in a numeric context, it stops parsing it after encountering a character that is not part of the number, leaving just the first number in the string to be used as the value.

Two copies of input
The -F and -a give you a split version of your input in @F as well as the complete input in $_.  Both @F and $_ can be used and modified as needed.


text:
Shortest program that demonstrates a language's complete syntax
The Challenge
Write the shortest possible program that demonstrates a programming language's entire syntax: statements, expressions, operators, reserved words, etc.
Take the language's grammar (usually in EBNF) and create a program that uses all of it.
The program doesn't have to do anything particularly useful, but if it does that's a bonus :)
Rules

You must use all of the language's syntax: every type of statement, expression, operator, keyword, etc the language defines.
It must be able to be run with no dependencies, except for the standard library included with the language (it doesn't need to use the entire standard lib though).
Include a link to the language spec you used (e.g. here is the Python 2.7 grammar).

I think the Turing Tarpit entries below demonstrate pretty clearly what a fuzzy idea "complete syntax" is. I'm not sure that this is going anywhere.

Here's one on c#: http://blogs.msdn.com/b/kirillosenkov/archive/2010/05/11/updated-c-all-in-one-file.aspx Very very long because the specification is very big. It also tests things like very long identifiers, which the spec says it needs to handle. Meant to be a stress test for the parse.

@dmckee I had a feeling it was going to go that way. Any suggestions on how it could be less fuzzy?

Not really. Minimal languages are minimal. A nop program written for a oisc would be three words. Define the machine word as a octet and you have a tree byte program, though the machine won't be capable of much.

I wonder if there is code coverage tool for BNF grammars. I can imagine modifying parser generations like yacc and JavaCC to report grammar coverage.

damnit.... java and its banned goto keyword thats blocked in the spec but not used. also native modifier for methods

My language of choice is C++, but I ain't even gonna try ._.

It shouldn't be a problem to omit goto and const for Java, as the two keywords can't be used in valid source code.
Speaking of const, why isn't it treated like final?

I started with a C++ answer, but calculated that I would be unable to finish it before the heat-death of the universe

Jot (2 chars)
10

http://semarch.linguistics.fas.nyu.edu/barker/Iota/#Goedel

Brainfuck:
.[->+<],

with the syntax being:
S=> '.'S|','S|'>'S|'<'S|'-'S|'+'S|'['S']'S|emptyStr

HQ9+ (4 chars)
HQ9+

It will print Hello World, then Quine, then 99 bottles of beer on the wall and then increment accumulator.

Is that really a language? Seems that it doesn't have any logic?

It isn't Turing complete, but is called "programming language" http://esolangs.org/wiki/HQ9+

Unary 1
0

With the syntax being
P => 0+

(syntax is technically more complicated, but I'm too lazy to figure out binary to unary conversion as an EBNF)

Ook
Ook! Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook!

Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook.

Flippin' Ook.  shakes his head

I finished doing that. Let me know if anyone can compile it.

I think you should omit the output. Since the brainfuck poster didn't post theirs. It'd be easier to scroll down this page.

@mbomb007 The output?

The first line is your program. So what's the long part?

Your program is identical to the brainfuck one. So why does your post take so much more space?

@mbomb007 The other program under it takes up more space.

SK combinator calculus (4 chars)
K(S)

Grammar:
E ::= K | S | (E) | EE |

Lambda calculus (9 chars)
λx. (x y)

Grammar
E ::= Letter | (E E) | 'λ' Letter '. ' E
Letter ::= 'a' | 'b' | ... | 'z'

Looks how much more verbose than SK this is!

Lisp (2 chars)
()

Of course, there are built in functions, such as defun and the basic arithmetic functions, but again, those are FUNCTIONS.

Python 2 (13 chars)
Not sure if this is allowed:
exec(input())

Example 1:
Input: 'print "Hello World!"'
Output: Hello World!
Example 2:
Input: 'import math; print math.pi'
Output: 3.14159265359

+1 Most people don't like loopholes for some reason.

The challenge says it "doesn't have to do anything particularly useful, but if it does that's a bonus". This does everything useful, although I'm not sure it meets the requirement that says that "[y]ou must use all of the language's syntax".

Is it you, though, who's using all of the syntax, or the user?

The code does not contain all of the elements of Python's syntax. It only contains two built-in function calls. The code is not dependent on user input; what it does is.

Blub
Blub! Blub. Blub! Blub? Blub! Blub! Blub. Blub? Blub. Blub. Blub? Blub. Blub? Blub! Blub. Blub!

Output:
Blub. Blub. Blub. Blub. Blub! Blub? Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub! Blub! Blub? Blub! Blub. Blub? Blub! Blub? Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub? Blub. Blub! Blub! Blub? Blub! Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub. Blub. Blub. Blub. Blub. Blub. Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub. Blub. Blub? Blub! Blub. Blub. Blub? Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub! Blub.

Also, this page: http://esolangs.org/wiki/TrivialBrainfuckSubstitution says "There are of course, infinitely many members not listed here." So please don't post anymore trivially substitutable programs/languages.

Seed, 3 chars
5 7

This seeds a Mersenne Twister with the number 7 and uses it to create a 5-character Befunge program.

source: Stack Exchange

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

sort: votes


text:
Code Golf: Word Unscrambler
Write a program that either accepts input via stdin or from the command line. It will then unscramble the words, printing out the unscrambled version of each word.You get a text file containing every word (most of them) in the English dictionary to use. (Here is the file: Word List, and you can either use it from the web or save it as a text file and use it from there.)
Inputs to measure the score:

bbuleb lwrfoe kaec rtawe cokr kmli pcaee

Correct Outputs:

bubble flower cake water rock milk peace
bubble fowler cake water cork milk peace

(Word case doesn't matter, and please post your score and outputs along with your code!)
Scoring:
Score = (Amount of correct outputs) x (100 / (Code Length))
The code with the highest score wins!
Edit: This is my first post, please be kind!

Scoring is suboptimal. say 'bubble flower cake water rock milk peace' scores hard-to-beat 213 and yet isn't very interesting.

Many scrambles have multiple correct unscrambles...I mean "opst" could easily be "stop" or "pots" or "post" or "tops".

I notice that all answers so far have loaded the wordlist from the web.  Is there any requirement that the file cannot be local?

@StevenRumbalski No, you can either use it from the web or locally.

I want to repeat dmckee's question: "bbuleb lwrfoe kaec rtawe cokr kmli pcaee" can be decoded as: bubble fowler cake water cork milk peace.  Is this be considered correct output?  If it isn't, it seems that some hard-coding of the requirements into my program would be needed.

You state that "Word case doesn't matter", does that mean that we can assume our inputs are in the same case as the word file (because currently they aren't).

@StevenRumbalski fowler and cork is considered correct output and the inputs can be the same case as the word life. (Will edit the post about the correct outputs)

If the word source is avaliable, why (Amount of correct outputs) in score?

GolfScript, 27 chars, 7 correct outputs ⇒ score ≈ 25.926
n%(\:w;' '%{$:c;w{$c=}?}%n*

GolfScript doesn't have a file I/O operator, so I had to get a bit clever with the input.  Specifically,

the scrambled words should be given on the first input line, separated by spaces, and
the wordlist should be given on the subsequent input lines, one word per line.

The scrambled words and the wordlist need to have the same letter case.
Here's an example invocation from a Unix shell command line, assuming that the code above has been saved as unscramble.gs, the GolfScript interpreter as golfscript.rb and the wordlist as wordlist.txt:
(echo BBULEB LWRFOE KAEC RTAWE COKR KMLI PCAEE; cat wordlist.txt) \
  | ruby golfscript.rb unscramble.gs

This will produce the following output:
BUBBLE
FLOWER
CAKE
WATER
CORK
MILK
PEACE

The way it works is simply by sorting the letters in each input word and selecting the first word in the wordlist that produces the same string when its letters are sorted.  Nearly half of the code is actually just for input parsing (and output formatting): all the real work is done in the {$:c;w{$c=}?}% loop.
Here's a de-golfed version with comments showing how it works:
n %                 # split the input on newlines
( \ :w ;            # pop the first line off the list of lines and assign the rest to w
' ' %               # split the first line on spaces

# apply the following map to each scrambled word:
{
    $ :c ;          # sort the letters in the word and assign the sorted word to c
    w { $ c = } ?   # find the first word in w that, sorted, equals c
} %

n *                 # join the results with newlines for output

Wow, this answer is amazing!

Python 3 / 84 chars / 7 correct outputs / score 8.3333
edit As per clarifications, removed .upper() and considering all 7 ouputs correct.
a=sorted
for b in input().split():print([c for c in open('x')if a(b)==a(c[:-1])][0])

Output:
BUBBLE
FLOWER
CAKE
WATER
CORK
MILK
PEACE

Python, 189 171 156 chars / 6 7 correct outputs / "spirit of the law"
from urllib import*
z=sorted
x=dict((`z(m)`,m)for m in urlopen("http://bit.ly/wZYCmE").read().split())
for n in raw_input().split():print x[`z(n.upper())`]

(It gets "fowler" instead of "flower", both are on the input list and have the same letters.)
Edit: Steven Rumbalski's suggestions
Python, 144 chars / 7 correct outputs / "letter of the law"
for x in raw_input().split():print{620:'bubble',655:'flower',404:'cake',547:'water',431:'rock',429:'milk',510:'peace'}[sum(map(ord,x.lower()))]

x=dict((z(m),m)for m in urlopen("http://bit.lywZYCmE").read().split())

z=lambda p:tuple(sorted(p))

Since you are using Python 2, you can save by taking advantage of backticks.  Have z=sorted, then instead of z(m) use \z(m)``

bash, grep, sed, sort: 144 chars, 144/7=20.57 (all correct)
s(){
echo $1|sed 's/./\n&/g'|sort
}
for w in $*
do
for m in $(egrep "^["$w"]{"${#w}"}$" d)
do
[[ `s $w` = `s $m` ]] &&(echo $m;break)
done
done

d is the filename of the dict; for testing on Linux replace it with $d as d=/usr/share/dict/words and subtract 1 from the filesize, to avoid a local copy.
usage:
./unscramble.sh bbuleb lwrfoe kaec rtawe cokr kmli pcaee
bubble
flower
cake
water
cork
rock
milk
peace

works well with dict/words, so I didn't download anything, lazy me! :)

Perl, 173 characters / 6 correct outputs
use LWP::Simple;
sub e{my$m;$m.=$_ for sort split//,uc$_[0];$m}$_=get"http://bit.ly/wZYCmE";
@x=split/\n/;$_=<>;for(split){$l=$_;for(@x){print"$_ ",$l=''if(e$_)eq e$l}}

 JavaScript, 357 330 chars [node.js] / 7 correct outputs
function g(w,s){return s===+s?g[a=w.toUpperCase().split("").sort().join("")]=g[a]||w:w.split("\n").map(g)&&s.split(" ").map(g).join(" ")}require('http').get({host:'web.mit.edu',path:'/kilroi/Public/bot/wordlist'},function(r){b=[];function f(c){c?b.push(c):console.log(g(b.join(""),process.argv[2]))}r.on('data',f),r.on('end',f)})

Eugh... slightly prettier version below. Doesn't read from stdin (string to check is first command-line argument), but it does fetch the dictionary from the net. The g function receives a string with the dictionary content (w) and a string to check (s); this is the most interesting part I suppose.
(It should theoretically work on any input string, as long as there's a permutation of each word in the dictionary. Oh, and the output is currently upper-case [as it is in the dictionary])
function g(w,s) {
  return s===+s
       ? g[a=w.toUpperCase().split("").sort().join("")] = g[a] || w
       : w.split("\n").map(g) && s.split(" ").map(g).join(" ")
}

require('http').get({host:'web.mit.edu',path:'/kilroi/Public/bot/wordlist'}, function(r) {
  b=[]
  function f(c) {
    c ? b.push(c)
      : console.log(g(b.join(""), process.argv[2]))
  }
  r.on('data',f)
  r.on('end',f)
})

PHP 270bytes Source. SCORE- ?
I'm not sure if if this type of output is accepted, please inform if its wrong.
<?$s=explode(PHP_EOL,file_get_contents('http://bit.ly/wZYCmE'));$n=explode(' ',$argv[1]);for($i=0;$i<count($n);$i++){$f=0;for($j=0;$j<count($s);$j++){$t1=str_split(trim($n[$i]));sort($t1);$t2=str_split($s[$j]);sort($t2);if($t1==$t2){$f++?echo'/':0;echo$s[$j];}}echo' ';}

Run:
php unscramble.php "BBULEB LWRFOE KAEC RTAWE COKR KMLI PCAEE"

Output:
BUBBLE FLOWER/FOWLER CAKE WATER CORK/KROC/ROCK MILK PEACE

It has the right output!

Q,38 chars, 7 correct, 18.42105 points
{1#d(&)1=asc[x]~/:(asc')d:(_)read0`:d}

d is the dictionary file, stored locally in the same working directory.
usage:
{1#d(&)1=asc[x]~/:(asc')d:(_)read0`:d} each ("bbuleb";"lwrfoe";"kaec";"rtawe";"cokr";"kmli";"pcaee")
"bubble"
"flower"
"cake"
"water"
"cork"
"milk"
"peace"

Jelly, 14 bytes, 7 correct outputs ⇒ score = 50 (Feedback appreciated!)
ɠḲ©µ³ḲŒ!f®ḢƊ€K

Try it online! (Long URL)
Feed space-separated dictionary on stdin and space-separated scrambled words as the first argument, e.g. curl http://web.mit.edu/kilroi/Public/bot/wordlist | tr '\n' ' ' | jelly fun unscrambler.j "BBULEB LWRFOE KAEC RTAWE COKR KMLI PCAEE"
ɠḲ©µ³ḲŒ!f®ḢƊ€K
ɠḲ©µ               read the dictionary from stdin splitting on spaces, and save it to the register
    ³Ḳ             split the scrambled word list argument on spaces
            Ɗ      define a function of the previous three links taking an input W:
       Œ!f®        get all permutations of W, and filter it with the dictionary
                   (aka, remove all words in the dictionary that are not permutations of W)
           Ḣ       take the head, so we return just one unscrambled word per scrambled word
              €K    run that Ɗ function on each of the unscrambled words, and split the results with spaces

In Jelly, taking input from whatever source is most convenient, and in whatever form is most convenient, can matter a lot. STDIN is pretty clunky. If you put the dictionary in ⁴ you can get rid of the register (11 bytes); if you take input as lists you get 8 bytes

Zsh, 129 chars / 7 correct outputs ⇒ score ≈ 5.426
for i in $@
do
while read w
do
[[ ${#w} == ${#i} ]]&&[[ ${${(Lo)${(s::)w}}} == ${${(Lo)${(s::)i}}} ]]&&echo $w&&break
done<d
done

Usage:
Save the word list as d in the same directory as the script, and from that directory run
% zsh ./unscramble.zsh bbuleb lwrfoe kaec rtawe cokr kmli pcaee
BUBBLE
FLOWER
CAKE
WATER
CORK
MILK
PEACE

How it works:
(s::) splits into single-character words
(L) lowercases
(o) sorts ascending
Was inspired to try after reading this blog post. Not golf, but a fun survey. (Disclaimer: the article's from one of the other teams at my workplace.)

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

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


text:
add commas to Numbers without String manipulation
This challenge consist in adding commas to numbers every 3 spaces like:
123456789 => 123,456,789

Specifications:

The possible inputs will be 1,000 <= input <= 100,000,000
You can ONLY use Mathematical Operators
(*) You can NOT do string, array, index or character manipulation
You can NOT use any kind of built-in functions that add these commas
The zeros should remain, ex 10000 => 10,000
You need to print/alert/log the output (so "the output is at x
var" is not allowed)

(*) the only exception is when forming/printing the output (but not in a manner that suggest cheating)
Examples
10100 => 10,100
120406 => 120,406
999999999 => 999,999,999

A basic idea on how to get numbers legally:
n = 123456;
m = roundDown(n / 10);//even if ends with .9
d = n - m;//we get the last number

Just to clarify, is 123,45,6 acceptable output for the input 123045006, or do we need to include the leading zeros? I'd assume we do, but if not, I have a very nice 13-char GolfScript solution. :)

@IlmariKaronen we need to use the zeros. I will clarify that (updating)

Integers only or will it have to support floats too?

@elssar you can use floats as long as they don't add the commas for you automatically or something like that

@ajax333221 : commas, by definition, involve a string op, since integers don't come with commas. you want to add commas without string ops ???? cuz even after doing all the division and modulo by 1000 still involves prepending or appending a 1-byte string "," to them.

GolfScript, 13 37 chars
0:|;~{.10%|):|3%''','if@10/.9>}do]-1%

Look, Ma, no arrays!
Well, almost.  The pieces of the output are collected on the stack in right-to-left order, so the final ]-1% is needed to reverse them.  But I assume that's OK, as it counts as "forming/printing the output".
Here's an ungolfed version with comments:
0 :| ;         # initialize the variable | to the value 0
~              # eval the input, turning it from a string into a number

{              # start of loop
  .            # duplicate the number on top of the stack; we'll need it later
  10 %         # take the remainder modulo 10 and leave it on the stack

  | ) :| 3 %   # increment | by one and take the remainder modulo 3 of the result
  '' ',' if    # if the remainder is 0, push a comma onto the stack, else an empty string

  @            # pull the value we saved at the start of the loop to top of the stack
  10 /         # divide it by ten, rounding down
  . 9 >        # check if the result is greater than 9...
} do           # ...and repeat the loop if so

]              # finally, collect the digits and commas off the stack into an array...
-1 %           # ...and reverse it for output

If it weren't for a few pesky details, the following 13-char solution would be pretty hard to beat:
~1000base','*

However, it fails on two counts: it doesn't correctly preserve leading zeros in digit groups, and the built-in base conversion operator base might be considered "array manipulation", since it takes a number and returns an array of digits.

Ps. Here's an older 49-char arrayless solution:
~{.999>}{:^1000%:&9&>99&>+{0}*','^1000/}while]-1%

you used an array. Using strings, character position, indexes or arrays is not allowed

the only exception is when forming/printing the output, the "collect digits and commas" is a formatting operation; no cheating to me. I'm developing a C interpreter of a language derived from GolfScript, which is able to interpret this solution; if you remove the array-related ]-1% part,my lang will output the correct result since it by default "dumps" the stack from top to bottom (it seems to me more natural for a stack oriented lang);the point is that the result is ready, you need just formatting, and this must be allowed or very few solutions would be possible!

You weren't very specific on the output format...
Haskell, 56
reverse.takeWhile(>0).map(`mod`1000).iterate(`div`1000)

example:
GHCi> reverse.takeWhile(>0).map(`mod`1000).iterate(`div`1000)$93842390862398
[93,842,390,862,398]

I don't understand Haskell, but is that array-free?

As array-free as it gets. Only lazy lists, i.e. pointers to functions and to integers. – It also has the leading-zero-problem, though, that requirement came in after my post; I can't fix that without String objects. Or can I? Wait...

Python 2, 86 chars
I figured this warranted a different enough answer. The first answer is for 3.0 only because of the print statement with end=, and this answer because division automatically floors instead of converts to float, and the use of backticks
b=input()
k=0
x=''
while b>0:
 x=`b%10`+x;b/=10;k+=1
 if k%3==0and b>0:x=','+x
print x

Only string manipulation is building the output
edit: by adding 5 characters int(), this program can accept any integer, even above 1 billion. The previous program inserts Ls (python longs) if the number is too large, but is still within the constraints of the challenge. Here is the program that works with any integer:
b=input()
k=0
x=''
while b>0:
 x=`int(b%10)`+x;b/=10;k+=1
 if k%3==0and b>0:x=','+x
print x

-
879612587634598623589762354009
879,612,587,634,598,623,589,762,354,009

AWK, no strings, 84 chars:
{for(p=$0;.1<p/=10;++i);for(;i-->0;printf i&&i%3==0?"%d,":"%d",$0/10**i%10);print""}

Test runs:
% awk -f commas.awk <<< 1230
1,230
% awk -f commas.awk <<< 123012
123,012
% awk -f commas.awk <<< 12301
12,301
% awk -f commas.awk <<< 12301000
12,301,000

C, 136
i,j,k;main(m,n){scanf("%d",&n);for(m=n;n^0;i++,n/=10);k=i%3;while(j++<i)printf("%d%c",(int)(m/pow(10,i-j))%10,j%3==k?',':0);putchar(8);}

I'm curious, why do you say ;n^0; instead of just ;n;?

In C, the ^ operator means xor, so it should evaluate to 0. In this case, with that context, the for loop should never run. Is this a typo?

awk, 47 chars

awk '{for(_=NF-2;1<_;_-=3)$_=","$_}NR' FS= OFS=

10,100
120,406
999,999,999

This is splitting the string into characters (FS=), and looping over character positions to insert ,.  The rules for this question say no string manipulation.

Python, 82 chars
n=input()
x=''
while n>999:x=','+`n/100%10`+`n/10%10`+`n%10`+x;n/=1000
print `n`+x

I can get it shorter (67 chars) with
while n>999:x=',%03d'%(n%1000)+x;n/=1000

Not sure if that's legal.

befunge, 62
&# <v%3-\3%3y+8a$j*d`0:/a\%a:
1`j@>:3%\3/!3*j',,\'0+,1+a8+y

well this code is array free, since befunge itself is array free.

the first line simply reads a number and push every digit into stack.
the second line reads those digits and prints then once at a time. and put commas if needed.

note that if you are trying to run it using rcfunge, you need run using "-Y" option.

Scala 65:
def f(n:Int){if(n<1000)print(n)else{f(n/1000)
print("."+n%1000)}}

Testcode:
val l=List(1,12,123,1234,12345,123456,1234567)
l.foreach(x=>{f(x);println})

JavaScript 104, 99, 90, 81

Edit: I just noticed I also have this missing zeros bug when any group of
  contains 000 ,00X or 0X0. If you see this message, the code below isn't fixed yet

Code:
for(n=0,s="",i=m=1e3,r=0;i<n*m;i*=m)r=~~((n%i-r)/i*m),s=r+(i-m?",":"")+s;alert(s)

Note: change the value of n for different inputs

ah, I just noticed I also have this missing zeros bug when any group of contains like 000 ,001 or 010... I will try to fix this later

I think the input should always count towards the final character count. at least the minimum: n=0; = 4 characters. I could reduce at least 6 characters in both my codes if input lines were free

@Blazer maybe you are right, I will update that. Sorry, this is my second code-golf :)

Python 3, 165 chars
from math import*
b=int(input())
j=10**8
k=l=0
while j>0:
 z=int(floor(b/j));b-=z*j;k+=1;j=floor(j/10)
 if not l:l=z!=0
 if l:print(z,end=','if k%3==0and j>0 else'')

No strings except for '' and ',', no arrays/lists/tuples/dicts, or indexing
edit: nixxed some characters

Not sure how python works, but surely int(floor(x)) is the same as int(x) or floor(x)? And if python is anything like the languages I use, you should be able to change ','if k%3==0and j>0 else'' to ''if k%3&j>0 else',' Also, I think while j>0 can be changed to while j

@Griffin thought int() rounded to the nearest. I guess I'm still learning some small details about Python xD. python's & operator is bitwise, not logical, so it can't be used the same way all the time. the while thing was just me being a noob

floor is essentially truncating after the decimal point, depending on the language int will round or truncate. Either way doing int(floor()) is no different from floor(). In javascript, because of the loose typing ORing by zero will truncate decimals: AAA.BBB | 0 == AAA - this might work for phython... My bad about the bitwise and, at least switch the if statement around so you don't need the ==0

Python 2.6.5, 65 94 chars
n=input()
s=''
while n:
    s=','+str(x)+s if x else','+'000'+s
    n/=1000
print s[1:]

Just used the string to store the output.
*Now preserves zeros

does not preserve zeros. eg: 976235004 = 976,235,4

gah! back to the drawing board.

C, 80 chars
Using recursion within printf to reverse the printing order (recursion handles the least significant digits first, but printing is done when returning, so they're printed last).
n;
p(x) {
    x=n%1000;
    n/=1000;
    printf(n?p(),",%03d":"%d",x);
}
main(){
    p(scanf("%d",&n));
}

You can shave off a few characters if you declare something like v=1000 and use x=n%v; and n/=v.

@GigaWatt ,v=1000 costs 7 chars, saves 6. ,v=1e3 comes out even.


text:
How long until this date?
The idea is this: Write a function to print the length of time from now/today's date (at the time the function is called) until a date supplied as an argument.
Assumptions:

Input date will always be tomorrow or later, in the future.
Input date will never be more than 10 years in the future.

Rules:

Output must be in this format: "[z year(s)], [x month(s)], y day(s) until -Input Date-"
Output time frame (day/month/year) must be pluralized correctly. i.e. 1 month, not 1 months
Input can be in whichever date format you prefer (3/15/12 - March 15, 2012 - 2012.03.15).

Example:
Assuming program is run on March 15, 2012:

Input date of 3/20/12 = 5 days until 3/20/12
NOT Input date of 4/16/12 = 1 month, 1 days until 3/20/12
Input date of 2012.04.20 = 1 month, 5 days until 2012.04.20
NOT Input date of 2012.04.20 = 36 days until 2012.04.20
Input date of 10/31/17 = 5 years, 7 months, 16 days until 10/31/17
Input date of 3/15/13 = 1 year until 3/15/13

This is code golf, so shortest length code wins.
I suppose for the sake of having a deadline, I will be selecting an answer on:
March 23, 2012!
(This is my first CG question, so I'll be happy to correct any question errors on my part!)

Wolfram|Alpha 10 chars: now until <input time>  :p

@Griffin 4 chars: now-<input time>

@PhiNotPi well played, good sir.

Is it okay to say "1 days until 3/16/12"?

@MrZander No. I'll update the question. If the number is 1, then there should be no pluralization.

Welcome to CodeGolf.SE. Every question should be tagged to indicate the class of challenge that is being presented (i.e. if you mean the least characters you want [code-golf]), because we entertain other types of challenges as well, as long as they have an objective winning standard. I'll do this one for you. BTW--Nicely specified.

How to work with leap yeras in answer? In 10 years then will be 2 days error. How long is month?

The month is as long as the calendar month. i.e. February 2012 has 29 days, February 2013 has 28.

R, 99 characters
I know it is sort of cheating, but R is all about its packages and lubridate is so convenient for this kind of tasks!
f=function(x){library(lubridate);cat(show(as.period(interval(mdy("3/15/2012"),mdy(x)))),"until",x)}

Usage:
f("10/31/2017")
[1] 5 years, 7 months and 16 days
5 years, 7 months and 16 days  until 10/31/2017

Python + dateutil, 331 bytes
from dateutil import*
from datetime import*
def f(s):
 if'/'in s:m,y,d=map(int,s.split('/'))
 else:y,m,d=map(int,s.split('.'))
 x=relativedelta.relativedelta(datetime(y,m,d),datetime.now())
 D,M,Y=x.days,x.months,x.years
 return f"{Y} year{'s'*(Y>1)}, "*(Y>0)+f"{M} month{'s'*(M>1)}, "*(M>0)+f"{D} day{'s'*(D>1)} "*(D>0)+"until "+s

VBA: 766 631 Chars
Thanks to mellamokb for helping shorten up the string creation and IIf.
Function k(i)
e=" month"
g="s"
n=Now()
r=Month(n)
s=Month(i)
t=DateSerial(Year(i),s,1)
u=DateSerial(Year(i),s-1,1)
v=Day(n)
w=Day(i)
x=DateSerial(Year(n),r,1)
d=t-u-v+w
For y=0 To 10
If Year(DateAdd("yyyy",-1*y,i))=Year(n) Then Exit For
Next
y=IIf(s=1,y-1,y)
z=s-r
z=IIf(z<0,z+12,z)
For m=0 To z
If Month(DateAdd("m",-1*m,i))=r Then Exit For
Next
d=IIf(v<=w,w-v,d)
m=IIf(v>w,m-1,m)
If y Then a=y & " year" & Left(g,y-1)
a=IIf((m Or d) And y,a & ",",a)
If m Then b=IIf(d,m & e & Left(g,m-1) & ",",m & e & Left(g,m-1))
If d Then c=IIf(d>1,d & " days",d & " day")
k=Trim(Trim(a & " " & b) & " " & c) & " until " & i & "."
End Function

I know VBA definitely does not lend itself to code golfing as well as some other languages, but it's what I'm good (not expert) at. :-)
This has been a fun exercise for me!

It's not entirely VBA's fault, there are some good ways to combine logic in your code :)  For example, If y > 0 Then a = y & " year,":If y > 1 Then a = y & " years," could be combined together to a = y & " year" & Left("s", y - 1) & ","

@mellamokb Very good. I'll take a look at that and repost!

I had an issue with some test cases, namely 1 year, 1 month, 1 day. I have corrected this in the answer. It actually made for shorter code!

And after posting the update, I see that I can change If v < w Then d = w - v:If v = w Then d = 0 to If v <= w Then d = w - v for a savings of an additional 20 characters. I'll update the answer if I have a more significant change to post.

I imagine I can do this better with arrays... I will take another look and possibly add another answer...

I think that you could rewrite this using the DateDiff function to drastically lower your bytecount

PHP, 315 characters
function p($z)
{
list($d,$m,$y)=explode("/",$z);
$d=$d-date("d");
$n=$m-1;
$m=$m-date("m")-($d<0);
$d=$d+($d<0)*($n>7^$n&1)+27+($n-2?3:($y%4?1:($y%100?2:($y%400?1:2))));
$y=$y-date("Y")-($m<0);
$s="s ";
echo ($y?$y." year".$s[$y<2]:"")." ".($m?$m." month".$s[$m<2]:"")." ".($d?$d." day".$s[$d<2]:"")." until ".$z;
}

Usage:
p("11/03/2006");

Takes dates in a dd/mm/yyyy format. I've used Griffin's month length calculation(again), though I had to stick extra brackets in it to make the precedence work properly. I've also left some line-breaks in to make it a little easier to read.

Ruby (213)
takes dates in any format Date.parse accepts. Tried just with yyyy-mm-dd
def u s
t=Date.today
f=Date.parse s
[[0,'year'],[0,'month'],[0,'day']].map{|c,n| while t<f
c+=1
t=t.send"next_#{n}"
end
c,t=c-1,t.send("prev_#{n}")if t>f
[c,n+(c>1??s:'')]*' 'if c>0}.compact*', '+' until '+s
end

to also get weeks, add:
['prev_','next_'].each{|n|Date.send(:define_method,n+'week'){send n+'day',7}}

and [0,'week'], (between month and day). days will then always be < 7

which ruby version are you using.... I tried to run your code on ruby1.9.2p0, but it gives me error uninitialized constant Object::Date (NameError)... I think you are using the Rails Date class

@Rohit 1.9.3, not using Rails stuff. Date rdoc

I saw the doc earlier.. but was confused on the error I was getting... I am still unable to figure out why I am getting this error. I am on windows 7 64-bit, ruby192p0

@rohit try with 193?

PHP, 151 chars
function p($z){$n=date_create(date('Y-m-d'));$d=date_create($z);$i=date_diff($n,$d);print($i->format('%R%y years, %m months, and %a days until '.$z));}

It is missing the plurals and does not count correctly, because format() does not subtract the days from the months... I had a similar solution with PHP as well.

This is my PHP solution, but still lacks of the previously mentioned error: echo date_diff(new DateTime(),new DateTime($argv[1]))->format('%yyears, %mmonths, %a days'); Its 92 chars long, when called on the command line.

JavaScript (ES6), 125 bytes
Since the answer by Paolo used an external library, I shall do the same. Node.js is all about NPM packages and moment + HumanizeDuration is so convenient for this task!
Node environments
m=require('moment'),f=d=>console.log(require('humanize-duration')(m(d).diff(m()),{units:['y','mo','d'],round:1})+' until '+d)

Browser environment
Since the libraries declare global variables, it's actually a bit shorter (102 bytes). It's not clear whether I need to include the script tags required to load in the third-party JavaScript, so I will count the Node one officially.
f=d=>console.log(humanizeDuration((m=moment)(d).diff(m()),{units:['y','mo','d'],round:1})+' until '+d)

CoffeeScript, also 125 bytes
f=(d)->console.log require('humanize-duration')((m=require 'moment')(d).diff(m()),{units:['y','mo','d'],round:1})+' until '+d


text:
Find the minimum edit distance between two strings
Explanation
The edit distance between two strings is a function of the minimum possible number of insertions, deletions, or substitutions to convert one word into another word.
Insertions and deletions cost 1, and substitutions cost 2.
For example, the distance between AB and A is 1, because deletions cost 1 and the only edit needed is the deletion of the B character.
The distance between CAR and FAR is 2, because substitutions cost 2. Another way to look at this is one deletion and one insertion.
Rules
Given two input strings (supplied however is convenient in your language), your program must find the minimum edit distance between the two strings.
You may assume that the strings only contain the characters A-Z and have fewer than 100 characters and more than 0 characters.
This is code golf, so the shortest solution wins.
Sample Test Cases
ISLANDER, SLANDER
> 1
MART, KARMA
> 5
KITTEN, SITTING
> 5
INTENTION, EXECUTION
> 8

I did this in excel in my algorithms class once. Was kinda fun to turn the project in as an .xls document. It actually worked pretty well. I'll see if I can find it.

PHP should win this easily.

@st0le - The built in levenshtein function treats substitutions as one edit (substitute), not two (delete + insert).

brainfuck, 2680
+>>>>>>>>>>>>>>>>>>>>>>++++++>,<[->-----<]>--[+++++++++++++++++++++
+++++++++++>>[->>+<<]>>+<<,--------------------------------]>>[-<<<
+>>>]<<<<[>[-<<+>>]<<<]>[-<<<<<+>>>>>]>[>>],----------[++++++++++>>
[->>+<<]>>+<<,----------]>>[-<<<+>>>]<<<<[>[-<<+>>]<<<]>[-<<+>>]<<[
-<+>>+<]<<<[->+<]>[-<+>>>>+<<<]>>>[-<+>]<[->+>+<<]<[-<+>]<[->+>+<<]
<[-<+>>+<]<[->+<]>>>>>>[-[->>+<<]<<[->>+<<]<<[->>+<<]>>>>>>]<<[->>+
>+<<<]>>>[-<<<+>>>]<[->>+[->+>+<<]<<[->>+<<]>>]>>[-]<[<<]<<<+[->>>+
<<<]>>>[-<+<<+>>>]<<<<<[->>[->>>>[->>+<<]<<[->>+<<]<<[->>+<<]<<[->>
+<<]>>>>]>>[->>>>+<<<<]>>>>[-<<<<+<<+>>>>>>]<<+[->>+<<]>>[-<<+<+>>>
]<<<<<<<<]>>[-]>>[-]>>[-]-[+<<-]+>>>>>>>>>>>>>>>>>[-<+>]<[->+<<<<+>
>>]<<<[->>>>>>[-<+>]<[->+<<<<+>>>]<<<<<<<[-]<<+>>>>>>[-<<<<+>>>>>>>
>>>[-<+>]<[->+>+<<]<<<<<<<<<[->+<]>[->>>>>>>>+<<<<<<<<<+>]<<<[->+<]
>[->>>>>>>>+<<<<<<<<<+>]>>>>>>>>>[-<<<<<+>>>>>]<<<<<[->>+>>>+<<<<<]
>>>>>>>>[-[->>+<<]<<[->>+<<]<<[->>+<<]<<[->>+<<]>>>>>>>>]<<<<<<+>>-
[-<<[-<<<<+>>>>]<<<<[->>+>>+<<<<]>>[->>>>>>[->>+<<]<<[->>+<<]<<[->>
+<<]<<[->>+<<]>>]>>>>]>>[->>+<<]>>[-<<+>>>>+<<]->>-[-[->>+<<]>>]>[-
>+<]>[-<+>>>+<<]<<<[->+<]>[-<+>>>+<<]+[->>[-<<+>>]>>[-<<+>>]<<<<<<+
]<<<<<<[->>>>>>+<<<<<<]>>>>>>>>[-<<<<<<<<+>>>>>>>>]<<<<[->>>>+<<<<]
-<<[-]>>>>>>>>[-<<<<<<<<+>>>>>>>>]<<<<[->>[->>+<<]<<[->>+<<]>>]>>-[
-[->>+<<]>>]<[->+<]>[-<+>>>+<<]+[->>[-<<+>>]<<<<+]>>[-<<+>>]<<<<<<<
<-[+>>[-<<+>>]>>[-<<+>>]>>[-<<+>>]<<<<<<<<-]+>>>[-]<[->+<]>>>[-]<[-
>+<]>>>[-]<[->+<]>>>[->+<]>[-<+>>>>>>>>>>>>>+<<<<<<<<<<<<]>>>>>>>>>
>>>-[-[->>+<<]>>]>[->+<]>[-<+<+>>]<<<<-[+>>[-<<+>>]<<<<-]+>>[-<+>]>
>>>>>>>>[->+<]>[-<+>>>>>>>>>>>+<<<<<<<<<<]>>>>>[->+<]>[-<+>>>>>+<<<
<]>>>>-[-[->>+<<]>>]>[->+<]>[-<+<+>>]<<<<-[+>>[-<<+>>]<<<<-]+>[->-<
]>[-<[-]+>]<[->>>+<<<]>>>[-<<+<+>>>]<<-[+>[->+<]<]<[->>+<-[[-]>[->+
<]>[-<+>>>+<<]+>>[-<<[-]>>]<[->+<]>[-<+>>>+<<]+>>[-<<[-]>>]<[->+<]>
[-<+>>>+<<]+>>[-<<[-]>>]<<[-<<[-]+>>]<<[-<<[-]+>>]<<[-<<[-]+>>]<<<+
>->->>->>-<<<<<]<[->+<]]>[-<+>]>>[-<<<+>>>]<<<[->>>>>>>>>>>>>+<<<<<
<<<<<<<<]>>>>>>>>[->+<]>[-<+>>>>>>>>>+<<<<<<<<]>[->+<]>[-<+>>>>>>>>
>+<<<<<<<<]>>>>>>>>>[->>>+<<<]>>>[-<<+<+>>>]<<<<<[->>>>>+<<<<<]>>>>
>[-<<<<<+<<<+>>>>>>>>]<<<<<<<<+>>>>>>[-[->>+<<]<<[->>+<<]<<[->>+<<]
<<[->>+<<]<<[->>+<<]>>>>>>>>>>]<<<<[-<<[-<<<<<<+>>>>>>]<<<<<<[->>+>
>>>+<<<<<<]>>[->>>>>>>>[->>+<<]<<[->>+<<]<<[->>+<<]<<[->>+<<]<<[->>
+<<]>>]>>>>>>]<<[-]<<[->>>>+<<<<]>>>>>>[-[->>+<<]<<[->>+<<]>>>>]<<[
->>>>>+<<<<<]-[+<<-]+>>>>>>>>>>>>>>>]<<]>>>>>>>>[->+<]<<[->+<]<<[->
+<]>>>>>[-[->>+<<]<<[->>+<<]<<[->>+<<]>>>>>>]<<<<[->>[->>>>+<<<<]>>
>>[-<<+<<+>>>>]<<+[-[->>+<<]<<[->>+<<]<<[->>+<<]>>>>>>]<<<<]>>[-[->
>+<<]>>]>>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>>>[->-[>+>>]>
[+[-<+>]>+>>]<<<<<]>[-]<++++++[->++++++++[->+>+<<<<+>>]<]>>>.<.<<<.

Using dynamic programming, of course.
Input strings should be separated by a space, and followed by a new line. For example:
INTENTION EXECUTION
008

Neatly aligned and very readable - I like it, +1!

Is this a computer language? :O

This is the most confusing submission to this question... +1 just because it's BF.

Brachylog (v2), 14 bytes
⟨⊇⊆⟩jg;?clᵐ-ˡṅ

Try it online!
This question has a surprising lack of golfing language solutions (there's an APL solution, which is a quasi-golfing language, but it doesn't beat the builtin-based solutions). So here's an attempt to get the ball rolling on that.
I'm not really happy with the golfiness of this; there's a lot of plumbing, as is so often the case when a Brachylog answer takes multiple inputs. In order to comprehensively beat the builtin-based solutions, ideally someone would come up with an answer that's shorter than the word "Levenshtein". Anyone feel like giving that a go?
Explanation
⟨⊇⊆⟩jg;?clᵐ-ˡṅ
⟨  ⟩             Find a value that is related to the first and second inputs:
 ⊇                 {the first input} is a non-continguous superstring of it
  ⊆                it is a non-contiguous substring of {the second input}
    j            Concatenate that value to itself
     g           Form a singleton list containing that value
      ;?c        Append the inputs to that list
         lᵐ      Take the length of each of the three elements
           -ˡ    Left fold by subtraction
             ṅ   Multiply the result by -1

The real work is done by the ⟨⊇⊆⟩ at the start, which finds the longest common subsequence of the two inputs (as specified, it just asks for any subsequence, but Brachlog's default tiebreaks will always pick the longest). Let's call the length of this q, and the lengths of the inputs a and b. The edit distance is then equal to a-q+b-q; to edit one into the other, we need to delete from one until we reach the common subsequence, then insert until we reach the other (when editing with insertions and deletions, the order doesn't matter).
After our ⟨⊇⊆⟩, the current implicit variable is a string of length q. Doubling this with j gives us a string of length 2q. After bringing the inputs back into our working value, we have three strings, of lengths [2q, a, b], and can replace these with their lengths. Reducing by subtraction then gives 2q-a-b = -(a-q+b-q), so we simply need to negate the answer to get the edit distance.

Python, 138 148 152 characters
Ok, I knew the principle but had never implemented edit distance before, so here goes:
x,y=raw_input().split()
d=range(99)
for a in x:
 c=d;d=[d[0]+1]
 for b,p,q in zip(y,c[1:],c):d+=[min(d[-1]+1,p+1,q+2*(a!=b))]
print d[-1]

R 51
This reads in two lines from the user (which are the input) and then just uses the adist function to calculate the distance.  Since substitutions cost 2 for this problem we need to add a named vector for the costs parameter for adist.  Since there is also a counts parameter for adist we can only shorten costs to cos so we still have a unique match for the parameter names.
x=readLines(n=2);adist(x[1],x[2],cos=c(i=1,d=1,s=2))

Example use
> x=readLines(n=2);adist(x[1],x[2],cos=c(i=1,d=1,s=2))
MART
KARMA
     [,1]
[1,]    5

This can be reduced to 38 bytes with a bit of golfing...

@Dominic van Essen 8 years later but I'd still like to see your suggestion

Click on the '38 byte' link in the comment!

PHP, 40
Follows the rules as stated, but not the spirit of the rules:
<?=levenshtein($argv[1],$argv[2],1,2,1);

Takes it's two parameters as arguments.  Example calling: php edit_dist.php word1 word2.
Normally levenshtein() considers a substitution as one operation, but it has an overloaded form where the insert/sub/delete weights can be specified.  In this case, its 1/2/1.

APL (90 characters)
⊃⌽({h←1+c←⊃⍵⋄d←h,1↓⍵⋄h,(⊂⍵){y←⍵+1⋄d[y]←⍺{h⌷b=⍵⌷a:⍵⌷⍺⋄1+d[⍵]⌊y⌷⍺}⍵}¨⍳x}⍣(⊃⍴b←,⍞))0,⍳x←⍴a←,⍞

I'm using Dyalog APL as my interpreter, with ⎕IO set to 1 and ⎕ML set to 0. The direct function ({ ... }) computes, given a row as input, the next row in the distance matrix. (It is started with the initial row: 0,⍳x.) The power operator (⍣) is used to nest the function once for each character in the second string (⊃⍴b). After all of that, the final row is reversed (⌽), and its first element is taken (⊃).
Example:
      ⊃⌽({h←1+c←⊃⍵⋄d←h,1↓⍵⋄h,(⊂⍵){y←⍵+1⋄d[y]←⍺{h⌷b=⍵⌷a:⍵⌷⍺⋄1+d[⍵]⌊y⌷⍺}⍵}¨⍳x}⍣(⊃⍴b←,⍞))0,⍳x←⍴a←,⍞
LOCKSMITH
BLACKSMITH
3
      ⊃⌽({h←1+c←⊃⍵⋄d←h,1↓⍵⋄h,(⊂⍵){y←⍵+1⋄d[y]←⍺{h⌷b=⍵⌷a:⍵⌷⍺⋄1+d[⍵]⌊y⌷⍺}⍵}¨⍳x}⍣(⊃⍴b←,⍞))0,⍳x←⍴a←,⍞
GATTTGTGACGCACCCTCAGAACTGCAGTAATGGTCCAGCTGCTTCACAGGCAACTGGTAACCACCTCATTTGGGGATGTTTCTGCCTTGCTAGCAGTGCCAGAGAGAACTTCATCATTGTCACCTCATCAAAGACTACTTTTTCAGACATCTCCTGTAG
AAGTACTGAACTCCTAATATCACCAATTCTTCTAAGTTCCTGGACATTGATCCGGAGGAGGATTCGCAGTTCAACATCAAGGTAAGGAAGGATACAGCATTGTTATCGTTGTTGAGATATTAGTAAGAAATACGCCTTTCCCCATGTTGTAAACGGGCTA
118

Husk, 10 9 bytes
Lṁ-→FnmṖ¹

Try it online!
Inspired by ais523's Brachylog solution, finds the longest common (not necessarily contiguous) subsequence and subtracts it from each string.
I don't like having to repeat Ṗ twice and having to explicitly refer to the two arguments ¹ and ³, but I couldn't find any shorter alternative. Now I'm happy :)
Explanation
Lṁ-→FnmṖ¹     Input: a list containing the two strings
       Ṗ      Get all possible subsequences
      m ¹      for each string
    Fn        Keep only the common ones
   →          Get the last one (which will be the longest)
  -           and subtract it
 ṁ            from each of the inputs, then concatenate the remaining characters
L             Find the length of this

Subtracting the longest common substring for each input results in the lists of characters that need to be deleted/inserted. We concatenate these two lists and get the length to calculate the edit distance.

Jelly, 10 bytes
ŒP€f/ṪLạẈS

Try it online!
A port to Jelly of my Brachylog answer, saving a few bytes through more convenient plumbing and some convenient builtins (and beating the builtin-based practical language answers by being shorter than the word "Levenshtein"). This is a function submission (although it also works as a full program), taking a list of the two strings.
The algorithm is the same: find the longest common subsequence of the two strings, then add together the differences in lengths between the common subsequence and each of the two original strings.
An odd side effect of this algorithm is that it seems to give an internally consistent definition of the edit difference between three or more strings, as well. I'm not sure if that would be useful for anything, but it's nice to know it exists.
Explanation
ŒP€f/ṪLạẈS
  €          On each of the original strings
ŒP             produce all possible subsequences of the string;
   f         take the list of common elements
    /          between the first and second sets of subsequences;
      L      take the length of
     Ṫ         the last of these common elements;
       ạ     take the absolute differences between that and
        Ẉ      the length of each {of the original strings}
         S   and sum them.

Shoutouts to Ẉ here for having an implied "each" in it, thus ensuring that Jelly implicitly finds the correct thing to take the length of (if you write L, "length", rather than Ẉ, "length of each", you get the number of strings you started with which is not helpful).
Jelly sorts the subsequences in order from shortest to longest, and f returns its output in the same order as in its left argument, so the Ṫ is guaranteed to find the longest subsequence. We can save any need to subtract from 0 (like the Brachylog submission does), because we have access to an absolute-difference builtin.

Smalltalk (Smalltalk/X), 34
I am lucky - the standard "String" class already contains levenshtein:
input a, b:
a levenshteinTo:b s:2 k:2 c:1 i:1 d:1

(the additional parameters allow for different weights on substitution, deletion, etc.)
Test run:
#( 'ISLANDER'  'SLANDER'
   'MART'      'KARMA'
   'KITTEN'    'SITTING'
   'INTENTION' 'EXECUTION'
) pairWiseDo:[:a :b|
    a print. ' ' print. b print. ' ' print.
    (a levenshteinTo:b
            s:2 k:2 c:1 i:1 d:1) printCR.
].

->
ISLANDER SLANDER 1
MART KARMA 5
KITTEN SITTING 5
INTENTION EXECUTION 8

Husk, 23 22 21 bytes
`-L+¹³*2▲mλΣz=←¹→)¤*Q

Try it online!
`-+L¹L³*2▲mλΣz=←¹→)¤*Q
`-                      # reversed minus: a-b
  +L¹L³                 # a = length of arg1 + length of arg2
       *2               # b = 2x
         ▲              # maximum value of
          m             # map function to all elements of list
           λ            # function:
            Σ           # sum of
             z=         # elements that are equal between
               ←¹       # sublist 1 and
                 →)     # sublist 2
                    *   # list: cartesian product of
                   ¤ Q  # all sublists of arg1 and arg2

Ruby 1.9, 124
l=->a,b{a[0]?b[0]?[(a[0]==b[0]?-1:1)+l[a[1..-1],b[1..-1]],l[a[1..-1],b],l[a,b[1..-1]]].min+1: a.size: b.size}
puts l[*ARGV]

Golfed version of the slow, recursive Ruby method here, modified to double the weight for substitutions. The fact that it takes 7 characters to remove the first character of a string really hurts, and it'd be cool to replace (a[0]==b[0]?-1:1) with something like -1**a[0]<=>b[0] but the order of operations is not my friend.