text:
There is water on my window
The scenario
I drive along a road with my car and it begins to rain. The raindrops are falling on my window randomly and now i ask myself, where is the biggest connected wet area?
The task
To make it easier, the window is split in a matrix of 10*10 squares.
Your job is to find the biggest connected water-drop-area on the window.
Input
There are two possible inputs, you can use a 2-dimensional Array or a 1-dimensional one. You can choose between any inputs like stdin, etc...
Example:
// 2-dimensional:
[[0,1,0,0,0,0,1,0,0,0],
 [0,1,1,0,0,0,0,1,1,0],
 [0,1,1,0,0,0,0,1,0,0],
 [0,1,0,0,0,0,0,0,0,0],
 [0,0,0,0,0,0,0,0,1,0],
 [0,0,0,1,1,0,0,0,1,0],
 [0,0,0,1,1,0,0,0,1,0],
 [0,0,0,0,0,1,1,0,1,0],
 [0,0,0,0,0,1,1,0,1,0],
 [0,0,0,0,0,0,0,0,0,0]]

// 1-dimensional
[0,1,0,0,0,0,1,0,0,0,
 0,1,1,0,0,0,0,1,1,0,
 0,1,1,0,0,0,0,1,0,0,
 0,1,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,1,0,
 0,0,0,1,1,0,0,0,1,0,
 0,0,0,1,1,0,0,0,1,0,
 0,0,0,0,0,1,1,0,1,0,
 0,0,0,0,0,1,1,0,1,0,
 0,0,0,0,0,0,0,0,0,0]

Output
Your code has to put out the size of the biggest connected area and the x- and y-coordinates of the waterdrops which belong to this area in the format "Size: Z Coordinates: (X1,Y1) (X2,Y2) ..."
Example for the previous input:
Size: 6 Coordinates: (1,0) (1,1) (2,1) (1,2) (2,2) (1,3)

The order of the Coordinates doesn't matter.
Rules

Waterdrops are connected, if they touch each other orthogonally
Diagonal connections don't count
There can be many areas and your code has to find the biggest one
An empty field is represented as "0" and a wet field as "1"
Post your solution with a short explanation and the output of the previous input
The shortest code within the next 7 days will win
If there are two areas with the same size, you can choose one

Winner: Ventero with 171 - Ruby

Welcome to Programming Puzzles & Code Golf! I see a few clarifications that could be made in this challenge: 1. What if there are two areas with the same size? 2. Why is "Coordinates" spelled strangely? 3. Why the time limit?

The time limit is simply saying, in 7 days he will determine the winner. this happens often, I dont consider it strange or anything.

I like this question, but a few clarifications are needed (besides the one above): Is stdin okay for taking the input? Also, is the array always 10x10?

And does the output have to be formatted exactly like in the example or can we just dump the size and the coords like 6 1,0 1,1 2,1...?

@Doorknob complaining about a typo? OP is german.

ok this is a bit off topic but I see the term OP everywhere, what does it stand for? XD I used it myself since I figured it means the one that posted the challenge but I want to know what it stands for

@Doorknob I changed it, thank you. The time limit only says, when I will determine the winner but you can still post answers.

I'd say this one is a duplicate of http://codegolf.stackexchange.com/questions/32015/are-you-in-the-biggest-room.

@HackerCow It is only necessary to run in 10x10 arrays. The output has to be formatted and you can choose between any inputs.

@TeunPronk: OP means Original Poster. Look it up in Google :)

@HackerCow No, like i wrote in the Output explanation

@TeunPronk, it could also mean Original Post. So you can say "OP said this", meaning the poster, and "it is stated in the OP that", meaning the post.

Some clarification on what input methods are allowed, exactly, would be great.

@Howard I think these are sufficiently different to still present a challenge once you've completed either one, mostly because this question requires bound checks but isn't variable dimension, but I'd agree they are similar, and as such I've posted my answer to this question as a community wiki.

Ruby, 171 characters
r=eval *$*
u=(0..99).map(&v=->p{-~p*r[p]>0?" (#{r[p]=0;u=p%c=10},#{p/c})"+v[p+c]+v[p-c]+v[u>0?p-1:p]+v[u<9?p+1:p]:""}).max_by &:size
puts"Size: #{u.size/6} Coordinates:"+u

Input via command line parameter as one-dimensional array.
Output for the sample input: Size: 6 Coordinates: (1,0) (1,1) (1,2) (1,3) (2,2) (2,1)
This answer uses a simple flood-fill approach, building a list of coordinates for each raindrop cluster. Most of the code is actually used for bounds checking and I/O.

Python - 192
a=10;g+=[0]*a
def f(k):
 if g[k]:g[k]=0;return" (%d,%d)"%(k/a,k%a)+f(k+a)+f(k-a)+f(k+(k%a<9))+f(k-(k%a>0))
 return''
m=max(map(f,range(100)),key=len)
print"Size: "+`len(m)/6`+" Coordinates:"+m

Input (Paste before the code):
g=[0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,1,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0]

Thanks Calvin's Hobbies for suggested edits!

You can use map(f,range(100)) instead of [f(i)for i in range(100)] to save 8 characters. Also I believe your coordinates are (y, x) not (x, y).

C# - 548 523 522 511 503 476
(under 500... yey)
I'm sure there's lots of room for improvement.
The way I inputted the data was to initialize an array. I didn't include that array in the score (if you think this is cheating I can change the code, but it will add relatively much code because C# isn't great at parsing arrays)
using o=System.Console;using l=System.Collections.Generic.List<int[]>;class P{
static int[,] a ={{0,1,0,0,0,0,1,0,0,0},{0,1,1,0,0,0,0,1,1,0},{0,1,1,0,0,0,0,1,0,0},{0,1,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,1,0},{0,0,0,1,1,0,0,0,1,0},{0,0,0,1,1,0,0,0,1,0},{0,0,0,0,0,1,1,0,1,0},{0,0,0,0,0,1,1,0,1,0},{0,0,0,0,0,0,0,0,0,0}};
static int w=10,h=w,x=0,y;static l t=new l(),m=new l();static void f(int r,int c){if(a[r,c]==1){a[r,c]=0;if(r<h)f(c,r+1);if(r>0)f(c,r-1);if(c<w)f(c+1,r);if(c>0)f(c-1,r);t.Add(new[]{c,r});}}static void Main(){for(;++x<w;)for(y=0;++y<h;){if(a[x,y]==1)f(x,y);if(t.Count>m.Count)m=t.FindAll(r=>true);t.Clear();}o.Write("Size: "+m.Count+" Coordinates: ");m.ForEach(c=>o.Write("({0},{1}) ",c[0],c[1]));}}

Test it at http://ideone.com/UCVCPM
Note: The current version doesn't work in ideone because it doesn't like using l=System.Collections..., so the ideone version is slightly outdated (and longer)
How it works
It basically checks if there is a 1. If it finds one, it uses the Flood Fill algorithm to replace all the adjacent 1's with 0 and adds the replaced coordinates to a temporary list. Afterwards it compares the top list (m) to the temporary list (t) and sets m to t if tcontains more elements.

Mathematica - 180 bytes
This function takes a 2-dimensional array.
Golfed
f@x_:=(c=MorphologicalComponents[x,CornerNeighbors->False];m=Last@SortBy[ComponentMeasurements[c,"Count"],Last];Print["Size: ",Last@m," Coordinates: ",Reverse/@Position[c,m[[1]]]])

Pretty
f@x_ := (
   c = MorphologicalComponents[x, CornerNeighbors -> False];
   m = Last@SortBy[ComponentMeasurements[c, "Count"], Last];
   Print["Size: ", Last@m, " Coordinates: ", Reverse/@Position[c, m[[1]]]]
   );

Example
{0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,1,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0};
w=Partition[%,10];
f@w

Size: 6 Coordinates: {{1,2},{2,2},{2,3},{3,2},{3,3},{4,2}}

