I read http://www.mit.edu/~mtikekar/posts/stream-fusion.html and was bored.

Readme.md

Collatz conjecture implemented in some languages

Implementation	Time
clang 3.3	0.40s
luajit 2.0.2	0.86s
GHC 7.6.3	0.49s
Node 0.10.22	2.43s

C

Implementation by Mehul Tikekar.

$ clang -v
clang version 3.3 (tags/RELEASE_33/final)
Target: x86_64-apple-darwin13.0.0
Thread model: posix
$ clang -O3 collatz.c -o collatz
$ time ./collatz 1000000
(329, 837799)
        0.40 real         0.39 user         0.00 sys

Lua

Written by me, equivalent to Mehul Tikekar's Cython implemenation.

$ luajit -v
LuaJIT 2.0.2 -- Copyright (C) 2005-2013 Mike Pall. http://luajit.org/
$ time luajit collatz.lua 1000000
329 837799
        0.86 real         0.85 user         0.00 sys

Haskell

Mehul Tikekar's second implementation, using lenIterWhile (combines the three lists into one without generating any intermediate lists).

$ ghc --version
The Glorious Glasgow Haskell Compilation System, version 7.6.3
$ ghc -O3 -fllvm collatz1.hs
$ time ./collatz1 1000000
(329,837799)
        0.49 real         0.47 user         0.00 sys

JavaScript

Written by me, equivalent to Mehul Tikekar's Cython implemenation.

$ node --version
v0.10.22
$ node -e "console.log(process.versions.v8)"
3.14.5.9
$ time node collatz.js 1000000
[ 329, 837799 ]
        2.43 real         2.37 user         0.03 sys

collatz.c

// cf. http://www.mit.edu/~mtikekar/posts/stream-fusion.html

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
   int max_a0 = atoi(argv[1]); 
   int longest = 0, max_len = 0;
   int a0, len;
   unsigned long a;
   
   for (a0 = 1; a0 <= max_a0; a0++) {
      a = a0;
      len = 0;
      
      while (a != 1) {
         len++;
         a = ((a%2==0)? a : 3*a+1)/2;
      }
      
      if (len > max_len) {
         max_len = len;
         longest = a0;
      }
   }
   printf("(%d, %d)\n", max_len, longest);
   return 0;
}

collatz.js

var collatzLen = function (a0) {
  var a = a0;
  var length = 0;

  while (a != 1) {
    a = (a % 2 == 0 ? a : 3 * a+1) / 2;
    length++;
  }

  return length;
};

var maxLen = function (max_a0) {
  var max_length = 0;
  var longest = 0;
  var length = 0;
  var a0 = 1;

  for (var a0 = 1; a0 < max_a0 + 1; a0++) {
    length = collatzLen(a0);
    if (length > max_length) {
      max_length = length;
      longest = a0;
    }
  }

  return [max_length, longest];
};

console.log(maxLen(+process.argv[2]));

collatz.lua

local function collatzLen(a0)
  local a = a0
  local length = 0

  while a ~= 1 do
    a = (a % 2 == 0 and a or 3 * a+1) / 2
    length = length + 1
  end
  return length
end

local function maxLen(max_a0)
  local max_length = 0
  local longest = 0
  local length = 0
  local a0 = 1
  
  for a0 = 1, (max_a0 + 1) do
    length = collatzLen(a0)
    if length > max_length then
      max_length = length
      longest = a0
    end
  end
  return max_length, longest
end

print(maxLen(tonumber(arg[1])))

collatz1.hs

-- cf. http://www.mit.edu/~mtikekar/posts/stream-fusion.html

import Data.Word
import Data.List
import System.Environment

collatzNext :: Word32 -> Word32
collatzNext a = (if even a then a else 3*a+1) `div` 2

-- new code
collatzLen :: Word32 -> Int
collatzLen a0 = lenIterWhile collatzNext (/= 1) a0

lenIterWhile :: (a -> a) -> (a -> Bool) -> a -> Int
lenIterWhile next notDone start = len start 0 where
    len n m = if notDone n
                then len (next n) (m+1)
                else m
-- End of new code

main = do
    [a0] <- getArgs
    let max_a0 = (read a0)::Word32
    print $ maximum $ map (\a0 -> (collatzLen a0, a0)) [1..max_a0]