haskell/build.sh

@@ -4,6 +4,8 @@ find ./src -name '*.hs' -printf '%T@ %p\n' \
 	| sort -r | head -n1 | cut -d' ' -f2 |  while read file
 do
 	out_file="$(basename "$file" | cut -d'.' -f1)"
+        echo "------------------------------------"
 	echo "Compiling file '${file}' into '${out_file}'"
-	ghc -o "$out_file" "$file"
+	ghc -O2 -i./src -o "$out_file" "$file"
+        echo "------------------------------------"
 done

haskell/src/0003.hs

@@ -0,0 +1,35 @@
+{-
+The prime factors of 13195 are 5, 7, 13 and 29.
+What is the largest prime factor of the number 600851475143?
+-}
+
+import Debug.Trace
+
+is_prime :: Int -> Bool
+is_prime x = go' x 2
+  where
+    go' 0 y = True
+    go' 1 y = True
+    go' x 2 = case (mod x 2) of
+                0 -> False
+                _ -> go' x 3
+    go' x y
+      | x == y    = True
+      | otherwise = case (mod x y) of
+                      0 -> False
+                      _ -> go' x (y + 2)
+
+solution :: Int
+solution = go' 1 0 where
+  target = 600851475143
+  go' x y
+    | x == target = y
+    | otherwise   = case (mod target x) of
+                      0 -> case (is_prime x) of
+                             True  -> go' (x + 2) x
+                             False -> go' (x + 2) y
+                      _ -> go' (x + 2) y
+
+-- This takes about 1hr to end
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0004.hs

@@ -0,0 +1,28 @@
+{-
+A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 * 99.
+Find the largest palindrome made from the product of two 3-digit numbers.
+-}
+
+rev_list :: [Char] -> [Char]
+rev_list []     = []
+rev_list [x]    = [x]
+rev_list (x:xs) = (rev_list xs) ++ [x]
+
+bigger :: Int -> Int -> Int
+bigger x y = if (x > y) then x else y
+
+is_palindrome :: Int -> Bool
+is_palindrome x = (xs == (rev_list xs)) where xs = show x
+
+solution' :: Int -> Int -> Int -> Int
+solution' x    1000 res = res
+solution' 1000 y    res = solution' 100 (y + 1) res
+solution' x y res = solution' (x + 1) y $! (if (is_palindrome (x * y))
+                                            then (bigger (x * y) res)
+                                            else res)
+
+solution :: Int
+solution = solution' 100 100 0
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0005.hs

@@ -0,0 +1,18 @@
+{-
+2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
+What is the smallest positive number that is evenly divisible with no remainder by all of the numbers from 1 to 20?
+-}
+
+evenly_div :: Int -> Int -> Bool
+evenly_div x 0 = True
+evenly_div x 1 = True
+evenly_div x y = if (mod x y) == 0 then evenly_div x (y - 1) else False
+
+solution' :: Int -> Int
+solution' x = if (evenly_div x 20) then x else solution' (x + 1)
+
+solution :: Int
+solution = solution' 1
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0006.hs

@@ -0,0 +1,20 @@
+{-
+The sum of the squares of the first ten natural numbers is, 1^2 + 2^2 + ... + 10^2 = 385.
+The square of the sum of the first ten natural numbers is, (1 + 2 + ... + 10)^2 = 55^2 = 3025.
+Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 - 385 = 2640.
+Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.
+-}
+
+solution :: Int
+solution = (square_of_sum 1 0) - (sum_of_square 1 0)
+  where
+    limit = 100
+    sum_of_square x res
+      | x > 100   = res
+      | otherwise = sum_of_square (x + 1) (res + (x * x))
+    square_of_sum x res
+      | x > 100   = res*res
+      | otherwise = square_of_sum (x + 1) (res + x)
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0007.hs

@@ -0,0 +1,27 @@
+{-
+By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
+What is the 10001st prime number?
+-}
+
+is_prime :: Int -> Bool
+is_prime x = go' x 2
+  where
+    go' :: Int -> Int -> Bool
+    go' x y
+      | x == y    = True
+      | x == 1    = True
+      | y == 2    = if (mod x 2) == 0 then False else go' x 3
+      | otherwise = if (mod x y) == 0 then False else go' x (y+2)
+
+solution :: Int
+solution = go' 3 2
+  where
+    go' :: Int -> Int -> Int
+    go' x count = if (is_prime x)
+                  then if count > 10000
+                       then x
+                       else go' (x + 2) (count + 1)
+                  else go' (x + 2) count
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0008.hs

@@ -0,0 +1,58 @@
+{-
+The four adjacent digits in the 1000-digit number that have the greatest product are 9*9*8*9 = 5832.
+
+73167176531330624919225119674426574742355349194934
+96983520312774506326239578318016984801869478851843
+85861560789112949495459501737958331952853208805511
+12540698747158523863050715693290963295227443043557
+66896648950445244523161731856403098711121722383113
+62229893423380308135336276614282806444486645238749
+30358907296290491560440772390713810515859307960866
+70172427121883998797908792274921901699720888093776
+65727333001053367881220235421809751254540594752243
+52584907711670556013604839586446706324415722155397
+53697817977846174064955149290862569321978468622482
+83972241375657056057490261407972968652414535100474
+82166370484403199890008895243450658541227588666881
+16427171479924442928230863465674813919123162824586
+17866458359124566529476545682848912883142607690042
+24219022671055626321111109370544217506941658960408
+07198403850962455444362981230987879927244284909188
+84580156166097919133875499200524063689912560717606
+05886116467109405077541002256983155200055935729725
+71636269561882670428252483600823257530420752963450
+
+Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?
+-}
+
+import Data.Char (ord)
+
+ban :: [Char]
+ban = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"
+
+ban_size :: Int
+ban_size = length ban
+
+slice_13 :: Int -> [Char]
+slice_13 start = (take 13 (drop start ban))
+
+solution :: Int
+solution = go' 0 0
+  where
+    limit :: Int
+    limit = ban_size - 13
+
+    c2i :: Char -> Int
+    c2i x = (ord x - ord '0')
+
+    mul :: [Int] -> Int
+    mul list = foldl (\x y -> x*y) 1 list
+
+    go' :: Int -> Int -> Int
+    go' index res
+      | index == limit = res
+      | otherwise      = go' (index+1) (if val > res then val else res)
+                           where val = mul (map c2i (slice_13 index))
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0009.hs