The output is slightly anomalous. Mathematica starts indexing at 1 instead of 0, and uses {} to indicate position. Add 2 bytes (-1) if the positions need to be 0-indexed. Add a lot of bytes if they need to use () instead of {} :(
Explanation
f is a function of x. It defines c as a transformation of x, where each (i,j) now equals an integer corresponding to which connected component it belongs to. It involves the main work:
MorphologicalComponents[w, CornerNeighbors -> False] // Colorize

Then m computes how many elements are in each component, sorts them by that number, and takes the last result (meaning, with the most elements). The last line prints the count, and the positions in c of the index contained in m.

Haskell, 246
r=[0..9]
q=[(i,j)|i<-r,j<-r]
t v p@(i,j)|elem p v||notElem p q||g!!j!!i==0=v|1<2=foldr(\(k,l)v->t v(i+k,j+l))(p:v)$zip[-1,0,1,0][0,-1,0,1]
(?)=map
a=t[]?q;(b,c)=maximum$zip(length?a)a
main=putStrLn.unwords$["Size:",show b,"Coordinates:"]++show?c

Input
Two dimension and paste before code as g, for example:
g = [[0, 1, 1, ......, 0], [......], ....]

Ungolfed
field = [
 [0,1,0,0,0,0,1,0,0,0],
 [0,1,1,0,0,0,0,1,1,0],
 [0,1,1,0,0,0,0,1,0,0],
 [0,1,0,0,0,0,0,0,0,0],
 [0,0,0,0,0,0,0,0,1,0],
 [0,0,0,1,1,0,0,0,1,0],
 [0,0,0,1,1,0,0,0,1,0],
 [0,0,0,0,0,1,1,0,1,0],
 [0,0,0,0,0,1,1,0,1,0],
 [0,0,0,0,0,0,0,0,0,0]
 ]
range = [0..9]
positions = [(i, j) | i <- range, j <- range]
directions = zip [-1, 0, 1, 0] [0, -1, 0, 1]
traverse visited pos@(i, j)
  | pos `elem` visited || pos `notElem` positions || field!!j!!i == 0 = visited
  | otherwise = foldr folder (pos:visited) directions
  where folder = (\(di, dj) visited -> traverse visited (i + di, j + dj))
blocks = map (traverse []) positions
(maxCount, maxBlock) = maximum $ zip (map length blocks) blocks
main = putStrLn.unwords $ ["Size:", show maxCount, "Coordinates:"] ++ map show maxBlock

C# 374byte function
This is a heavily modified version of my answer to Are you in the biggest room?. It takes a one-dimensional array of ints, and returns a string in the style required. It works by building up disjoint sets from the input (first loop), tallying the size of each set and finding the largest set (second loop) and then appending any cells in that set to an output string (third loop) which is then returned.
static string F(int[]g){int s=10,e=0,d=s*s,a=0,b=d+1;int[]t=new int[b],r=new int[b];t[d]=d;System.Func<int,int>T=null,k=v=>t[T(v)]=t[v]<d?a:d;T=v=>t[v]!=v?T(t[v]):v;for(;a<d;a++)if(g[a]>0){e=t[a]=a;if(a>s)k(a-s);if(a%s>0)k(a-1);}else t[a]=d;for(;a-->0;)e=r[e]<++r[b=T(a)]&&b<d?b:e;var p="Size: "+r[e]+" Coordinates:";for(;d-->1;)p+=T(d)==e?" ("+d%s+","+d/s+")":"";return p;}

Less golfed (and with test code):
class P
{
    static int[] z = {0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,1,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0};

    static string F(int[]g)
    {
        int s=10,e=0,d=s*s,a=0,b=d+1;

        int[]t=new int[b],r=new int[b];
        t[d]=d;
        System.Func<int,int>T=null,k=v=>t[T(v)]=t[v]<d?a:d;
        T=v=>t[v]!=v?T(t[v]):v;

        for(;a<d;a++)
            if(g[a]>0)
            {
                e=t[a]=a;
                if(a>s)k(a-s);
                if(a%s>0)k(a-1);
            }
            else
                t[a]=d;
        for(;a-->0;)
            e=r[e]<++r[b=T(a)]&&b<d?b:e;

        var p="Size: "+r[e]+" Coordinates:";
        for(;d-->1;)
            p+=T(d)==e?" ("+d%s+","+d/s+")":"";

        return p;
    }

    static void Main()
    {
        System.Console.WriteLine(F(z));
    }
}

This makes me feel bad about my 476 bytes solution :( +1 for you, good sir.

Scala, 420
Hi, my entry takes a 2d array as a List[List[Int]], returns a String
val o=for{(r, y)<-w.zipWithIndex;(v,x)<-r.zipWithIndex;if(v == 1)}yield(x,y);val a=o.flatMap(c=>o.collect{case(x,y)if{(x==c._1+1||x==c._1-1)&&y==c._2^(y==c._2+1||y==c._2-1)&&x==c._1}=>c->(x,y)}).groupBy(_._1).map(n => (n._1->n._2.map(t=>t._2)));val b=a.values.flatMap(v=>v.map(c=>a(c)++v));val l=b.collect{case x if (x.length==b.map(_.length).max)=>x}.head;println(s\"Size: ${l.length} Coordinates: ${l.mkString(" ")}\")

Explanation
Given a window as a List[List[Int]], first we find each "1" and save the coordinates in a list. Next we turn that list into a Map of the coordinate of each "1" to a list the coordinates of every adjacent "1". Then use the adjacency map to transitively link the sub-blobs into blobs, and finally we return the largest blob (and ignoring duplicate blobs since order of the returned coordinates does not matter).
More Readable
 val w = {
  List(//0,1,2,3,4,5,6,7,8,9
    List(0,1,0,0,0,0,1,0,0,0), //0
    List(0,1,1,0,0,0,0,1,1,0), //1
    List(0,1,1,0,0,0,0,1,0,0), //2
    List(0,1,0,0,0,0,0,0,0,0), //3
    List(0,0,0,0,0,0,0,0,1,0), //4
    List(0,0,0,1,1,0,0,0,1,0), //5
    List(0,0,0,1,1,0,0,0,1,0), //6
    List(0,0,0,0,0,1,1,0,1,0), //7
    List(0,0,0,0,0,1,1,0,1,0), //8
    List(0,0,0,0,0,0,0,0,0,0)) //9
}

case class Coord(x: Int, y: Int)

val ones: List[Coord] = for{
  (row, y)   <- w.zipWithIndex
  (value, x) <- row.zipWithIndex
  if (value == 1)
} yield Coord(x,y)

val adjacencyMap: Map[Coord, List[Coord]] = ones.flatMap(keyCoord => ones.collect{
case Coord(adjacentX, adjacentY) if {
    (adjacentX == keyCoord.x + 1 || adjacentX == keyCoord.x - 1) && adjacentY == keyCoord.y ^
    (adjacentY == keyCoord.y + 1 || adjacentY == keyCoord.y - 1) && adjacentX == keyCoord.x
  }  => keyCoord->Coord(adjacentX,adjacentY)
}).groupBy(_._1).map(n => (n._1->n._2.map(t=>t._2) ))

val blobs: Iterable[List[Coord]] = adjacencyMap.values.flatMap(v => v.map(coord => adjacencyMap(coord)++v))

val largestBlob: List[Coord] = blobs.collect{case x if (x.length == blobs.map(b=> b.length).max) => x}.head

println(s"""Size: ${largestBlob.length} Coordinates: ${largestBlob.collect{case Coord(x,y) => (x,y)}.mkString(" ")}""")

Criticism is very much appreciated.

JavaScript (EcmaScript 6) 183 189
A function with array input and string return value. If real output is needed (not clear to me) add 7 bytes for 'alert()'.
W=(a,n=10,x=0)=>(F=p=>a[p]|0&&(a[p]=0,o+=' ('+p%n+','+(p/n|0)+')',1+F(p-n)+F(p+n)+F(p-(p%n>0))+F(p+((p+1)%n>0))),a.map((e,p)=>(t=F(p,o=''))>x&&(x=t,k=o)),'Size: '+x+' Coordinates:'+k)

Test Output
Size: 6 Coordinates: (1,0) (1,1) (1,2) (1,3) (2,2) (2,1)

More readable
W=(a,n=10,x=0)=>
(
  F=p=>
    a[p]|0&&(
      a[p]=0,o+=' ('+p%n+','+(p/n|0)+')',
      1+F(p-n)+F(p+n)+F(p-(p%n>0))+F(p+((p+1)%n>0)) // modulo takes care of not overflowing out of a row
    ),
  a.map((e,p)=>(t=F(p,o=''))>x&&(x=t,k=o)),
  'Size: '+x+' Coordinates:'+k
)

Explanation
Get a single dimension array and an optional parameter with the size of a row. The function works also with different array dimensions, even x!=y.
Pseudo code:
 For each element,
   try to fill.
   During the fill operation build a string with the coordiinates.
   Remember the longest fill and the corresponding string and
 output that at the end.

JavaScript, 273
Function takes array and returns string.  My first attempt was ~500 characters and did not use Flood Fill. This one does.  I'm learning JavaScript so any suggestions would be appreciated.
This function loops through the input array and for each 1 found it starts there and changes all connected to 1s to 0 using the Fill function.  While doing so it remembers the blob with the most 1s.  The Fill function changes the current position to 0 and then calls itself on the position above, to the right, below, and to the left.
function G(m){var B="",b=0;for(var p=0;p<m.length;p++)if(m[p]){var T="",t=0;
Z(p);if(t>b){b=t;B=T;}}return"Size: "+b+" Coordinates:"+B;function Z(p){if(m[p])
{m[p]=0;t++;T+=" ("+p%10+","+Math.floor(p/10)+")";if(p>9)Z(p-10);if(p%10)Z(p-
1);if(p<90)Z(p+10);if(p%10!=9)Z(p+1);}}}

Test here: http://goo.gl/9Hz5OH
Readable Code
var map = [0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
           ...
           0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

function F(map) {

    var bestBlob = "", bestLen=0;
    for (var p = 0; p < map.length; p++)
        if (map[p]) {
            var thisBlob = "", thisLen=0;
            Fill(p);
            if (thisLen > bestLen){
                bestLen=thisLen ; bestBlob = thisBlob;
            }
        }
    return "Size: " + bestLen + " Coordinates:" + bestBlob;

    function Fill(p) {
        if (map[p]) {
            map[p] = 0; thisLen++;
            thisBlob += " (" + p % 10 + "," + Math.floor(p / 10) + ")";
            if (p > 9) Fill(p - 10);
            if (p % 10) Fill(p - 1);
            if (p < 90) Fill(p + 10);
            if (p % 10 != 9) Fill(p + 1);
        }
    }
}


text:
Khinchin's constant to as many decimal places as possible in 64 bytes or less
Khinchin's constant is a curious mathematical constant that, according to Wolfram MathWold, is "notoriously difficult to calculate to high precision".
Here it is to 100 digits:

2.685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697...

Write a program in 64 bytes or less that outputs Khinchin's constant to the maximum number of correct decimal places.

You may not use any built in library constants or functions directly relating to Khinchin's constant. (e.g. Math.Khinchin(precision) is definitely not allowed.)
You may use math libraries to compute logarithms, summations, etc.
You may hardcode all or part of your answer.
Your program must produce finite output and run in less than an hour on a reasonably modern computer (such as those listed here).
You must output to stdout. There is no input.
You may use any characters you want as long as http://mothereff.in/byte-counter registers 64 bytes or less.

Scoring
Your score is the number of successive digits in Khinchin's constant your program outputs correctly, starting with 2.68... You may output incorrect digits but only the last correct digit is counted towards your score.
For example, an output of

2.68545200206530644530971483548179569382038229399446295305115234555721

would score 9 points. One for each of the digits 2 6 8 5 4 5 2 0 0 but nothing after the 2 that should be a 1.

Can you clarify what functions you are banning? The Wiki article says the Hurwitz zeta can be used to compute the constant, is this allowed or not?

@KyleKanos Hurwitz zeta is fine. Something like Math.getKhinchin() would not be allowed.

Why are you allowing hardcoding the entire answer?

@WilliamBarbosa why not? ideally there should be a solution that scores better than 31. if not, well that's unfortunate.

@m.buettner Precisely!

Is unicode allowed? How to count it?

I think 32 bytes limits attempts to compute the number to super-concise languages. I hope that there will be mathematical solutions, not just text-compression.

@xnor Me too. I was considering 64 but felt that might be too freeing...

@xnor: I think the restriction to 32 bytes effectively means that mathematical solutions are impossible.

@KyleKanos and xnor. I am willing to change it, or might it be too late?

@Calvin'sHobbies: While entirely up to you, I think that it'd be bad to change it since you've got two solutions using 32 bytes.

Does extended ASCII still count as 1 byte? And non-printable ASCII?(0x00 to 0x1F)?

You should allow 64b instead of 32, and count all chars as UTF-8 bytes (http://mothereff.in/byte-counter) (=1 to 4 bytes per char depending on the Unicode plane). Also, the existing solutions could easily be adapted to 64b

ASCII doesn't have 256 standard values, only 128

Extended ASCII has 256 @aditsu

@KevinL I don't think there's a standard association between codes and characters for the higher 128, that's where dozens of encodings come in

Tell you what, I'm changing it to what @xem suggested. Sorry if that messes up anyone's progress.

Given that a 64-bit IEEE-754 double can only do 16 decimal digits, the only languages which can compete with hard-coding the answer are those which have concise arbitrary-precision decimals supporting at the very least logarithms. You should disallow hard-coding.

@PeterTaylor I coded a CJam floating-point solution, and let me tell you, limited precision is not the main problem :p

The rules have been updated. 64 bytes is now the max and there is a link that will count your bytes.

@KevinL 154 digits, really?  code please...

My lord, that is literally a horrible constant to compute. x'D

Maple, 200+
The following Maple command computes Khinchin's constant to the requested precision (here, 200 digits):
evalf[200](exp(sum((-1)^k*(2-2^k)*ζ(1,k)/k,k=2..∞)/ln(2)));

This code should work if you copy-paste it into the Maple graphical interface.  The ζ takes two bytes in UTF-8, and the ∞ three, for a total of 62 bytes.
Writing out the ASCII versions of those symbols, even with the trick of using min() instead of infinity, alas, brings the byte count up to 66:
evalf[200](exp(sum((-1)^k*(2-2^k)*Zeta(1,k)/k,k=2..min())/ln(2)));

The number of digits computed can be easily adjusted by changing the number in square brackets after evalf.  On my rather old computer, 200 digits seems to finish in about half an hour; yours might be capable of more.  Note that Maple rounds the result to the requested precision instead of truncating it, so the actual number of matching digits might be somewhat less.
This method of calculating the constant is based on formula (9) from the MathWorld page, cited there to Gosper (1996, pers. comm.):

This was the most efficient method that I managed to (barely) squeeze into 64 bytes or less.

Pretty neat. If only I had Maple :/

CJam - 118
2'."*;TeT?_aN{.i9B*ZEay
G`9~eW}nE=Lr-`B}    )D>9m9"136b

Try it at http://cjam.aditsu.net/
Since stackexchange destroys some of the characters, here's a program that generates the program above; run it first, then run its output:
"2'.\""685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697995153465905288090 136b:c"\"136b"

Explanation:
2 pushes 2
'. pushes the dot
"…" is a string containing the rest of the digits in encoded form
128b converts the string to a number, treating the characters as digits in base 128 (via their ASCII code)

Very nice. Can you explain it a bit?

@KyleKanos added explanation

That's awesome. I should learn CJam one day... Also, I cannot get your online interpreter to work in Opera web browser, though it works on my Firefox. Probably an Opera-issue, but thought I'd mention it.

@KyleKanos I think the issue is GWT doesn't support Opera by default

@aditsu are you sure that what you have is optimal? You have 64-9=55 characters to encode the number, and 55 * log(128) ~= 115.9, so with the 2, shouldn't you be able to hit at least 116?

@KevinL double quotes and some unprintable characters are causing problems, even before stackexchange messes everything up :p

I'm wondering, could anyone beat this within the hour limit using only math but as many characters as they wanted?

@Calvin'sHobbies In 1997 Xavier Gourdon computed the first 110,000 digits in 22 hours using at most a  250MHz processor. So you might be able to compute 1000 times as many digits as this solution in an hour. https://web.archive.org/web/20120218093629/http://pi.lacim.uqam.ca/piDATA/khintchine.txt

@Calvin'sHobbies see this link for a complete program that reportedly calculated 2000 digits in 7 seconds.

Haskell, 5
Well, since nobody's posted a solution using actual maths, I decided I would, even though it's nowhere near as close as the other answers.
main=print$product[(1+1/r/(r+2))**2`logBase`r|r<-[1..99999999]]

This computes 2.6854453689859192, which is a whopping 5 characters of the constant.  Wolfram was right when they said it is "difficult to calculate to high precision".

63 byte program - 1 byte to spare! Nice!

The extra byte could be another 9, but my computer couldn't handle that and even if it could, I'm not sure whether it would result in another accurate digit.

Using Ruby, I basically hit the maximum one could do using this formula, running this in 60 seconds. I got 2.685451312659854: https://tio.run/##KypNqvz/P9vWkEvDUE/P0NjAwNAACDT1chMLqmvyarK1bDUMtQ31DPTz9DXytI00NbW0fBNLMqyscvLTjTTyNGu5ChSy//8HAA

Kona 63
Simple hard-coded answer:
2.68545200106530644530971483548179569382038229399446295305115234

mmm isn't it 63?

@xem: minor typographical error. Fixed. :D

Also works in GNU BC

@DigitalTrauma: Probably works in several other languages too, I just stuck with Kona because I've answered in it before.

Mathematica, 6
(Times@@Rest@ContinuedFraction[Pi,977])^(1.`9/976)

gives
2.68545843

and uses only 50 bytes, so there is some room for finding something better than Pi and using a larger continued fraction, but I'm not sure it'll get a lot better with a runtime of an hour. (Especially since finding a better combination would probably take several days if I'm just using brute force.)
(Of course, you were clever enough to disallow Khinchin~N~2000, where 2000 could be replaced with any number that gives you a result within an hour ;).)

+1 for using meaning of the constant, not just a formula.

wxMaxima 3
An actually computed method!
bfloat(product((1+1/(n*(n+2)))^(log(n)/log(2)),n,1,10000));

After about 25 minutes, it returned
2.681499686663101b0

Now I understand why the Mathematica page stated that. I have 6 characters to play with, but I can't imagine adding 6 0's would (a) run in <60 min and (b) give me a more accurate solution.

Suspicion: Each additional zero adds less than one more correct digit :'(

Python, 64 66
print"2.%i"%int('anljsgqif7gwwwsrntcz7zv2obv6gv5us7fzfwjcaj',36)

Outputs:
2.68545200106530644530971483548179569382038229399446295305115234555

You can cut the space after the print to squeeze in another character.

GNU BC, 5 digits (54 byte program)
An attempt to actually calculate.  GNU BC is horribly slow.  This ran for 53 minutes on an Ubuntu 14.04 VM running on a mid-2012 MacBook Pro Retina.  Strangely it runs faster in the VM than the OSX bare metal - presumably the GNU version is better optimised for this task than the BSD version.
for(k=r=1;r++<10^7;)k*=e(l(1/(r*(r+2))+1)*l(r)/l(2))
k

Output:
2.68544536902156538295

Note:
bc -l needs to be used for e() and l() functions (and setting scale = 20).

CJam floating point calculation - 6
1e8{I{1.II2+*/)I2mL#*}1.?}fI

It fits in the original 32 bytes :)
Running with the java interpreter using java 8, it outputs this after about a minute on my laptop:
2.6854513126595827

The online interpreter would probably take too long.

Python (5)
x=3**.1
p=1
for _ in[1]*10**6:p*=(x//1)**1e-6;x=1/(x%1)
print(p)

Output: 2.6854396408091694
(Output takes ~2 seconds.)
In solidarity with the other math solutions, I'll give an even worse-converging one that computes the geometric mean of the first million continued fraction coefficients of a single arbitrary-ish irrational number that's not of a type known to not work. Actually, I rigged that number by trying a few until I got one that coincided on an extra digit.
Funny thing: I froze my computer and had to do a hard shutdown after trying to shorten this code with the Python golf trick of replacing for _ in[1]*10**6:code with exec("code"*10**6).

Ruby - 73
Unfortunately, you can only convert up to base 36 using to_i in Ruby:
"2.#{"hmegxpkvliy1vaw4lb054ep8wsqwkz2yx9cm9jvc9yfd48j".to_i 36}"

which returns
"2.6854520010653064453097148354817956938203822939944629530511523455572188595"

RPL/2, 7 calculated digits, 61 bytes
'LN(FLOOR(1/X))/(X+1)/LN(2)' { 'X' 1e-9 1 } 1e-7 INT DROP EXP

returns 2.68545210493822 in one minute on my old (intel Core2) laptop.
No Zeta function in RPL/2 as far as I know, this is why I have used the integration (formula 15 from the Mathworld page). In principle the accuracy could be improved by replacing 1e-9 and 1e-7 by smaller number, but I was apparently lacking memory for that.
Of course resorting to the infinite product  solve this point, it looks like
1 1 1e9 FOR I 1 1 I dup 2 + * / + I LN 2 LN / ^ * NEXT

and shall work as is on an HP RPL calc, but it turns out to be two order of magnitude slower (on the laptop, didn't tried on my HP !), and gives only 6 digits.
So the integration algorithm in RPL/2 does quite a good job actually.

Vyxal Ṫ, 145
‛2.»×¯⌐›‟₁⟇⟩ǐ₄cJḣsĖ↓r₍₀⁺¡₴¼ƒ∷⟨\ꜝṁ€∷₃‹ǒ Uẇḋv⁋∇I⌐ah6\⋎'*FǏ₈"ꜝṅė}₃≤

Try it Online!
Uses a base-255 compressed string.

Many repl languages, 61
sorry, didn't find a better solution.
"2.685452001065306445309714835481795693820382293994462953051152"

The rules don't say that the correct number sequence can't be preceded by quotes, so I'm using this. By executing that in a JS console for example, you'll get the same string, including the quotes.

Yes, this valid even with a quote in front. It only matters that the 2.685... is uninterrupted.

ES7, 56
alert`2.6854520010653064453097148354817956938203822939944629531`

source: Stack Exchange

license: 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/

sort: votes


text:
Courier Ception
Courier Ception
The program must accept any string as input and output an pixel image that shows the input string in Courier. All the letters that contain a 'hole' (like abdegopqABDPQR etc) that is surrounded by black pixels must be also filled black.
Input
The Program must be able to accept any ASCII string as input. The input can be any way you want, as long as the program code itself does not have to change in order to accept a different input. (Except for e.g. the filename of the file that is to be read.) No standard loopholes. You can assume that each input contains at least one printable letter.
Output
The output must be a black and white (no gray) pixel graphic that shows the string written in Courier (in black, background white), with the specified 'holes' filled. The fontsize of the whole string must be constant (that means no different scaling for each different letters) so that the full sized letters (e.g. ABCDEFGHIJKLMNOPRSTUVWXYZ but j and Q are bigger) must be at least 10px in height. (You do not have to write it to a file, any kind of display is ok as long as it is generated as pixelgraphics, as e.g. canvas in JavaScript.) Please post this graphic with your answer.
Access to courier.ttf / font libraries is allowed.
The program must as well count the number of black pixels and write it to console or what ever output method prefered in the end.
Score
The score is evaluated as follows: The full program code must be used as input string to your program. The number of black pixels will be your score. Program code that contains non-printable or non-ASCII letters is not allowed. (As well as standard loopholes.) The lower the score the better.

Output is specified as b/w, so no grey pixels allowed. And thank you for asking about the encoding, this is gonna be limited to ASCII because of the font.

There are at least two serious problems which need clarification. Firstly, it's not clear whether the program is allowed access to a Courier.ttf and to font libraries which can use it. Secondly, do you seriously intend to prohibit programs which don't contain non-ASCII characters?

Yes, access to Courier.ttf and font libraries is allowed - it wouldn't make sense otherwise, thank you. I was not able to come up with any major language that does rely on non-ASCII characters - do you know any languages that need non-ASCII characters?

@flawr APL. And in Mathematica you could shorten a few things using Unicode characters.

Is ImageMagick allowed?

@DigitalTrauma I am not familiar with it but after a short glance it looks like something like a library that is available for many languages, so I think that is ok. Or what makes you doubt whether it is allowed?

Do I only have to fill the holes in letters? or would 0 and % be filled too,

No you have to fill all the holes in all characters, so yes, 8°§096#@&%$ have to be filled too.

@flawr Except that °§ are not ASCII.

Mathematica, 4864 pixels
l = ImageData[Binarize[Rasterize[Style[j, FontSize -> 15]], .71]]
i = {{1, 1}}
While[Length[i] > 1 - 1,
 {r, c} = j = i[[1]]; l[[r, c]] = 2; i = i[[2 ;; -1]];
 If[FreeQ[i, {r, c} = J = j + #] && l[[r, c]] == 1,
    i = i~Join~{J}] & /@
  {{1, 1 - 1}, {1 - 1, 1}, {-1, 1 - 1}, {1 - 1, -1}}
 ]
Image[l = l /. 1 -> 1 - 1 /. 2 -> 1]
Count[l, 1 - 1, {2}]

Here is the picture:

In Mathematica when you write a "program" you just write a snippet. So this expects the input stored in j and the last thing it returns is the image and the count. This also spits out a bunch of errors, because I don't do bounds checking on l, but it produces the desired result anyway.
where % refers to said last output.
Thanks to Geobits for the idea for the algorithm. I'm flood-filling the image from the top-left corner with an invalid intensity, then I replace all remaining white pixels with black pixels, and the invalid ones with white ones.
Note that the FreeQ check isn't actually necessary for the program to work correctly, but for it to finish in a reasonable amount of time. If I'd leave it out, I'd actually score about 300 pixels less.

The counting should be part of the program itself! Other than that it's a nice solution, did you calculate which letters (as variable names) use the least number of pixels?

@flawr yes :) (now for all of them) (fixing the counting in a second)

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


text:
Crosswalk Efficiency
A standard road intersection contains 4 sidewalk corners and four crosswalks connecting them. It could also have 2 diagonal walks.
    sRRRRs
    iOOOOi
    dAAAAd
    eDDDDe
side0----1walk
ROAD|\  /|ROAD
ROAD| \/ |ROAD
ROAD| /\ |ROAD
ROAD|/  \|ROAD
side2----3walk
    wRRRRw
    aOOOOa
    lAAAAl
    kDDDDk

Not all 6 crosswalks are needed to let pedestrians get from any corner to any other (assuming no jaywalking). It's better for traffic and cheaper for the highway department if there are fewer crosswalks. However, it is better for pedestrians if they can get across faster.
Let L be the total length of the crosswalks present in the intersection. Assume the intersection is a unit square, so the length of orthogonal walks is 1 and for diagonal walks it's sqrt(2).
Let W be the average distance a pedestrian needs to walk when crossing the intersection. Each corner fills up with pedestrians evenly and each pedestrian at a corner is randomly headed for one of the 3 other corners with equal chance.
When L and W are low we have an efficient intersection. Let E = 1 / (W * L) be the crosswalk efficiency of a particular set of crosswalks. Higher E means more efficient.
Goal
Write a program that takes in a list of present crosswalks and outputs the efficiency.
Input will come from stdin in the form 01 32 21 (for example), which represents an intersection with crosswalks from corners 0 to 1, 3 to 2, and 2 to 1 (in a Z). Output to stdout.
Running your program might look something like
$ crosswalk.mylanguage 01 23
0.0

Scoring
This is code golf. The submission with the fewest characters wins.
Details

Pedestrians always stay on the crosswalks and always take the shortest route.
Pedestrians can change direction where the diagonals meet (and at corners).
If all corners aren't connected take W to be infinity (and E to be 0).
The input crosswalk edges are always unique and there are only up to 6.
The input or corner order doesn't matter. 01 32 21 is the same as 23 21 10.

Given the finite space of possible combinations, are precalculated values allowed?

What is the advantage of changing direction at the diagonals? The path would be longer!

Not if there's not a direct route...

If there are two diagonals, is a pedestrian allowed to change direction at the centre? If so, the best efficency is just the diagonals: 1/(   (2*sqrt(2))*(6*sqrt(2)/6)   )=1/4. Otherwise it is three edges:1/(3* (1+1+1+2+2+3)/6 )=1/5

You may precalculate values for W and L but not for E.  Changing the efficiency function to say E = 1 / (W*W*L) should be doable in only a few extra characters.

@steveverrill Yes, the question says that's fine. And I want you to find the general efficiency, not the max.

What happens if the input is 03 32 so that there's no way to get to or from corner 1?

@ssdecontrol Then W is infinity and E is 0.

Python 3 - 424 characters
This uses precalculated values for W:
u,s=list(map(list,[map(int,x) for x in input().split()])),2**.5
q,p,o,w,e,r=sum(u,[]),(2*s+1)/3,(s+1)/3,(2*s+3)/3,(s+3)/3,(5*s+1)/6
print(.0 if len(set(q))<4 or len(q)<5 and q[0]^q[1]==q[2]^q[3]!=3 else 1/({66:p,80:p,34:w,48:w,42:e,49:e,10:5/3,17:5/3,72:r,65:r,74:o,81:o,73:p,41:(s+2)/2,64:s,18:4/3,82:(s+2)/3,50:(s+6)/6}[sum([(0,1,8,32)[q[x]^q[x+1]] for x in range(0,len(q),2)])]*sum(map(lambda a:(1,s)[a[0]^a[1]==3],u))))

It can be run like this:
echo 32 01 31 | python3 filename.py

Python - 489
Uses all pairs shortest paths.
import re
R=re.sub
exec R("I"," in ",R("F","for ","""s,m,i=sum,map,int
r=2**.5/2
n=1e309
g=[0,1,1,n,r],[1,0,n,1,r],[1,n,0,1,r],[n,1,1,0,r],[r]*4+[0]
f="01021323"
o=lambda v:[list(v[x:x+2])FxIrange(0,len(v),2)]
v=o(f+"04142434")
q=m(sorted,R("12|21","14 24",R("03|30","04 34",raw_input())).split())
r=range(5)
u=[m(i,x)FxIv if x notIq]
l=s(g[i(y)][i(x)]Fy,xIq)
Fy,xIu:g[y][x]=n
FaIr:
 FbIr:
    FcIr:g[b][c]=min(g[b][a]+g[a][c],g[b][c])
w=s(g[i(y)][i(x)]Fy,xIo(f+"0312"))/6.
print 1/(w*l)"""))


text:
Let's have a tank war!
Let's have a tank war!
Partially inspired by Destroy Them With Lazers
Objective
Your task is to control a tank. Move around and shoot other tanks and obstacles in the 2D battlefield. The last tank standing will be the winner!
Map format
Your tank will be on a 2D field based on an n by n grid of unit squares. I will decide what n is based on the number of submissions. Each square can contain only one of:

A tank
A tree
A rock
A wall
Nothing

All obstacles and tanks completely fill their spaces, and they block all shots that hit them from damaging things further down.
Here is an example of a field with #=tank; T=tree; R=rock; W=wall; .=nothing with n=10
.....#....
..T....R..
WWW...WWWW
W......T..
T...R...Ww
W...W.....
W....W...T
WWWWWW...R
W.........
WWWWWWRT..

Coordinates are in the format x, y where x increases left to right and y increases bottom to top. The bottom left space has the coordinate 0, 0. Each tank may move to any empty space and shoot in any direction.
Map Dynamics
Your tank doesn't just have to shoot other tanks! If it shoots something on the map, things can happen.

If a wall is shot at, it will be destroyed after some number of shots, ranging from 1 to 4
If a tree is shot at, it will be destroyed immediately
If a rock is shot at, the shot will pass over it and damage the next thing it hits

Once something is destroyed, it is no longer on the map (it will be replaced with nothing). If a shot destroys an obstacle, it will be blocked and will not damage anything further along its path.
Tank dynamics
Each tank starts with life=100. Each shot at a tank will reduce 20-30 life based on distance. This can be calculated with delta_life=-30+(shot_distance*10/diagonal_map_length) (where diagonal_map_length is (n-1)*sqrt(2)). Additionally, each tank regenerates 1 life per turn.
Turns
Some number of rounds will be run (I will decide once I have submissions). At the beginning of every round, a map will be generated randomly, and tanks will be placed on it in random empty locations. During every round, each tank will be given a turn, in any arbitrary order. After every tank has been given a turn, they will be given turns again in the same order. The round continues until there is only one tank left. That tank will be the winner, and they will receive 1 point. The game will then go on to the next round.
Once all the rounds have been run, I will post the scores on this question.
During a tank's turn, it may do one of the following

Move up to 3 spaces in a single direction, either horizontally or vertically. If the tank is blocked by an obstacle or another tank, it will be moved as far as possible without going through the obstacle or tank.
Shoot in some direction, represented by a floating point angle in degrees. The x-axis of your tank's local space (horizontally left to right, aka east or TurnAction.Direction.EAST) is 0deg, and angles increase counterclockwise. Shots are inaccurate, and the actual angle of the shot may be 5 degrees greater or less than the angle you choose.
Do nothing.

Turns are not limited in time, but this doesn't mean you can intentionally waste time to hang everything up.
Submissions/Protocol
Each program submitted will control one tank on the field. The control program is in Java, so your programs need to be in Java for now (I will probably write a wrapper for other languages at some point, or you could write your own).
Your programs will implement the Tank interface, which has the following methods:
public interface Tank {
    // Called when the tank is placed on the battlefield.
    public void onSpawn(Battlefield field, MapPoint position);
    // Called to get an action for the tank on each turn.
    public TurnAction onTurn(Battlefield field, MapPoint position, float health);
    // Called with feedback after a turn is executed.
    // newPosition and hit will be populated if applicable.
    public void turnFeedback(MapPoint newPosition, FieldObjectType hit);
    // Called when the tank is destroyed, either by another tank,
    // or because the tank won. The won parameter indicates this.
    public void onDestroyed(Battlefield field, boolean won);
    // Return a unique name for your tank here.
    public String getName();
}

The Battlefield class contains a 2D array of objects (Battlefield.FIELD_SIZE by Battlefield.FIELD_SIZE) which represents things on the battlefield. Battlefield.getObjectTypeAt(...) will give a FieldObjectType for the object at the specified coordinates (one of FieldObjectType.ROCK, FieldObjectType.TREE, FieldObjectType.TANK, FieldObjectType.WALL, or FieldObjectType.NOTHING). If you try to get an object out of range of the map (coordinates <0 or >=Battlefield.FIELD_SIZE) then an IllegalArgumentException will be thrown.
MapPoint is a class for specifying points on the map. Use MapPoint.getX() and MapPoint.getY() to access the coordinates.
EDIT: Some utility methods have been added: MapPoint.distanceTo(MapPoint), MapPoint.angleBetween(MapPoint), Battlefield.find(FieldObjectType), and TurnAction.createShootActionRadians(double) as suggested by Wasmoo.
More info can be found in the javadocs, see section below.
All (public API) classes are under the package zove.ppcg.tankwar.
Control Program
The full source and javadocs of the control program and tank API can be found on my GitHub repo: https://github.com/Hungary-Dude/TankWarControl
Feel free to send pull requests and/or comment if you see a bug or want an improvement.
I have written two sample tank programs, RandomMoveTank and RandomShootTank (the name says it all).
To run your tank, add your fully qualified (package name + class name) tank class to tanks.list (one class per line), edit settings as necessary in zove.ppcg.tankwar.Control (turn delay, whether or not to show a GUI representation of the field, etc), and run zove.ppcg.tankwar.Control. Make sure there are at least 2 tanks on the list, or results are undefined. (Use the sample tanks if necessary).
Your programs will be run on my machine under this control program.
I'll include a link to the source once I write it. Feel free to suggest edits to the source.
Rules

Your submissions must follow the guidelines above
Your programs may not access the filesystem, network, or attempt to attack my machine in any way
Your programs may not attempt to exploit my control program to cheat
No trolling (such as intentionally making your program waste time to hang everything up)
You may have more than one submission
Try to be creative with submissions!
I reserve the right to allow or not allow programs arbitrarily

Good luck!
UPDATE: After fixing the wall teleportation bug and implementing regeneration, I ran the current submissions for 100 rounds with Battlefield.FIELD_SIZE = 30
UPDATE 2: I added the new submission, RunTank, after fooling with Groovy for a bit...
Updated results:
+-----------------+----+
| RandomMoveTank  | 0  |
| RandomShootTank | 0  |
| Bouncing Tank   | 4  |
| Richard-A Tank  | 9  |
| Shoot Closest   | 19 |
| HunterKiller 2  | 22 |
| RunTank         | 23 |
| Dodge Tank      | 24 |
+-----------------+----+

Currently tanks regenerate 1 life per turn. Should that be increased?

Why are MapPoint's x and y floats? Shouldn't they be ints?

Good point. I'm not sure why I decided to make them floats. I'll change them to ints. Edit: updated them to ints, check the repo

If you stand on point 1,1 and shoot with an angle of 0 degrees, the projectile goes in direction EAST, right?

@Manu Yes. I'm sorry if that wasn't clear.

I found a few errors:
Battlefield.java:88 Sometimes obj is null (I think when a tank dies when its move action is pending)
Control.java:151 When tanks simultaneously kill each other, get(0) is invalid

@Wasmoo Fixed, thanks for pointing that out

The most recent change to my tank, shows that it can jump over walls.

Weird... I'll see what's causing that.

Is it allowed to use Groovy instead of Java? It can use Java classes and can be compiled into a .jar file.

@Fels sure, as long as your class implements the Tank interface and can be instantiated with reflection...

It looks like Hunter Killer and Dodge Tank can get into a stand-off where they will move back and forth, but neither one will shoot.
Interestingly, the health-regeneration doesn't work. If it did, Dodge Tank would eventually recover enough health to shoot.

Whoops! I didn't even implement regeneration... Sorry!

If the map generation is random, isn't it possible that one tank spawns surrounded completely by rocks and becomes a sitting duck?

Yes, but the chances are so small they're negligible. When I run the tanks on my machine, if there is some unfair map generation, I will just restart the control program and generate a new map.

One-per-round health regeneration is pretty slow; it will take 20 rounds to recover a single minimum hit, and Shoot Closest can take out about 3 tanks in that time. So if you want healing to count, either the walls need to be stronger (10-20 hits) or the health recovery needs to be higher (5 or so). That way, hiding behind a wall until it's destroyed will grant you another hit.

This straight-forward tank finds the closest enemy tank and shoots at it.
Would be nice if find, distance, and angle were built in, and if createShootAction accepted a double in radians (i.e. the result of angle)
Edit: Class rewritten to include new utility methods
public final class ShootClosestTank implements Tank {

    @Override
    public TurnAction onTurn(Battlefield field, MapPoint position, float health) {
        //Find all the tanks
        List<MapPoint> tanks = field.find(FieldObjectType.TANK);
        tanks.remove(position);

        if (tanks.isEmpty()) return TurnAction.createNothingAction();

        //Calculate closest tank
        MapPoint cPoint = null;
        double cDist = Double.POSITIVE_INFINITY;
        for (MapPoint p : tanks) {
            double dist = position.distanceTo(p);
            if (dist < cDist) {
                cDist = dist;
                cPoint = p;
            }
        }

        //Shoot at closest tank
        return TurnAction.createShootActionRadians(position.angleBetweenRadians(cPoint));

    }

    @Override
    public void onDestroyed(Battlefield field, boolean won) {
        //Sucks to be me
    }

    @Override
    public void onSpawn(Battlefield field, MapPoint position) {
        //No setup
    }

    @Override
    public void turnFeedback(MapPoint newPosition, FieldObjectType hit) {
        //Nothing to update
    }

    @Override
    public String getName() {
        return "Shoot Closest";
    }
}

Would be nice if find, distance, and angle were built in, and if createShootAction accepted a double in radians (i.e. the result of angle) - Great idea, I'll add it in.

HunterKiller
This intelligent hunter will attempt to find a safe position where it can cleanly shoot at exactly one target. (And thus, only one target can shoot it)
Works best when there is lots of cover.
import zove.ppcg.tankwar.*;
import java.util.*;
public final class HunterKiller implements Tank {

    private final int MAX_DEPTH = 2;
    private Battlefield field;
    private List<MapPoint> enemies;
    private MapPoint me;
    private HashMap<MapPoint, MoveNode> nodeMap = new HashMap();

    //A description of how safe the position is from each tank in enemies
    private class Safety extends java.util.ArrayList<Double> {
        public int threats;
        public Safety(MapPoint position) {
            for (MapPoint p : enemies) {
                int obstacles = countObstacles(position, p, false);
                if (obstacles > 0) {
                    add((double) obstacles);
                } else {
                    add(missChance(position.distanceTo(p)));
                    threats++;
                }
            }
        }
    };

    //A description of a move
    private class Move {

        public TurnAction.Direction direction;
        public int distance;
        public MapPoint point;

        public Move(TurnAction.Direction direction, int distance, MapPoint point) {
            this.direction = direction;
            this.distance = distance;
            this.point = point;
        }

        public TurnAction action() {
            return TurnAction.createMoveAction(direction, distance);
        }

        @Override
        public String toString() {
            return direction + " " + distance;
        }
    }

    /**
     * A MoveNode holds a point and all the moves available from that point.
     * The relative safety of the node can be calculated as a function
     * of its depth; ie. this position is safe because we can can move to safety
     */
    private class MoveNode {

        MapPoint point;
        ArrayList<Move> moves;
        ArrayList<Safety> safetyArray = new ArrayList();

        public MoveNode(MapPoint point) {
            this.point = point;
            this.moves = getMoves(point);
        }

        public Safety getSafety(int depth) {
            if (safetyArray.size() <= depth) {
                Safety value;
                if (depth == 0 || this.moves.isEmpty()) {
                    value = new Safety(point);
                } else {
                    ArrayList<Safety> values = new ArrayList();
                    for (Move m : moves) {
                        MoveNode n = nodeMap.get(m.point);
                        if (n == null) {
                            n = new MoveNode(m.point);
                            nodeMap.put(n.point, n);
                        }
                        values.add(n.getSafety(depth - 1));
                    }
                    Collections.sort(values, cmp);
                    value = values.get(0);
                }
                safetyArray.add(depth, value);
            }
            return safetyArray.get(depth);
        }
    }

    /**
     * Find all the points between here and there, excluding those points
     */
    private java.util.ArrayList<MapPoint> path(final MapPoint p1, MapPoint p2) {
        java.util.ArrayList<MapPoint> ret = new ArrayList();
        float tankX = p1.getX();
        float tankY = p1.getY();
        double angle = p1.angleBetweenRadians(p2);
        double maxDistance = p1.distanceTo(p2);
        for (int x = 0; x < Battlefield.FIELD_SIZE; x++) {
            for (int y = 0; y < Battlefield.FIELD_SIZE; y++) {
                float x2 = (float) (((x - tankX) * Math.cos(-angle)) - ((y - tankY) * Math.sin(-angle)));
                float y2 = (float) (((x - tankX) * Math.sin(-angle)) + ((y - tankY) * Math.cos(-angle)));
                if (x2 > 0 && y2 >= -0.5 && y2 <= 0.5) {
                    MapPoint p = new MapPoint(x, y);
                    if (maxDistance > p1.distanceTo(p)) {
                        ret.add(p);
                    }
                }
            }
        }
        Collections.sort(ret, new Comparator<MapPoint>() {
            @Override
            public int compare(MapPoint o1, MapPoint o2) {
                return (int) Math.signum(p1.distanceTo(o2) - p1.distanceTo(o1));
            }
        });
        return ret;
    }

    /**
     * Find the number of obstacles between here and there, excluding those
     * points
     */
    private int countObstacles(MapPoint p1, MapPoint p2, boolean countRocks) {
        java.util.ArrayList<MapPoint> points = path(p1, p2);
        int count = 0;
        for (MapPoint p : points) {
            Object obj = field.getObjectTypeAt(p);
            if (FieldObjectType.NOTHING.equals(obj)
                    || (!countRocks && FieldObjectType.ROCK.equals(obj))
                    || (!countRocks && FieldObjectType.TANK.equals(obj))
                    || p.equals(me)) {
                count += 0;
            } else {
                count += 1;
            }
        }
        return count;
    }

    /**
     * Returns a value between 1.0 and 0.0, where 1.0 is far and 0.0 is close
     */
    private double missChance(double distance) {
        return distance / Battlefield.DIAGONAL_FIELD_SIZE;
    }

    //Returns a list of valid moves from the given position
    private ArrayList<Move> getMoves(MapPoint position) {
        ArrayList<Move> ret = new ArrayList();
        for (TurnAction.Direction d : TurnAction.Direction.values()) {
            for (int i = 1; i <= 3; i++) {
                MapPoint p = d.translate(position, i);
                try {
                    FieldObjectType t = field.getObjectTypeAt(p);
                    if (t != FieldObjectType.NOTHING && !p.equals(me)) {
                        break;
                    }
                    ret.add(new Move(d, i, p));
                } catch (IllegalArgumentException ex) {
                    //Can't move off the map...
                    break;
                }
            }
        }
        return ret;
    }

    //Compares two safeties with a preference for exactly 1 threat
    private Comparator<Safety> cmp = new Comparator<Safety>() {
        @Override
        public int compare(Safety o1, Safety o2) {
            int tc1 = o1.threats;
            int tc2 = o2.threats;
            //Prefer 1 threat
            if (tc2 == 1 && tc1 != 1) {
                return 1;
            }
            if (tc2 != 1 && tc1 == 1) {
                return -1;
            }

            //Prefer fewer threats
            if (tc2 != tc1) {
                return tc1 - tc2;
            }

            //We're splitting hairs here
            //Determine the least safe option
            int ret = -1;
            double s = Double.MAX_VALUE;
            for (Double d : o1) {
                if (d < s) {
                    s = d;
                }
            }
            for (Double d : o2) {
                if (d < s) {
                    ret = 1;
                    break;
                }
                if (d == s) {
                    ret = 0;
                }
            }
            if (tc1 > 1) {
                //Prefer the safest
                return -ret;
            } else {
                //Prefer the least safest
                return ret;
            }
        }
    };

    @Override
    public TurnAction onTurn(Battlefield field, MapPoint position, float health) {
        //Find all the tanks
        List<MapPoint> enemies = field.find(FieldObjectType.TANK);
        enemies.remove(position);
        if (enemies.isEmpty()) {
            return TurnAction.createNothingAction();
        }

        //Set the constants needed for this turn
        this.enemies = enemies;
        this.field = field;
        this.me = position;

        //Create a new NodeMap
        MoveNode n = new MoveNode(position);
        this.nodeMap.clear();
        this.nodeMap.put(position, n);

        //Find the "best" safety within MAX_DEPTH moves
        int depth = 0;
        Safety safety = n.getSafety(0);
        for (depth = 0; depth < MAX_DEPTH; depth++) {
            int lastThreat = safety.threats;
            safety = n.getSafety(depth);
            int newThreat = safety.threats;
            if (newThreat == 1) {
                //Always prefer 1 threat
                break;
            }
            if (depth != 0 && lastThreat - newThreat >= depth) {
                //Prefer fewer threats only if we are much safer;
                //  Specifically, don't move twice for only 1 less threat
                break;
            }
        }

        //Depth == 0         : Only 1 threat; best position
        //Depth == MAX_DEPTH : Many or no threats, but no good moves available
        if (depth > 0 && depth < MAX_DEPTH) {
            //Move towards the better spot
            for (Move m : n.moves) {
                if (nodeMap.get(m.point).getSafety(depth - 1) == safety) {
                    return m.action();
                }
            }
        }

        //We're in a good position, shoot now
        //Calculate tank with most threat
        MapPoint threat = null;
        double biggestThreat = Double.MAX_VALUE;
        for (MapPoint p : enemies) {
            double t = missChance(position.distanceTo(p)) + countObstacles(position, p, false);
            if (t < biggestThreat) {
                biggestThreat = t;
                threat = p;
            }
        }

        return TurnAction.createShootActionRadians(position.angleBetweenRadians(threat));
    }
    public void onDestroyed(Battlefield field, boolean won) {}
    public void onSpawn(Battlefield field, MapPoint position) {}
    public void turnFeedback(MapPoint newPosition, FieldObjectType hit) {}
    public String getName() {
        return "HunterKiller " + MAX_DEPTH;
    }

}

And that's it. I'm spent.

This one is a variant on the Shoot-Closest in that, every other turn, it moves in a direction until it can no longer. It shoots every other turn.
It has a handy utility, path, which can be used to identify all points (and thus objects) between two points.
public final class BouncingTank implements Tank {

    /**
     * Find all the points between here and there, excluding those points
     * @param p1 Here
     * @param p2 There
     * @return
     */
    private java.util.ArrayList<MapPoint> path(MapPoint p1, MapPoint p2) {
        double dist = p1.distanceTo(p2);
        double dx = (p2.getX() - p1.getX()) / dist;
        double dy = (p2.getY() - p1.getY()) / dist;

        java.util.ArrayList<MapPoint> ret = new java.util.ArrayList();
        MapPoint lastP = null;
        for (int i = 0; i < dist; i++) {
            MapPoint p = p1.cloneAndTranslate((int)(i*dx), (int)(i*dy));
            if (p.equals(p1) || p.equals(lastP)) continue;
            if (p.equals(p2)) break;
            ret.add(p);
            lastP = p;
        }
        return ret;
    }

    /**
     * Find the number of legal moves in the given direction
     * @param field
     * @param position
     * @param dir
     * @return
     */
    private int findMoves(Battlefield field, MapPoint position, TurnAction.Direction dir) {
        if (dir == null) return -1;
        int count = 0;
        MapPoint dest = dir.translate(position, Battlefield.FIELD_SIZE);
        java.util.ArrayList<MapPoint> obs = path(position, dest);
        for (MapPoint oMP : obs) {
            try {
                if (FieldObjectType.NOTHING.equals(field.getObjectTypeAt(oMP))) {
                    count++;
                } else {
                    break;
                }
            } catch (IllegalArgumentException ex) {
                break;
            }
        }
        return count;
    }

    /**
     * Finds the direction towards which there are the fewest obstacles
     * @param field
     * @param position
     * @return
     */
    private TurnAction.Direction findDirection(Battlefield field, MapPoint position) {
        TurnAction.Direction ret = null;
        int mostMoves = 0;
        for (TurnAction.Direction d : TurnAction.Direction.values()) {
            int count = findMoves(field, position, d);
            if (count > mostMoves) {
                ret = d;
                mostMoves = count;
            }
        }
        return ret; //Maybe null
    }

    private TurnAction shootClosest(Battlefield field, MapPoint position) {
        //Find all the tanks
        List<MapPoint> tanks = field.find(FieldObjectType.TANK);
        tanks.remove(position);

        if (tanks.isEmpty()) return TurnAction.createNothingAction();

        //Calculate closest tank
        MapPoint cPoint = null;
        double cDist = Double.POSITIVE_INFINITY;
        for (MapPoint p : tanks) {
            double dist = position.distanceTo(p);
            if (dist < cDist) {
                cDist = dist;
                cPoint = p;
            }
        }

        //Shoot at closest tank
        return TurnAction.createShootActionRadians(position.angleBetweenRadians(cPoint));
    }

    private int turnsUntilShoot = 1;
    private TurnAction.Direction moveToward = null;

    @Override
    public TurnAction onTurn(Battlefield field, MapPoint position, float health) {
        //Determine if current direction is valid
        int moves = findMoves(field, position, moveToward);
        if (moves <= 0) {
            moveToward = findDirection(field, position);
            //Determine if we're stuck
            if (moveToward == null) {
                return shootClosest(field, position);
            }
        }

        //Shoot if it's time
        if (turnsUntilShoot == 0) {
            turnsUntilShoot = 1;
            return shootClosest(field, position);
        } else {
            turnsUntilShoot--;
            return TurnAction.createMoveAction(moveToward, Math.min(3, moves));
        }
    }

    public void onDestroyed(Battlefield field, boolean won) {}
    public void onSpawn(Battlefield field, MapPoint position) {}
    public void turnFeedback(MapPoint newPosition, FieldObjectType hit) {}
    public String getName() {
        return "Bouncing Tank";
    }
}

I'm not very good at this but I thought I'd still give it a shot, you know, practice and stuff.
My tank will randomly decide to move or shoot. When it decides to shoot, it'll try to shoot at the nearest available target.
package com.richarda.tankwar;

import zove.ppcg.tankwar.*;

import java.util.Random;
import java.util.ArrayList;

public class RichardATank implements Tank
{
    private String name;

    public RichardATank()
    {
        this.name = "Richard-A Tank";
    }

    /**
     *
     * @param field
     *            The current battlefield, complete with all obstacle and tank
     *            positions
     * @param position
     */
    @Override
    public void onSpawn(Battlefield field, MapPoint position)
    {

    }

    /**
     * The tank will randomly move around and occasionally shoot at the nearest available target.
     *
     * @param field
     *            The current battlefield, complete with all obstacle and tank
     *            positions
     * @param position
     *            The tank's current position
     * @param health
     *            The tank's current health
     * @return
     */
    @Override
    public TurnAction onTurn(Battlefield field, MapPoint position, float health)
    {
        Random r = new Random();
        int n = r.nextInt(2);

        if(n == 1)
        {
            return this.tryShootAtNearestTank(field, position);
        }

        return TurnAction.createMoveAction(TurnAction.Direction.getRandom(), r.nextInt(2) + 1);
    }

    /**
     *
     * @param newPosition
     *            The tank's new position (may not be changed)
     * @param hit
     *            What the tank hit, if it decided to shoot
     */
    @Override
    public void turnFeedback(MapPoint newPosition, FieldObjectType hit)
    {

    }

    /**
     *
     * @param field
     *            The battlefield
     * @param won
     */
    @Override
    public void onDestroyed(Battlefield field, boolean won)
    {

    }

    @Override
    public String getName()
    {
        return this.name;
    }

    /**
     * Try and shoot at the nearest tank
     *
     * @param bf The battlefield
     * @param curTankLocation The current tank's location
     * @return TurnAction the shoot action to the nearest tank
     */
    private TurnAction tryShootAtNearestTank(Battlefield bf, MapPoint curTankLocation)
    {
        MapPoint nearestTankLoc = this.getNearestTankLocation(bf, curTankLocation);

        double firingAngle = curTankLocation.angleBetween(nearestTankLoc);

        return TurnAction.createShootAction((float) firingAngle);
    }

    /**
     * Try to find the nearest tank's location
     *
     * @param bf The battlefield
     * @param curTankLocation The current tank's location
     * @return MapPoint The location of the nearest tank
     */
    private MapPoint getNearestTankLocation(Battlefield bf, MapPoint curTankLocation)
    {
        ArrayList<MapPoint> enemyTankLocations = this.getEnemyTanksOnField(bf, curTankLocation);

        MapPoint nearestTankLoc = null;

        for(MapPoint enemyTankLoc : enemyTankLocations)
        {
            if(nearestTankLoc == null || curTankLocation.distanceTo(enemyTankLoc) < curTankLocation.distanceTo(nearestTankLoc))
            {
                nearestTankLoc = enemyTankLoc;
            }
        }

        return nearestTankLoc;
    }

    /**
     * Get all enemy tanks on the field
     *
     * @param bf The battlefield
     * @param curTankLocation The current tank's location
     * @return ArrayList<MapPoint> A list with all enemy tanks in it
     */
    private ArrayList<MapPoint> getEnemyTanksOnField(Battlefield bf, MapPoint curTankLocation)
    {
        int maxSize = Battlefield.FIELD_SIZE;
        ArrayList<MapPoint> tanks = new ArrayList<MapPoint>();

        for(int i = 0; i < maxSize; i++)
        {
            for(int j = 0; j < maxSize; j++)
            {
                FieldObjectType objType = bf.getObjectTypeAt(i, j);

                if(objType == FieldObjectType.TANK)
                {
                    MapPoint tankLocation = new MapPoint(i, j);

                    if(!tankLocation.equals(curTankLocation))
                    {
                        tanks.add(tankLocation);
                    }
                }
            }
        }

        return tanks;
    }
}

The full code including the control program can be found here.

Try Direction.getRandom()

@ZoveGames Edited it, thanks for the tip.

Dodge Tank
This tank will shoot at the closest tank. Every so often, depending on its health and the last time it moved, it will try to move perpendicular to the closest tank in an attempt to dodge its lasers.
public class DodgeTank implements Tank {

private int lastMove;
@Override
public void onSpawn(Battlefield field, MapPoint position){
    //nada
}
@Override
public TurnAction onTurn(Battlefield field, MapPoint position, float health){
    List<MapPoint> tanks = field.find(FieldObjectType.TANK);
    tanks.remove(position);
    MapPoint nearest= new MapPoint(0,0);
    double dis=Double.POSITIVE_INFINITY;
        for (MapPoint tank: tanks){
            double distance=tank.distanceTo(position);
            if (distance<dis){
                nearest=tank;
                dis=distance;
            }
        }
    if (lastMove*Math.random()+(4-health/25)<5){//Attack
        lastMove++;
        return TurnAction.createShootActionRadians(position.angleBetweenRadians(nearest));
    }
    else {
        lastMove=0;
        double cumulativeAngle=position.angleBetweenRadians(nearest);
        for (MapPoint tank : tanks){
            cumulativeAngle+=position.angleBetweenRadians(tank);
        }
        cumulativeAngle/=tanks.size();
        cumulativeAngle/=(Math.PI/2);
        int dir=(int)Math.floor(cumulativeAngle);
        TurnAction move;
        switch (dir){
            case 0:
                if (position.getX()>2&&field.getObjectTypeAt(position.cloneAndTranslate(-3, 0)).equals(FieldObjectType.NOTHING)){
                    return TurnAction.createMoveAction(TurnAction.Direction.WEST, 3);
                }
                return TurnAction.createMoveAction(TurnAction.Direction.EAST, 3);
            case 1:
                if (position.getY()>2&&field.getObjectTypeAt(position.cloneAndTranslate(0, -3)).equals(FieldObjectType.NOTHING)){
                    return TurnAction.createMoveAction(TurnAction.Direction.SOUTH, 3);
                }
                return TurnAction.createMoveAction(TurnAction.Direction.NORTH, 3);
            case -1:
                if ((position.getY()<(Battlefield.FIELD_SIZE-4))&&field.getObjectTypeAt(position.cloneAndTranslate(0,3)).equals(FieldObjectType.NOTHING)){
                    return TurnAction.createMoveAction(TurnAction.Direction.NORTH, 3);
                }
                return TurnAction.createMoveAction(TurnAction.Direction.SOUTH, 3);
            default:
                if ((position.getX()<(Battlefield.FIELD_SIZE-4))&&field.getObjectTypeAt(position.cloneAndTranslate(3,0)).equals(FieldObjectType.NOTHING)){
                    return TurnAction.createMoveAction(TurnAction.Direction.EAST, 3);
                }
                return TurnAction.createMoveAction(TurnAction.Direction.WEST, 3);
        }
    }
}
@Override
public void turnFeedback(MapPoint newPosition, FieldObjectType hit){
    //Nada
}
@Override
public void onDestroyed(Battlefield field, boolean won){
  //if (won) this.taunt();
  //else this.selfDestruct();
}
@Override
public String getName(){
    return "Dodge Tank";
}
}

This was way more complicated than I thought..
This is my entry in groovy, you need groovy installed and compile it with
groovyc zove\ppcg\tankwar\felsspat\RunTank.groovy

To call it you need to add $GROOVY_HOME/Groovy/Groovy-2.3.4/lib/groovy-2.3.4.jar (or whatever version) to the classpath.
I could send you a compiled .class file and the library if you don't want to install it.
There seems to be a situation where tanks can't see it other, I don't know if that is intended. That caused deadlocks while testing.
Anyway here is RunTank: RunTank boldy advances in the opposite direction of the closest tank if it is the closest tank to the closest tank or more than one tank is within FIELD_SIZE / 3. I hope that makes sense, I'm drunk :)
package zove.ppcg.tankwar.felsspat

import zove.ppcg.tankwar.Battlefield
import zove.ppcg.tankwar.FieldObjectType
import zove.ppcg.tankwar.MapPoint
import zove.ppcg.tankwar.Tank
import zove.ppcg.tankwar.TurnAction
import zove.ppcg.tankwar.TurnAction.Direction

public class RunTank implements Tank {

    @Override
    public TurnAction onTurn(Battlefield field, MapPoint position, float health) {
        def targets = (field.find(FieldObjectType.TANK) - position).sort{ position.distanceTo(it) }

        if (targets) {

            def runDistance = (Battlefield.FIELD_SIZE / 3).toInteger()

            def closeTargets = targets.grep {
                position.distanceTo(it) < runDistance
            }

            if (position.distanceTo(closestEnemy(position, field)) < targets.first().distanceTo(closestEnemy(targets.first(), field))) {
                return run(field, position, targets)
            }

            if (closeTargets.size() > 1) {
                return run(field, position, targets)
            } else  {
                return shootEnemy(position, targets)
            }
        } else {
            println "WTF! Targets: ${field.find(FieldObjectType.TANK)} + Position ${position}"
            return TurnAction.createMoveAction(Direction.getRandom(), 1);
        }

    }

    def shootEnemy(position, targets) {
        return TurnAction.createShootActionRadians(position.angleBetweenRadians(targets.first()))
    }

    def run(field, position, targets) {
        def freePositions = (field.find(FieldObjectType.NOTHING) - position).grep { position.distanceTo(it) <= 3.0 && [0d, 90d, 180d, 270d].contains(position.angleBetween(it))}.sort{position.distanceTo(it)}
        def availablePositions = []
        freePositions.each { targetPosition ->
            def positions = getPositionsBetween(position,targetPosition)
            if (! positions || positions.every { it.equals(FieldObjectType.NOTHING) }) {
                availablePositions.add(targetPosition)
            }
        }
        availablePositions = availablePositions.sort{closestEnemy(it, field)}.reverse()

        if (availablePositions) {
            def targetPosition = availablePositions.first()
            if (targetPosition.distanceTo(closestEnemy(targetPosition, field)) > position.distanceTo(closestEnemy(position, field))) { // Don't move closer to an enemy
                return moveTo(position, targetPosition)
            } else {
                return shootEnemy(position, targets)
            }
        } else {
            return shootEnemy(position, targets)
        }
    }

    def moveTo(position, targetPosition) {
        def distance = position.distanceTo(targetPosition).toInteger()
        switch (position.angleBetween(targetPosition)) {
            case 0d:
                return TurnAction.createMoveAction(TurnAction.Direction.NORTH, distance)
                break

            case 90d:
                return TurnAction.createMoveAction(TurnAction.Direction.EAST, distance)
                break

            case 180d:
                return TurnAction.createMoveAction(TurnAction.Direction.SOUTH, distance)
                break

            case 270d:
                return TurnAction.createMoveAction(TurnAction.Direction.West, distance)
                break

            default:
            println "I'm stupid :("

        }
    }

    def closestEnemy(position, field) {
        return field.find(FieldObjectType.TANK).sort { position.distanceTo(it) }.first()
    }

    def getPositionsBetween(self, target) {
        def positions = []
        if(self.x == target.x) {
            for (y in self.y..target.y) {
                positions.add(new MapPoint(self.x, y))
            }
        } else {
            for (x in self.x..target.x) {
                positions.add(new MapPoint(x, self.y))
            }
        }
        return positions - self - target
    }

    @Override
    public void turnFeedback(MapPoint newPosition, FieldObjectType hit) {
    }

    @Override
    public void onDestroyed(Battlefield field, boolean won) {
        println ":("
    }

    @Override
    public void onSpawn(Battlefield field, MapPoint position) {
        println "Go!"
    }

    @Override
    public String getName() {
        return "RunTank";
    }
}

I have one suggestion: Add colors to the tank, and a method to implement it. Also labels would be nice in the GUI :)

def RandomMoveTank() {} - is that meant to be there? (I don't know groovy)

No, I copied the RandomMoveTank and forgot to remove the constructor, thanks :)

I compiled your code and added the folder containing the .class files and the groovy jar to my project classpath. Reflection worked! I've posted the updated scores. Your tank did pretty well :)

Nice! And damn you DodgeTank!

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


text:
Print the lyrics to "Twinkle Twinkle Little Star"
Your goal is to print the lyrics to the song "Twinkle Twinkle Little Star" as each note is played.
The computer's microphone will hear notes. If the pitch (but not necessarily the length) of the note is correct, print the appropriate syllable. Otherwise, do nothing. Each note will be at least half a second long, and there will be a break of at least a quarter of a second between notes.
Use the musical notes provided here, and the following lyrics: (Vertical lines represent syllable breaks.)

Twin|kle, twin|kle, lit|tle star,
How I won|der what you are.
Up a|bove the world so high,
Like a dia|mond in the sky.
Twin|kle, twin|kle, lit|tle star,
How I won|der what you are.

A recording of the music can be found here.
Example
The computer hears a middle C and prints "Twin"
It hears another middle C and prints "kle,"
Then it hears another middle C (wrong note) and does nothing.
Then it hears the G above middle C and prints "twin" and so on.
Rules

Punctuation must be as shown.
Spacing must be as shown (with spaces and newlines).
The whitespace may be printed along with either the previous or the next syllable.

Is there any way to relax "must be printed before note ends?" With 1/16 second notes, even if you dedicate 3/4 of that time to sampling, you only have ~47ms of sound to work with. That gives pretty murky frequency resolution for mid-range notes.

@Geobits Good point; I removed that rule.

This is the first puzzle using audio input that I could find!  Congrats!

Is the title mispelled on purpose to differentiate the two twinkles?

@Rusher No, it was a bad mistake on my part. Sorry.

Generally I hear Twinkle, Twinkle, Little Star played at around 120 BPM at its fastest. Perhaps you could relax the requirement to at least 0.4 seconds of the note being played and 0.1 seconds of the note being released, since most renditions will only go as fast as that.

@JoeZ. I relaxed the requirements.

Does punctuation include the vertical bars?

@Charles No; do not output the vertical bars.

Could we have a link to an audio file for testing?

@Calvin'sHobbies https://en.wikipedia.org/wiki/File:Twinkle_Twinkle_Little_Star_plain.ogg (also linked to in the question)

Python 3 - Partial solution (760 742 734 710 705 657 characters)
(Last edit; I promise)
This seems like a really, pretty, very hard problem (especially recognizing where the notes start or end). Automatic transcription of music seems like an open research topic (not that I know anything about it). So here's a partial solution that doesn't do any note segmentation (eg it prints "Twinkle" all at once when it hears the frequency) and probably only works for that specific ogg file:
A=-52
F=44100
C=4096
import pyaudio as P
import array
import scipy.signal as G
import numpy as N
import math
L=math.log
i=0
j=[9,2,0,2,4,5,7,9]
k=[2,4,5,7]
n=j+k+k+j
w="Twinkle, |twinkle, |little |star,\n|How I |wonder |what you |are.\n|Up a|bove the |world so |high,\n|Like a |diamond |in the |sky.\n".split('|')
w+=w[:8]
e=P.PyAudio().open(F,1,8,1,0,None,0,C)
while i<24:
 g=array.array('h',e.read(C));b=sum(map(abs,g))/C
 if b>0 and 20*L(b/32768,10)>A:
  f=G.fftconvolve(g,g[::-1])[C:];d=N.diff(f);s=0
  while d[s]<=0:s+=1
  x=N.argmax(f[s:])+s;u=f[x-1];v=f[x+1]
  if int(12*L(((u-v)/2/(u-2*f[x]+v)+x)*F/C/440,2))==n[i]+15:print(w[i],end='',flush=1);i+=1

This requires...

Python 3 (tested with 3.3 on Windows 64 bit... should work on Mac/Linux in theroy)
PyAudio (I used the windows binary package from here, since the windows binary packages from the PyAudio page didn't work)
SciPy and NumPy (I used scipy-stack from the same site)

Change the A=-52 (minimum amplitude) on the top line depending on your microphone, ammount of ambient sound, how loud the song is playing, etc. On my microphone, less than -57 seems to pick up a lot of extraneous noise and more than -49 requires you play it very loud.
This could be golfed a LOT more; I'm sure there are ways to save a bunch of characters on the words array in particular. This is my first non-trivial program in python, so I'm not very familiar with the language yet.
I stole the code for frequency detection via autocorrelation from https://gist.github.com/endolith/255291
Ungolfed:
import pyaudio
from array import array
import scipy.signal
import numpy
import math
import sys

MIN_AMPLITUDE = -52
FRAMERATE = 44100

def first(list):
    for i in range(len(list)):
        if(list[i] > 0):
            return i
    return 0

# Based on: https://en.wikipedia.org/wiki/Decibel#Acoustics
def getAmplitude(sig):
    total = 0;
    elems = float(len(sig))
    for x in sig:
        total += numpy.abs(x) / elems
    if(total == 0):
        return -99
    else:
        return 20 * math.log(total / 32768., 10)

# Based on: https://en.wikipedia.org/wiki/Piano_key_frequencies
def getNote(freq):
    return int(12 * math.log(freq / 440, 2) + 49)

# --------------------------------------------------------------------------
# This is stolen straight from here w/ very slight modifications: https://gist.github.com/endolith/255291
def parabolic(f, x):
    return 1/2. * (f[x-1] - f[x+1]) / (f[x-1] - 2 * f[x] + f[x+1]) + x

def getFrequency(sig):
    # Calculate autocorrelation (same thing as convolution, but with
    # one input reversed in time), and throw away the negative lags
    corr = scipy.signal.fftconvolve(sig, sig[::-1], mode='full')
    corr = corr[len(corr)/2:]

    # Find the first low point
    diffs = numpy.diff(corr)

    # Find the next peak after the low point (other than 0 lag). This bit is
    # not reliable for long signals, due to the desired peak occurring between
    # samples, and other peaks appearing higher.
    # Should use a weighting function to de-emphasize the peaks at longer lags.
    start = first(diffs)
    peak = numpy.argmax(corr[start:]) + start
    return parabolic(corr, peak) * (FRAMERATE / len(sig))
# --------------------------------------------------------------------------

# These are the wrong keys (ie it is detecting middle C as an A), but I'm far too lazy to figure out why.
# Anyway, these are what are detected from the Wikipedia .ogg file:
notes = [73,          66,           64,       66,         68,       69,        71,          73,       66,     68,          69,         71,         66,        68,         69,        71      ]
words = ["Twinkle, ", "twinkle, ", "little ", "star,\n",  "How I ", "wonder ", "what you ", "are.\n", "Up a", "bove the ", "world so ", "high,\n", "Like a ", "diamond ", "in the ", "sky.\n"]
notes += notes[:8]
words += words[:8]

pa = pyaudio.PyAudio()
stream = pa.open(format=pyaudio.paInt16, channels = 1, rate = FRAMERATE, input = True, frames_per_buffer = 4096)
idx = 0
while(idx < len(notes)):
    # Read signal
    sig = array('h', stream.read(4096))
    if(getAmplitude(sig) > MIN_AMPLITUDE):
        note = getNote(getFrequency(sig))
        if(note == notes[idx]):
            sys.stdout.write(words[idx])
            sys.stdout.flush()
            idx += 1

I wrote a little syntax help for you. Check lines 14-29 and 80-88. http://pastebin.com/W9XSYwMJ

@Sieg -- Awesome; thanks! Old habits are hard to break;