coder . cl

The Collatz problem is Math problem related to a pair of operations which applied recursively will make a number reach 1 always. «The Collatz conjecture is a conjecture in mathematics named after Lothar Collatz, who first proposed it in 1937. The conjecture is also known as the 3n + 1 conjecture, the Ulam conjecture (after Stanisław Ulam), Kakutani’s problem (after Shizuo Kakutani), the Thwaites conjecture (after Sir Bryan Thwaites), Hasse’s algorithm (after Helmut Hasse), or the Syracuse problem; the sequence of numbers involved is referred to as the hailstone sequence or hailstone numbers, or as wondrous numbers.»

Take any natural number n. If n is even, divide it by 2 to get n / 2. If n is odd, multiply it by 3 and add 1 to obtain 3n + 1. Repeat the process (which has been called “Half Or Triple Plus One”, or HOTPO[4]) indefinitely. The conjecture is that no matter what number you start with, you will always eventually reach 1. The property has also been called oneness.

It was proposed as problem as part of the Project Euler and by Eduardo Díaz on his blog, I have implemented my solution in Haskell, because I want to enhance my skills with this language, to reach the most professional coding on it.

My first solution is as follows, is using recursion and if statements. Where if statements should be avoided, also the colmax function can be reduced and eliminated.

module Main (main) where

import System.Environment

collatz :: Int -> [Int] -> [Int]
collatz 1 xs = xs ++ [1]
collatz n xs = if even n
                  then collatz (n `div` 2) $ xs ++ [n]
               else collatz (n * 3 + 1) $ xs ++ [n]

colmax :: [Int] -> Int -> Int -> Int
colmax [] _ m = m
colmax (x:xs) n m = let r = length $ collatz x []
                        in if r > n
                              then colmax xs r x
                           else colmax xs n m

main :: IO ()
main = do [x] <- getArgs
          print $ colmax [1..(read x)] 0 0

My second solution uses the Haskell features to avoid if statements and some reductions to allow more concise code, mainly due to the lazyness of used functions.

module Main (main) where

import System.Environment
import Data.List
import Data.Ord
import Data.Function

collatz :: Int -> [Int] -> [Int]
collatz n xs | n == 1 = xs ++ [1]
             | even n = collatz (n `div` 2) $ xs ++ [n]
             | otherwise = collatz (n * 3 + 1) $ xs ++ [n]

main :: IO ()
main = do [x] <- getArgs
          print $ fst $ maximumBy (comparing length `on` snd)
            $ fmap (\ x -> (x, collatz x []) ) [1..(read x)]

This code looks really well, and seems to be more clear to understand, mainly due to the inline pointfree lambda expression comparing length `on` snd. So, the code is easy to understand and clear enough. Without if statements and using guards rather than if.