@@ -0,0 +1,26 @@
+{-
+A Pythagorean triplet is a set of three natural numbers, a < b < c, for which, a^2 + b^2 = c^2.
+For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
+There exists exactly one Pythagorean triplet for which a + b + c = 1000.
+Find the product abc.
+-}
+
+solution :: Int
+solution = go' 1 1 1 10
+  where
+    target :: Int
+    target = 1000
+
+    is_pit3 :: Int -> Int -> Int -> Bool
+    is_pit3 a b c = (a*a + b*b) == c*c
+
+    go' :: Int -> Int -> Int -> Int -> Int
+    go' a b c tag
+      | a == tag                             = go' 1 (b+1) c     tag
+      | b == tag                             = go' 1 1     (c+1) tag
+      | c == tag                             = go' 1 1     1     (tag*2)
+      | (is_pit3 a b c) && (a+b+c) == target = a*b*c
+      | otherwise                            = go' (a+1) b c tag
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0010.hs

@@ -0,0 +1,21 @@
+{-
+The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
+Find the sum of all the primes below two million.
+-}
+
+is_prime :: Int -> Bool
+is_prime x = go' x 2
+  where
+    go' :: Int -> Int -> Bool
+    go' 1 y = True
+    go' 2 y = True
+    go' x y
+      | x == y    = True
+      | y == 2    = if (mod x y) == 0 then False else go' x 3
+      | otherwise = if (mod x y) == 0 then False else go' x (y+2)
+
+solution :: Int
+solution = sum (filter is_prime [2..2000000])
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0011.hs

@@ -0,0 +1,72 @@
+{-
+In the 20 * 20 grid below, four numbers along a diagonal line have been marked in red.
+08 02 22 97 38 15 00 40  00  75  04  05  07 78 52 12 50 77 91 08
+49 49 99 40 17 81 18 57  60  87  17  40  98 43 69 48 04 56 62 00
+81 49 31 73 55 79 14 29  93  71  40  67  53 88 30 03 49 13 36 65
+52 70 95 23 04 60 11 42  69  24  68  56  01 32 56 71 37 02 36 91
+22 31 16 71 51 67 63 89  41  92  36  54  22 40 40 28 66 33 13 80
+24 47 32 60 99 03 45 02  44  75  33  53  78 36 84 20 35 17 12 50
+32 98 81 28 64 23 67 10 *26* 38  40  67  59 54 70 66 18 38 64 70
+67 26 20 68 02 62 12 20  95 *63* 94  39  63 08 40 91 66 49 94 21
+24 55 58 05 66 73 99 26  97  17 *78* 78  96 83 14 88 34 89 63 72
+21 36 23 09 75 00 76 44  20  45  35 *14* 00 61 33 97 34 31 33 95
+78 17 53 28 22 75 31 67  15  94  03  80  04 62 16 14 09 53 56 92
+16 39 05 42 96 35 31 47  55  58  88  24  00 17 54 24 36 29 85 57
+86 56 00 48 35 71 89 07  05  44  44  37  44 60 21 58 51 54 17 58
+19 80 81 68 05 94 47 69  28  73  92  13  86 52 17 77 04 89 55 40
+04 52 08 83 97 35 99 16  07  97  57  32  16 26 26 79 33 27 98 66
+88 36 68 87 57 62 20 72  03  46  33  67  46 55 12 32 63 93 53 69
+04 42 16 73 38 25 39 11  24  94  72  18  08 46 29 32 40 62 76 36
+20 69 36 41 72 30 23 88  34  62  99  69  82 67 59 85 74 04 36 16
+20 73 35 29 78 31 90 01  74  31  49  71  48 86 81 16 23 57 05 54
+01 70 54 71 83 51 54 69  16  92  33  48  61 43 52 01 89 19 67 48
+The product of these numbers is 26 * 63 * 78 * 14 = 1788696.
+What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20 * 20 grid?
+-}
+
+import Data.List
+import Data.Maybe
+import Utils
+
+bat :: Matrix Int
+bat =
+  [ [08, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 08],
+    [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00],
+    [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65],
+    [52, 70, 95, 23, 04, 60, 11, 42, 69, 24, 68, 56, 01, 32, 56, 71, 37, 02, 36, 91],
+    [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
+    [24, 47, 32, 60, 99, 03, 45, 02, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
+    [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
+    [67, 26, 20, 68, 02, 62, 12, 20, 95, 63, 94, 39, 63, 08, 40, 91, 66, 49, 94, 21],
+    [24, 55, 58, 05, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
+    [21, 36, 23, 09, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95],
+    [78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 03, 80, 04, 62, 16, 14, 09, 53, 56, 92],
+    [16, 39, 05, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57],
+    [86, 56, 00, 48, 35, 71, 89, 07, 05, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
+    [19, 80, 81, 68, 05, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 04, 89, 55, 40],
+    [04, 52, 08, 83, 97, 35, 99, 16, 07, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
+    [88, 36, 68, 87, 57, 62, 20, 72, 03, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
+    [04, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 08, 46, 29, 32, 40, 62, 76, 36],
+    [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16],
+    [20, 73, 35, 29, 78, 31, 90, 01, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 05, 54],
+    [01, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48]
+  ]
+
+solution :: Int
+solution =
+  (maximum
+     (map
+        (\x -> foldl' (*) 1 x)
+        (catMaybes
+           [(matrix_get_n bat 4 d (Point x y))
+            | (x, y, d) <- combinations3
+                             [0 .. 19]
+                             [0 .. 19]
+                             allDirection
+           ]
+        )
+     )
+  )
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0012.hs

@@ -0,0 +1,30 @@
+{-
+The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28.
+The first ten terms would be: 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
+Let us list the factors of the first seven triangle numbers:
+1 : 1
+3 : 1,3
+6 : 1,2,3
+10: 1,2,5,10
+15: 1,3,5,15
+21: 1,3,7,21
+28: 1,2,4, 7,14,28
+We can see that 28 is the first triangle number to have over five divisors.
+What is the value of the first triangle number to have over five hundred divisors?
+-}
+
+import Data.List
+import Data.Maybe
+
+n_divs :: Int -> Int
+n_divs n = length (filter (\x -> (mod n x) == 0) [1..n])
+
+-- Even Number Always have more divisors than Odd
+solution :: Int
+solution = fromJust (find (\x -> (n_divs x) > 500) (iterate (+2) 2))
+
+{-
+This program has never run to conclusion, but it is mathematically correct so it stays
+-}
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0013.hs

@@ -0,0 +1,217 @@
+{-
+Work out the first ten digits of the sum of the following one hundred 50-digit numbers.
+37107287533902102798797998220837590246510135740250
+46376937677490009712648124896970078050417018260538
+74324986199524741059474233309513058123726617309629
+91942213363574161572522430563301811072406154908250
+23067588207539346171171980310421047513778063246676
+89261670696623633820136378418383684178734361726757
+28112879812849979408065481931592621691275889832738
+44274228917432520321923589422876796487670272189318
+47451445736001306439091167216856844588711603153276
+70386486105843025439939619828917593665686757934951
+62176457141856560629502157223196586755079324193331
+64906352462741904929101432445813822663347944758178
+92575867718337217661963751590579239728245598838407
+58203565325359399008402633568948830189458628227828
+80181199384826282014278194139940567587151170094390
+35398664372827112653829987240784473053190104293586
+86515506006295864861532075273371959191420517255829
+71693888707715466499115593487603532921714970056938
+54370070576826684624621495650076471787294438377604
+53282654108756828443191190634694037855217779295145
+36123272525000296071075082563815656710885258350721
+45876576172410976447339110607218265236877223636045
+17423706905851860660448207621209813287860733969412
+81142660418086830619328460811191061556940512689692
+51934325451728388641918047049293215058642563049483
+62467221648435076201727918039944693004732956340691
+15732444386908125794514089057706229429197107928209
+55037687525678773091862540744969844508330393682126
+18336384825330154686196124348767681297534375946515
+80386287592878490201521685554828717201219257766954
+78182833757993103614740356856449095527097864797581
+16726320100436897842553539920931837441497806860984
+48403098129077791799088218795327364475675590848030
+87086987551392711854517078544161852424320693150332
+59959406895756536782107074926966537676326235447210
+69793950679652694742597709739166693763042633987085
+41052684708299085211399427365734116182760315001271
+65378607361501080857009149939512557028198746004375
+35829035317434717326932123578154982629742552737307
+94953759765105305946966067683156574377167401875275
+88902802571733229619176668713819931811048770190271
+25267680276078003013678680992525463401061632866526
+36270218540497705585629946580636237993140746255962
+24074486908231174977792365466257246923322810917141
+91430288197103288597806669760892938638285025333403
+34413065578016127815921815005561868836468420090470
+23053081172816430487623791969842487255036638784583
+11487696932154902810424020138335124462181441773470
+63783299490636259666498587618221225225512486764533
+67720186971698544312419572409913959008952310058822
+95548255300263520781532296796249481641953868218774
+76085327132285723110424803456124867697064507995236
+37774242535411291684276865538926205024910326572967
+23701913275725675285653248258265463092207058596522
+29798860272258331913126375147341994889534765745501
+18495701454879288984856827726077713721403798879715
+38298203783031473527721580348144513491373226651381
+34829543829199918180278916522431027392251122869539
+40957953066405232632538044100059654939159879593635
+29746152185502371307642255121183693803580388584903
+41698116222072977186158236678424689157993532961922
+62467957194401269043877107275048102390895523597457
+23189706772547915061505504953922979530901129967519
+86188088225875314529584099251203829009407770775672
+11306739708304724483816533873502340845647058077308
+82959174767140363198008187129011875491310547126581
+97623331044818386269515456334926366572897563400500
+42846280183517070527831839425882145521227251250327
+55121603546981200581762165212827652751691296897789
+32238195734329339946437501907836945765883352399886
+75506164965184775180738168837861091527357929701337
+62177842752192623401942399639168044983993173312731
+32924185707147349566916674687634660915035914677504
+99518671430235219628894890102423325116913619626622
+73267460800591547471830798392868535206946944540724
+76841822524674417161514036427982273348055556214818
+97142617910342598647204516893989422179826088076852
+87783646182799346313767754307809363333018982642090
+10848802521674670883215120185883543223812876952786
+71329612474782464538636993009049310363619763878039
+62184073572399794223406235393808339651327408011116
+66627891981488087797941876876144230030984490851411
+60661826293682836764744779239180335110989069790714
+85786944089552990653640447425576083659976645795096
+66024396409905389607120198219976047599490197230297
+64913982680032973156037120041377903785566085089252
+16730939319872750275468906903707539413042652315011
+94809377245048795150954100921645863754710598436791
+78639167021187492431995700641917969777599028300699
+15368713711936614952811305876380278410754449733078
+40789923115535562561142322423255033685442488917353
+44889911501440648020369068063960672322193204149535
+41503128880339536053299340368006977710650566631954
+81234880673210146739058568557934581403627822703280
+82616570773948327592232845941706525094512325230608
+22918802058777319719839450180888072429661980811197
+77158542502016545090413245809786882778948721859617
+72107838435069186155435662884062257473692284509516
+20849603980134001723930671666823555245252804609722
+53503534226472524250874054075591789781264330331690
+-}
+
+import Utils
+
+import Data.Maybe
+import Data.Function
+import Data.Char
+
+numbers :: [Integer]
+numbers = map read ["37107287533902102798797998220837590246510135740250",
+                    "46376937677490009712648124896970078050417018260538",
+                    "74324986199524741059474233309513058123726617309629",
+                    "91942213363574161572522430563301811072406154908250",
+                    "23067588207539346171171980310421047513778063246676",
+                    "89261670696623633820136378418383684178734361726757",
+                    "28112879812849979408065481931592621691275889832738",
+                    "44274228917432520321923589422876796487670272189318",
+                    "47451445736001306439091167216856844588711603153276",
+                    "70386486105843025439939619828917593665686757934951",
+                    "62176457141856560629502157223196586755079324193331",
+                    "64906352462741904929101432445813822663347944758178",
+                    "92575867718337217661963751590579239728245598838407",
+                    "58203565325359399008402633568948830189458628227828",
+                    "80181199384826282014278194139940567587151170094390",
+                    "35398664372827112653829987240784473053190104293586",
+                    "86515506006295864861532075273371959191420517255829",
+                    "71693888707715466499115593487603532921714970056938",
+                    "54370070576826684624621495650076471787294438377604",
+                    "53282654108756828443191190634694037855217779295145",
+                    "36123272525000296071075082563815656710885258350721",
+                    "45876576172410976447339110607218265236877223636045",
+                    "17423706905851860660448207621209813287860733969412",
+                    "81142660418086830619328460811191061556940512689692",
+                    "51934325451728388641918047049293215058642563049483",
+                    "62467221648435076201727918039944693004732956340691",
+                    "15732444386908125794514089057706229429197107928209",
+                    "55037687525678773091862540744969844508330393682126",
+                    "18336384825330154686196124348767681297534375946515",
+                    "80386287592878490201521685554828717201219257766954",
+                    "78182833757993103614740356856449095527097864797581",
+                    "16726320100436897842553539920931837441497806860984",
+                    "48403098129077791799088218795327364475675590848030",
+                    "87086987551392711854517078544161852424320693150332",
+                    "59959406895756536782107074926966537676326235447210",
+                    "69793950679652694742597709739166693763042633987085",
+                    "41052684708299085211399427365734116182760315001271",
+                    "65378607361501080857009149939512557028198746004375",
+                    "35829035317434717326932123578154982629742552737307",
+                    "94953759765105305946966067683156574377167401875275",
+                    "88902802571733229619176668713819931811048770190271",
+                    "25267680276078003013678680992525463401061632866526",
+                    "36270218540497705585629946580636237993140746255962",
+                    "24074486908231174977792365466257246923322810917141",
+                    "91430288197103288597806669760892938638285025333403",
+                    "34413065578016127815921815005561868836468420090470",
+                    "23053081172816430487623791969842487255036638784583",
+                    "11487696932154902810424020138335124462181441773470",
+                    "63783299490636259666498587618221225225512486764533",
+                    "67720186971698544312419572409913959008952310058822",
+                    "95548255300263520781532296796249481641953868218774",
+                    "76085327132285723110424803456124867697064507995236",
+                    "37774242535411291684276865538926205024910326572967",
+                    "23701913275725675285653248258265463092207058596522",
+                    "29798860272258331913126375147341994889534765745501",
+                    "18495701454879288984856827726077713721403798879715",
+                    "38298203783031473527721580348144513491373226651381",
+                    "34829543829199918180278916522431027392251122869539",
+                    "40957953066405232632538044100059654939159879593635",
+                    "29746152185502371307642255121183693803580388584903",
+                    "41698116222072977186158236678424689157993532961922",
+                    "62467957194401269043877107275048102390895523597457",
+                    "23189706772547915061505504953922979530901129967519",
+                    "86188088225875314529584099251203829009407770775672",
+                    "11306739708304724483816533873502340845647058077308",
+                    "82959174767140363198008187129011875491310547126581",
+                    "97623331044818386269515456334926366572897563400500",
+                    "42846280183517070527831839425882145521227251250327",
+                    "55121603546981200581762165212827652751691296897789",
+                    "32238195734329339946437501907836945765883352399886",
+                    "75506164965184775180738168837861091527357929701337",
+                    "62177842752192623401942399639168044983993173312731",
+                    "32924185707147349566916674687634660915035914677504",
+                    "99518671430235219628894890102423325116913619626622",
+                    "73267460800591547471830798392868535206946944540724",
+                    "76841822524674417161514036427982273348055556214818",
+                    "97142617910342598647204516893989422179826088076852",
+                    "87783646182799346313767754307809363333018982642090",
+                    "10848802521674670883215120185883543223812876952786",
+                    "71329612474782464538636993009049310363619763878039",
+                    "62184073572399794223406235393808339651327408011116",
+                    "66627891981488087797941876876144230030984490851411",
+                    "60661826293682836764744779239180335110989069790714",
+                    "85786944089552990653640447425576083659976645795096",
+                    "66024396409905389607120198219976047599490197230297",
+                    "64913982680032973156037120041377903785566085089252",
+                    "16730939319872750275468906903707539413042652315011",
+                    "94809377245048795150954100921645863754710598436791",
+                    "78639167021187492431995700641917969777599028300699",
+                    "15368713711936614952811305876380278410754449733078",
+                    "40789923115535562561142322423255033685442488917353",
+                    "44889911501440648020369068063960672322193204149535",
+                    "41503128880339536053299340368006977710650566631954",
+                    "81234880673210146739058568557934581403627822703280",
+                    "82616570773948327592232845941706525094512325230608",
+                    "22918802058777319719839450180888072429661980811197",
+                    "77158542502016545090413245809786882778948721859617",
+                    "72107838435069186155435662884062257473692284509516",
+                    "20849603980134001723930671666823555245252804609722",
+                    "53503534226472524250874054075591789781264330331690"]
+
+solution :: Int
+solution = sum numbers |> show |> take 10 |> read
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0014.hs

@@ -0,0 +1,38 @@
+{-
+The following iterative sequence is defined for the set of positive integers:
+n -> n/2 (n is even)
+n -> 3n + 1 (n is odd)
+Using the rule above and starting with 13, we generate the following sequence:
+13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1.
+It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.
+Which starting number, under one million, produces the longest chain?
+NOTE: Once the chain starts the terms are allowed to go above one million.
+-}
+
+import Data.List
+import Data.Maybe
+import Data.Function
+
+(|>) = (&)
+
+next_term :: Int -> Int
+next_term 1 = 1
+next_term x
+  | even x    = div x 2
+  | otherwise = (x * 3) + 1
+
+gen_chain :: Int -> [Int]
+gen_chain 1 = [1]
+gen_chain s = [s] ++ gen_chain (next_term s)
+
+solution :: Int
+solution = chains !! (elemIndex biggest chains_size |> fromJust) |> head
+  where
+    chains = [1..1000000] |> map gen_chain
+    -- For some reason if chains is used here it will fill all the memory
+    chains_size = [1..1000000] |> map gen_chain |> map length
+    biggest :: Int
+    biggest = maximum chains_size
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0017.hs

@@ -0,0 +1,70 @@
+{-
+If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
+If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?
+NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.
+-}
+
+import Data.Char
+import Data.Function
+
+(|>) = (&)
+
+-- Round Down to Nearest Ten
+rd2nt :: Int -> Int
+rd2nt x
+  | x < 10  = 0
+  | x < 20  = 10
+  | x < 30  = 20
+  | x < 40  = 30
+  | x < 50  = 40
+  | x < 60  = 50
+  | x < 70  = 60
+  | x < 80  = 70
+  | x < 90  = 80
+  | x < 100 = 90
+  | x >= 100 = rd2nt (mod x 100)
+
+digit_to_name :: Int -> String
+digit_to_name 0  = ""
+digit_to_name 1  = "one"
+digit_to_name 2  = "two"
+digit_to_name 3  = "three"
+digit_to_name 4  = "four"
+digit_to_name 5  = "five"
+digit_to_name 6  = "six"
+digit_to_name 7  = "seven"
+digit_to_name 8  = "eight"
+digit_to_name 9  = "nine"
+digit_to_name 10 = "ten"
+digit_to_name 11 = "eleven"
+digit_to_name 12 = "twelve"
+digit_to_name 13 = "thirteen"
+digit_to_name 14 = "fourteen"
+digit_to_name 15 = "fifteen"
+digit_to_name 16 = "sixteen"
+digit_to_name 17 = "seventeen"
+digit_to_name 18 = "eighteen"
+digit_to_name 19 = "nineteen"
+digit_to_name 20 = "twenty"
+digit_to_name 30 = "thirty"
+digit_to_name 40 = "forty"
+digit_to_name 50 = "fifty"
+digit_to_name 60 = "sixty"
+digit_to_name 70 = "seventy"
+digit_to_name 80 = "eighty"
+digit_to_name 90 = "ninety"
+digit_to_name 1000 = "one thousand"
+digit_to_name x
+  | (mod x 100) == 0 = digit_to_name (div x 100) ++ " hundred"
+  | x < 100          = digit_to_name (rd2nt x) ++ " " ++ digit_to_name (mod x 10)
+  | x < 1000         = digit_to_name (div x 100) ++ " hundred and " ++ digit_to_name (mod x 100)
+
+
+isNotSpace :: Char -> Bool
+isNotSpace x = isSpace x |> not
+
+solution :: Int
+solution = map digit_to_name [1..1000] |> map (filter isNotSpace) |> map length |> sum
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0018.hs

@@ -0,0 +1,58 @@
+{-
+By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.
+   *3*
+  *7* 4
+ 2 *4* 6
+8 5 *9* 3
+That is, 3 + 7 + 4 + 9 = 23.
+Find the maximum total from top to bottom of the triangle below:
+75
+95 64
+17 47 82
+18 35 87 10
+20 04 82 47 65
+19 01 23 75 03 34
+88 02 77 73 07 63 67
+99 65 04 28 06 16 70 92
+41 41 26 56 83 40 80 70 33
+41 48 72 33 47 32 37 16 94 29
+53 71 44 65 25 43 91 52 97 51 14
+70 11 33 28 77 73 17 78 39 68 17 57
+91 71 52 38 17 14 91 43 58 50 27 29 48
+63 66 04 68 89 53 67 30 73 16 69 87 40 31
+04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
+NOTE: As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method! ;o)
+-}
+
+import Utils
+
+triangle :: String
+triangle = "75\n95 64\n17 47 82\n18 35 87 10\n20 04 82 47 65\n19 01 23 75 03 34\n88 02 77 73 07 63 67\n99 65 04 28 06 16 70 92\n41 41 26 56 83 40 80 70 33\n41 48 72 33 47 32 37 16 94 29\n53 71 44 65 25 43 91 52 97 51 14\n70 11 33 28 77 73 17 78 39 68 17 57\n91 71 52 38 17 14 91 43 58 50 27 29 48\n63 66 04 68 89 53 67 30 73 16 69 87 40 31\n04 62 98 27 23 09 70 98 73 93 38 53 60 04 23"
+
+lookAhead :: Int -> Tri Int -> Int
+lookAhead _  (EmptyTri) = 0
+lookAhead 0  _          = 0
+lookAhead td t          = go' 0 t
+  where
+    go' :: Int -> Tri Int -> Int
+    go' d EmptyTri     = 0
+    go' d (Node x l r)
+      | d >= td   = x
+      | otherwise = x + (go' (d+1) n)
+                      where n :: Tri Int
+                            --n = bigger (triValDef 0) [l, r]
+                            n = bigger (lookAhead (td-1)) [l, r]
+
+solution :: Int
+solution = go' (triParseString triangle)
+  where
+    go' :: Tri Int -> Int
+    go' EmptyTri    = 0
+    go' (Node x l r) = x + (go' n)
+                         where
+                           n :: Tri Int
+                           n = bigger (lookAhead 4) [l, r]
+
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0019.hs

@@ -0,0 +1,26 @@
+{-
+You are given the following information, but you may prefer to do some research for yourself.
+1 Jan 1900 was a Monday.
+Thirty days has September,
+April, June and November.
+All the rest have thirty-one, Saving February alone,
+Which has twenty-eight, rain or shine.
+And on leap years, twenty-nine.
+A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.
+How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?
+-}
+
+import Utils
+
+solution :: Int
+solution = go' sD (iterate weekdayNext (weekdayOfDate sD)) 0
+  where
+    sD = Date 1901  1  1
+    eD = Date 2000 12 31
+    go' :: Date -> [Weekday] -> Int -> Int
+    go' d (x:xs) c
+      | d == eD   = c
+      | otherwise = go' (dateNextDay d) xs (if (x == Sunday && (dateDay d) == 1) then (c+1) else c)
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0020.hs

@@ -0,0 +1,16 @@
+{-
+n! means n * (n - 1) * ... * 3 * 2 * 1.
+For example, 10! = 10 * 9 * ... * 3 * 2 * 1 = 3628800,
+and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
+Find the sum of the digits in the number 100!.
+-}
+
+import Utils
+
+import Data.Maybe
+
+solution :: Int
+solution = foldl (+) 0 (map (\x -> fromJust (c2i x)) (show (factorial 100)))
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0021.hs

@@ -0,0 +1,26 @@
+{-
+Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n).
+If d(a) = b and d(b) = a, where a != b, then a and b are an amicable pair and each of a and b are called amicable numbers.
+For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220.
+Evaluate the sum of all the amicable numbers under 10000.
+-}
+
+import Utils
+
+import Data.List
+import Data.Maybe
+
+amicableNum :: Int -> Maybe (Int, Int)
+amicableNum a = if (a == na && a /= b)
+                then Just (a, b)
+                else Nothing
+                  where b = sum (divs a)
+                        na = sum (divs b)
+
+solution :: Int
+solution = foldl (\c x -> c+x) 0 abs
+  where
+    abs = nub (takeWhile (<10000) (flattenTupleList (catMaybes (map amicableNum (iterate (+1) 1)))))
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0022.hs

@@ -0,0 +1,33 @@
+{-
+Using names.txt (right click and 'Save Link/Target As...'),
+ a 46K text file containing over five-thousand first names,
+ begin by sorting it into alphabetical order.
+Then working out the alphabetical value for each name,
+ multiply this value by its alphabetical position in the list to obtain a name score.
+For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would obtain a score of 938 \times 53 = 49714.
+What is the total of all the name scores in the file?
+-}
+
+import Utils
+
+import System.Environment
+
+import Data.Char
+import Data.List
+import Data.Maybe
+
+import Debug.Trace
+import Text.Printf
+
+alphabeticalValue :: String -> Int
+alphabeticalValue s = map toUpper s |> map ord |> map (`sub` 64) |> sum
+                        where sub = (-)
+
+solution :: String -> Int
+solution input = filter (/='"') input |> splitByChar ',' |> sort |> mapi (\i x -> (i+1)*(alphabeticalValue x)) |> sum
+
+main :: IO ()
+main = do
+  inputContent <- (\x -> "input/" ++ x ++ ".txt") <$> getProgName >>= readFile
+
+  putStrLn ("Solution: " ++ show (solution inputContent))

haskell/src/0023.hs

@@ -0,0 +1,43 @@
+{-
+A perfect number is a number for which the sum of its proper divisors is exactly equal to the number. For example, the sum of the proper divisors of 28 would be 1 + 2 + 4 + 7 + 14 = 28, which means that 28 is a perfect number.
+A number n is called deficient if the sum of its proper divisors is less than n and it is called abundant if this sum exceeds n.
+
+As 12 is the smallest abundant number, 1 + 2 + 3 + 4 + 6 = 16, the smallest number that can be written as the sum of two abundant numbers is 24. By mathematical analysis, it can be shown that all integers greater than 28123 can be written as the sum of two abundant numbers. However, this upper limit cannot be reduced any further by analysis even though it is known that the greatest number that cannot be expressed as the sum of two abundant numbers is less than this limit.
+Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers.
+-}
+
+import Utils
+
+import Data.List
+
+--import Data.Map (Map)
+--import qualified Data.Map as Map
+
+import Data.IntSet (IntSet)
+import qualified Data.IntSet as IntSet
+
+import Debug.Trace
+
+isAbundant :: Int -> Bool
+isAbundant x = (divs x |> sum) > x
+
+abundants :: [Int]
+abundants = iterate (+1) 1 |> take 28124 |> filter isAbundant
+abundantsSet :: IntSet
+abundantsSet = IntSet.fromList abundants
+
+f :: Int -> Bool
+f n = go' abundants
+  where
+    go' [] = False
+    go' [x] = IntSet.member (n-x) abundantsSet
+    go' (x:xs)
+      | x >= n                           = False
+      | IntSet.member (n-x) abundantsSet = True
+      | otherwise                        = go' xs
+
+solution :: Int
+solution = iterate (+1) 1 |> take 28123 |> filter (\x -> (f x) == False) |> sum
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0024.hs

@@ -0,0 +1,16 @@
+{-
+A permutation is an ordered arrangement of objects. For example, 3124 is one possible permutation of the digits 1, 2, 3 and 4. If all of the permutations are listed numerically or alphabetically, we call it lexicographic order. The lexicographic permutations of 0, 1 and 2 are:
+012   021   102   120   201   210
+What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?
+-}
+
+import Utils
+
+import Data.List
+import Data.Char
+
+solution :: Int
+solution = read ((permutations [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] |> map (map intToDigit) |> sort) !! 999999)
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0025.hs

@@ -0,0 +1,17 @@
+
+import Utils
+
+import Data.Tuple
+
+fibonacciWhile :: (Integer -> Bool) -> (Int, Integer)
+fibonacciWhile f = go' 1 1 1
+  where
+    go' i f1 f2
+      | f f1      = go' (i+1) (f1+f2) f1
+      | otherwise = (i, f1)
+
+solution :: Int
+solution = (fibonacciWhile (\x -> (length $ show x) < 1000) |> fst) + 1
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0026.hs

@@ -0,0 +1,51 @@
+
+import Utils
+
+import Data.Char
+import Data.List
+import Data.Ratio
+import Data.Maybe
+
+--import Debug.Trace
+--import Text.Printf
+
+f :: Int -> Int
+f 1 = 0
+f x = go' "" s s
+  where
+    s :: String
+    s = dropWhile (=='0') (drop 2 (longDiv (1%x)))
+    sL :: Int
+    sL = length s
+
+    go' :: String -> String -> String -> Int
+    --go' r (h:tl) sC | trace (printf "go' r=%s h=%c tl=%s sC=%s" r h tl sC) False = undefined
+    go' _ _  [] = 0
+    go' r [] sC  = go' "" (drop 1 sC) (drop 1 sC)
+    go' r sS sC | (length r) > (div (length sS) 2)= go' "" (drop 1 sC) (drop 1 sC)
+    go' r (h:tl) sC = if ((take 1 nR) == (take 1 tl)) && does_repeat nR tl -- does_repeat c 0 tl
+                      then (length r)+1
+                      else go' nR tl sC
+      where nR = (r++[h])
+
+    does_repeat :: String -> String -> Bool
+    --does_repeat n h | trace (printf "does_repeat n=%s h=%s" n h) False = undefined
+    does_repeat n [] = True
+    does_repeat n h = if (nS == hSlc)
+                      then does_repeat n (drop hSlcL h)
+                      else False
+      where nL = length n
+            hL = length h
+            hSlc = take nL h
+            hSlcL = length hSlc
+            nS = if hSlcL /= nL then take hSlcL n else n
+
+solution :: Int
+solution = l !! mI
+  where l = [1..1000]
+        fL = map f l
+        m = maximum fL
+        mI = fromJust (elemIndex m fL)
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0027.hs

@@ -0,0 +1,30 @@
+
+import Utils
+
+import Data.List
+import Data.Maybe
+
+--import Debug.Trace
+--import Text.Printf
+
+numOfPrimes :: Int -> Int -> Int
+numOfPrimes a b = go' 0
+  where
+    go' :: Int -> Int
+    go' n
+      -- | trace (printf "go' n=%-5d r=%-5d" n r) False = undefined
+      | otherwise = if (isPrime r) then go' (n+1) else n
+      where r = (n*n) + (a*n) + b
+
+solution :: Int
+solution = combinations2 [aDLimit..aULimit] [bDLimit..bULimit]
+             |> mapFindMaxInitial (uncurry numOfPrimes)
+             |> (uncurry (*))
+  where
+    aULimit = 999
+    bULimit = 1000
+    aDLimit = -999
+    bDLimit = -1000
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0028.hs

@@ -0,0 +1,17 @@
+
+import Utils
+
+import Data.List
+
+layersSize :: [Int]
+layersSize = [1,3..999] |> map (+1)
+                        |> concatMap (\x -> [x, x, x, x])
+
+solution :: Int
+solution = layersSize |> mapAccumL (\a x -> dup (a+x)) 1
+                      |> snd
+                      |> sum
+                      |> (+1)
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0029.hs

@@ -0,0 +1,10 @@
+
+import Utils
+
+import Data.List
+
+solution :: Int
+solution = combinations2 [2..100] [2..100] |> map (uncurry (^)) |> sort |> nub |> length
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/0030.hs

@@ -0,0 +1,17 @@
+
+import Utils
+
+import Data.List
+import Data.Char
+
+solution :: Int
+solution = iterate (+1) 2
+             |> filter (\x -> addResult (\y -> show y |> map digitToInt
+                                                      |> map (^5)
+                                                      |> sum) x
+                                |> (uncurry (==)))
+             |> take 6
+             |> sum
+
+main :: IO ()
+main = putStrLn ("Solution: " ++ show solution)

haskell/src/Utils.hs

@@ -0,0 +1,297 @@
+module Utils where
+  import Data.Function
+  import Data.Maybe
+  import Data.Ratio
+  import Data.List
+  import Data.Char
+
+  import Debug.Trace
+  import Text.Printf
+
+  (|>) = (&)
+
+  (!?) :: [a] -> Int -> Maybe a
+  l !? i
+    | i >= (length l) = Nothing
+    | i == 0          = car l
+    | otherwise       = cdr l >>= \x -> x !? (i-1)
+
+  c2i :: Char -> Maybe Int
+  c2i c = if cv < 48 || cv > 57
+          then Nothing
+          else Just (cv - 48)
+    where cv = ord c
+
+  car :: [a] -> Maybe a
+  car []    = Nothing
+  car [x]   = Just x
+  car (x:_) = Just x
+
+  cdr :: [a] -> Maybe [a]
+  cdr []     = Nothing
+  cdr [_]    = Just []
+  cdr (_:xs) = Just xs
+
+  run_maybe :: Maybe a -> (a -> b) -> Maybe b
+  run_maybe x f = case x of
+                    Nothing -> Nothing
+                    Just x  -> Just (f x)
+
+  to_maybe :: (a -> b) -> (a -> Maybe b)
+  to_maybe f = \x -> Just (f x)
+
+  compareLength :: [a] -> Int -> Ordering
+  compareLength l s
+    | len == s = EQ
+    | len >  s = LT
+    | len <  s = GT
+      where len = length l
+
+  combinations2 :: [a] -> [b] -> [(a, b)]
+  combinations2 x y = go' x y 0 0
+    where
+      go' :: [a] -> [b] -> Int -> Int -> [(a, b)]
+      go' x y xi yi
+        | compareLength x xi == EQ = go' x y 0 (yi+1)
+        | compareLength y yi == EQ = []
+        | otherwise                = [((x !! xi), (y !! yi))] ++ go' x y (xi+1) yi
+
+  combinations3 :: [a] -> [b] -> [c] -> [(a, b, c)]
+  combinations3 x y z = go' x y z 0 0 0
+    where
+      go' :: [a] -> [b] -> [c] -> Int -> Int -> Int -> [(a, b, c)]
+      go' x y z xi yi zi
+        | compareLength x xi == EQ = go' x y z 0 (yi+1) zi
+        | compareLength y yi == EQ = go' x y z 0 0      (zi+1)
+        | compareLength z zi == EQ = []
+        | otherwise                = [((x !! xi), (y !! yi), (z !! zi))] ++ go' x y z (xi+1) yi zi
+
+  data Direction = DUp | DDown | DLeft | DRight | DUpRight | DUpLeft | DDownRight | DDownLeft deriving Show
+  allDirection :: [Direction]
+  allDirection = [DUp, DDown, DLeft, DRight, DUpRight, DUpLeft, DDownRight, DDownLeft]
+
+  data Point = Point { x :: Int, y :: Int } deriving Show
+
+  point_next_dir :: Point -> Direction -> Point
+  point_next_dir p d =
+    case d of
+      DUp        -> Point ((x p)-1) (y p)
+      DDown      -> Point ((x p)+1) (y p)
+      DLeft      -> Point (x p)     ((y p)-1)
+      DRight     -> Point (x p)     ((y p)+1)
+      DUpRight   -> Point ((x p)-1) ((y p)+1)
+      DUpLeft    -> Point ((x p)-1) ((y p)-1)
+      DDownRight -> Point ((x p)+1) ((y p)+1)
+      DDownLeft  -> Point ((x p)+1) ((y p)-1)
+
+  type Matrix a = [[a]]
+
+  matrix_n_rows :: Matrix a -> Int
+  matrix_n_rows m = length m
+
+  matrix_n_cols :: Matrix a -> Maybe Int
+  matrix_n_cols m = car m >>= to_maybe length
+
+  matrix_get :: Matrix a -> Int -> Int -> Maybe a
+  matrix_get m x y = m !? x >>= \z -> z !? y
+
+  matrix_get_n :: Matrix a -> Int -> Direction -> Point -> Maybe [a]
+  matrix_get_n m a d p = go' m a d p 0
+    where
+      go' :: Matrix a -> Int -> Direction -> Point -> Int -> Maybe [a]
+      go' m a d p c
+        | c == a    = Just []
+        | otherwise = case matrix_get m (x p) (y p) of
+                        Nothing -> Nothing
+                        Just z -> go' m a d (point_next_dir p d) (c+1) >>= \w -> Just ([z] ++ w)
+
+  coalesce2 :: Maybe a -> Maybe a -> a -> a
+  coalesce2 x y d = coalesce1 y (coalesce1 x d)
+
+  coalesce1 :: Maybe a -> a -> a
+  coalesce1 (Just x)  _ = x
+  coalesce1 (Nothing) d = d
+
+  bigger :: (a -> Int) -> [a] -> a
+  bigger f xs = xs !! i where li = map f xs
+                              i = fromJust $ elemIndex (maximum li) li
+
+  data Tri a = EmptyTri | Node a (Tri a) (Tri a)
+    deriving Show
+
+  triLeft :: Tri a -> Tri a
+  triLeft EmptyTri = EmptyTri
+  triLeft (Node _ l _) = l
+
+  triRight :: Tri a -> Tri a
+  triRight EmptyTri = EmptyTri
+  triRight (Node _ _ r) = r
+
+  triVal :: Tri a -> Maybe a
+  triVal EmptyTri     = Nothing
+  triVal (Node x _ _) = Just x
+
+  triValDef :: a -> Tri a -> a
+  triValDef d EmptyTri     = d
+  triValDef _ (Node x _ _) = x
+
+  triVal' :: Tri a -> a
+  triVal' (Node x _ _) = x
+
+  triParseString :: String -> Tri Int
+  triParseString s = lines s |> map words |> map (map read) |> go' 0
+    where
+      go' :: Int -> [[Int]] -> Tri Int
+      go' _ [] = EmptyTri
+      go' i [x] = Node (x !! i) EmptyTri EmptyTri
+      go' i (x:xs) = Node (x !! i) (go' (i+0) xs) (go' (i+1) xs)
+
+  tri2UnsortedList :: Int -> Tri a -> [a]
+  tri2UnsortedList _  (EmptyTri) = []
+  tri2UnsortedList td t          = go' t 0
+    where
+      go' (EmptyTri)   _ = []
+      go' (Node x l r) d
+        | d == td   = []
+        | otherwise = [x] ++ go' l (d+1) ++ go' r (d+1)
+
+  type Day = Int
+  type Month = Int
+
+  monthNumOfDay :: Year -> Month -> Int
+  monthNumOfDay yyyy 2  = if (yearIsLeap yyyy) then 29 else 28
+  monthNumOfDay _    4  = 30
+  monthNumOfDay _    6  = 30
+  monthNumOfDay _    9  = 30
+  monthNumOfDay _    11 = 30
+  monthNumOfDay _    mm = 31
+
+  type Year = Int
+
+  yearIsLeap :: Year -> Bool
+  yearIsLeap yyyy = (mody 4) && ((not (mody 100)) || (mody 400))
+    where mody = \x -> mod yyyy x == 0
+
+  data Date = Date Year Month Day
+    deriving (Show, Eq)
+
+  dateDay :: Date -> Day
+  dateDay (Date _ _ dd) = dd
+
+  dateNextDay :: Date -> Date
+  dateNextDay (Date yyyy mm dd)
+    | dd == (monthNumOfDay yyyy mm) = dateNextMonth (Date yyyy mm 1)
+    | otherwise                     = (Date yyyy mm (dd+1))
+
+  dateNextMonth :: Date -> Date
+  dateNextMonth (Date yyyy 12 dd) = dateNextYear (Date yyyy 1 dd)
+  dateNextMonth (Date yyyy mm dd) = (Date yyyy (mm+1) dd)
+
+  dateNextYear :: Date -> Date
+  dateNextYear (Date yyyy mm dd) = (Date (yyyy+1) mm dd)
+
+  data Weekday = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday
+    deriving (Show, Enum, Eq)
+
+  weekdayNext :: Weekday -> Weekday
+  weekdayNext Sunday = Monday
+  weekdayNext x = succ x
+
+  weekdayOfDate :: Date -> Weekday
+  weekdayOfDate tD = go' (Date 1900 1 1) (iterate weekdayNext Monday)
+    where
+      go' :: Date -> [Weekday] -> Weekday
+      go' d (x:xs)
+        | d == tD   = x
+        | otherwise = go' (dateNextDay d) xs
+
+  factorial :: Integer -> Integer
+  factorial 0 = 0
+  factorial 1 = 1
+  factorial x = x * factorial (x-1)
+
+  divs :: Int -> [Int]
+  divs 0 = []
+  divs 1 = [1]
+  divs x = filter (\x' -> (mod x x') == 0) (take (x-1) (iterate (+1) 1))
+
+  flattenTupleList :: [(a, a)] -> [a]
+  flattenTupleList [] = []
+  flattenTupleList [(x, y)] = [x, y]
+  flattenTupleList ((x, y):xs) = [x, y] ++ (flattenTupleList xs)
+
+  mapi :: (Int -> a -> b) -> [a] -> [b]
+  mapi _ [] = []
+  mapi f l  = go' l 0
+    where go' [] _ = []
+          go' [x] i = [f i x]
+          go' (x:xs) i = [f i x] ++ go' xs (i+1)
+
+  splitByChar :: Char -> String -> [String]
+  splitByChar c s = go' (elemIndex c s) s
+    where go' :: Maybe Int -> String -> [String]
+          go' (Nothing) s = [s]
+          go' (Just i)  s = [b] ++ go' (elemIndex c a) a
+                              where
+                                (b, aRaw) = splitAt i s
+                                a = tail aRaw
+
+  tracePPId :: Show a => [a] -> [a]
+  tracePPId l = if (go' l 0) then [] else l
+    where
+      go' :: Show a => [a] -> Int -> Bool
+      go' []     _ = False
+      go' (x:xs) i = trace (printf "%5d -> %s" i (show x)) (go' xs (i+1))
+
+  slice :: Int -> Int -> [a] -> [a]
+  slice b s l = drop b l |> take s
+
+  howManyFit :: Int -> Int -> Int
+  --howManyFit x y | trace (printf "howManyFit %3d %3d" x y) False = undefined
+  howManyFit x y = if w == 0
+                   then 1
+                   else (if w > 0
+                         then 1 + (howManyFit x w)
+                         else 0)
+    where w = y-x
+
+  tW f (x:xs) = case f x of
+                  True -> tW f xs
+                  False -> x
+
+  longDiv :: Ratio Int -> String
+  longDiv r = if dn == nmRaw then "1" else pred ++ (go' nm False 5000)
+    where
+      nmRaw = numerator r
+      dn = denominator r
+      hMInc = iterate (+1) 1 |> tW (\x -> (howManyFit dn (nmRaw*(10^x))) == 0)
+      nm = nmRaw * (10^hMInc)
+      pred = case hMInc of
+               1 -> "0."
+               2 -> "0.0"
+               3 -> "0.00"
+               4 -> "0.000"
+               _ -> ""
+
+      go' :: Int -> Bool -> Int -> [Char]
+      go' 0 _ _ = []
+      go' _ _ 0 = []
+      go' x z n
+        -- | trace (printf "go' %3d %3d | hmf -> %3d" x n hmf) False = undefined
+        | hmf == 0 && z = ['0'] ++ (go' x False (n-1))
+        | otherwise = if hmf == 0
+                      then go' (x * 10) True (n)
+                      else [(intToDigit hmf)] ++ (go' (x-(dn*hmf)) False (n-1))
+                        where hmf = howManyFit dn x
+
+  isPrime :: Int -> Bool
+  isPrime x = (divs x) == [1]
+
+  addResult :: (a -> b) -> a -> (a, b)
+  addResult f x = (x, f x)
+
+  mapFindMaxInitial :: Ord b => (a -> b) -> [a] -> a
+  mapFindMaxInitial f l = map (addResult f) l |> maximumBy (\a b -> compare (snd a) (snd b)) |> fst
+
+  dup :: a -> (a,a)
+  dup x = (x, x)

python/src/0016.py

@@ -0,0 +1,13 @@
+# 2^15 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
+# What is the sum of the digits of the number 2^1000?
+
+def solution() -> int:
+    return sum(map(lambda x: int(x), str(2**1000)))
+
+def main() -> bool:
+    res = solution()
+    print(f"Solution: {res}")
+    return True
+
+if __name__ == "__main__":
+    main()