haskell problem 13 -> 18, 20

9 files changed, 360 insertions, 2 deletions

diff --git a/haskell/007-10001st_prime.hs b/haskell/007-10001st_prime.hs
index c775f7d..47cb355 100644
--- a/haskell/007-10001st_prime.hs
+++ b/haskell/007-10001st_prime.hs
@@ -13,6 +13,7 @@ main = do
                                               -- to the arbirary range
     print (nth_prime 10000) -- better but meh since we're testing every divisor each time,
                             -- should keep a list of them
+    -- print (primes !! 10000) -- from the haskell website, stream of numbers (takes forever)
 
 nth_prime :: Int -> Int
 nth_prime n = nth_check n 0
@@ -39,3 +40,6 @@ is_prime x
             | x `mod` d == 0 || x `mod` (d + 2) == 0 = False
             | otherwise = trial_div (d + 6)
 
+primes :: [Int]
+primes = filterPrimes [2..]
+    where filterPrimes (p:xs) = p : filterPrimes [x | x <- xs, x `mod` p /= 0]
diff --git a/haskell/013-large_sum.hs b/haskell/013-large_sum.hs
new file mode 100644
index 0000000..b307e7a
--- /dev/null
+++ b/haskell/013-large_sum.hs
@@ -0,0 +1,111 @@
+-- Large sum
+
+-- Problem 13
+-- Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.
+
+
+import Data.Char
+
+main = do
+    putStrLn (take 10 $ show (sum [read s :: Integer | s <- lines bignum]))
+
+bignum = "37107287533902102798797998220837590246510135740250\n\
+          \46376937677490009712648124896970078050417018260538\n\
+          \74324986199524741059474233309513058123726617309629\n\
+          \91942213363574161572522430563301811072406154908250\n\
+          \23067588207539346171171980310421047513778063246676\n\
+          \89261670696623633820136378418383684178734361726757\n\
+          \28112879812849979408065481931592621691275889832738\n\
+          \44274228917432520321923589422876796487670272189318\n\
+          \47451445736001306439091167216856844588711603153276\n\
+          \70386486105843025439939619828917593665686757934951\n\
+          \62176457141856560629502157223196586755079324193331\n\
+          \64906352462741904929101432445813822663347944758178\n\
+          \92575867718337217661963751590579239728245598838407\n\
+          \58203565325359399008402633568948830189458628227828\n\
+          \80181199384826282014278194139940567587151170094390\n\
+          \35398664372827112653829987240784473053190104293586\n\
+          \86515506006295864861532075273371959191420517255829\n\
+          \71693888707715466499115593487603532921714970056938\n\
+          \54370070576826684624621495650076471787294438377604\n\
+          \53282654108756828443191190634694037855217779295145\n\
+          \36123272525000296071075082563815656710885258350721\n\
+          \45876576172410976447339110607218265236877223636045\n\
+          \17423706905851860660448207621209813287860733969412\n\
+          \81142660418086830619328460811191061556940512689692\n\
+          \51934325451728388641918047049293215058642563049483\n\
+          \62467221648435076201727918039944693004732956340691\n\
+          \15732444386908125794514089057706229429197107928209\n\
+          \55037687525678773091862540744969844508330393682126\n\
+          \18336384825330154686196124348767681297534375946515\n\
+          \80386287592878490201521685554828717201219257766954\n\
+          \78182833757993103614740356856449095527097864797581\n\
+          \16726320100436897842553539920931837441497806860984\n\
+          \48403098129077791799088218795327364475675590848030\n\
+          \87086987551392711854517078544161852424320693150332\n\
+          \59959406895756536782107074926966537676326235447210\n\
+          \69793950679652694742597709739166693763042633987085\n\
+          \41052684708299085211399427365734116182760315001271\n\
+          \65378607361501080857009149939512557028198746004375\n\
+          \35829035317434717326932123578154982629742552737307\n\
+          \94953759765105305946966067683156574377167401875275\n\
+          \88902802571733229619176668713819931811048770190271\n\
+          \25267680276078003013678680992525463401061632866526\n\
+          \36270218540497705585629946580636237993140746255962\n\
+          \24074486908231174977792365466257246923322810917141\n\
+          \91430288197103288597806669760892938638285025333403\n\
+          \34413065578016127815921815005561868836468420090470\n\
+          \23053081172816430487623791969842487255036638784583\n\
+          \11487696932154902810424020138335124462181441773470\n\
+          \63783299490636259666498587618221225225512486764533\n\
+          \67720186971698544312419572409913959008952310058822\n\
+          \95548255300263520781532296796249481641953868218774\n\
+          \76085327132285723110424803456124867697064507995236\n\
+          \37774242535411291684276865538926205024910326572967\n\
+          \23701913275725675285653248258265463092207058596522\n\
+          \29798860272258331913126375147341994889534765745501\n\
+          \18495701454879288984856827726077713721403798879715\n\
+          \38298203783031473527721580348144513491373226651381\n\
+          \34829543829199918180278916522431027392251122869539\n\
+          \40957953066405232632538044100059654939159879593635\n\
+          \29746152185502371307642255121183693803580388584903\n\
+          \41698116222072977186158236678424689157993532961922\n\
+          \62467957194401269043877107275048102390895523597457\n\
+          \23189706772547915061505504953922979530901129967519\n\
+          \86188088225875314529584099251203829009407770775672\n\
+          \11306739708304724483816533873502340845647058077308\n\
+          \82959174767140363198008187129011875491310547126581\n\
+          \97623331044818386269515456334926366572897563400500\n\
+          \42846280183517070527831839425882145521227251250327\n\
+          \55121603546981200581762165212827652751691296897789\n\
+          \32238195734329339946437501907836945765883352399886\n\
+          \75506164965184775180738168837861091527357929701337\n\
+          \62177842752192623401942399639168044983993173312731\n\
+          \32924185707147349566916674687634660915035914677504\n\
+          \99518671430235219628894890102423325116913619626622\n\
+          \73267460800591547471830798392868535206946944540724\n\
+          \76841822524674417161514036427982273348055556214818\n\
+          \97142617910342598647204516893989422179826088076852\n\
+          \87783646182799346313767754307809363333018982642090\n\
+          \10848802521674670883215120185883543223812876952786\n\
+          \71329612474782464538636993009049310363619763878039\n\
+          \62184073572399794223406235393808339651327408011116\n\
+          \66627891981488087797941876876144230030984490851411\n\
+          \60661826293682836764744779239180335110989069790714\n\
+          \85786944089552990653640447425576083659976645795096\n\
+          \66024396409905389607120198219976047599490197230297\n\
+          \64913982680032973156037120041377903785566085089252\n\
+          \16730939319872750275468906903707539413042652315011\n\
+          \94809377245048795150954100921645863754710598436791\n\
+          \78639167021187492431995700641917969777599028300699\n\
+          \15368713711936614952811305876380278410754449733078\n\
+          \40789923115535562561142322423255033685442488917353\n\
+          \44889911501440648020369068063960672322193204149535\n\
+          \41503128880339536053299340368006977710650566631954\n\
+          \81234880673210146739058568557934581403627822703280\n\
+          \82616570773948327592232845941706525094512325230608\n\
+          \22918802058777319719839450180888072429661980811197\n\
+          \77158542502016545090413245809786882778948721859617\n\
+          \72107838435069186155435662884062257473692284509516\n\
+          \20849603980134001723930671666823555245252804609722\n\
+          \53503534226472524250874054075591789781264330331690"
diff --git a/haskell/014-longest_collatz_sequence.hs b/haskell/014-longest_collatz_sequence.hs
new file mode 100644
index 0000000..8f6b5b0
--- /dev/null
+++ b/haskell/014-longest_collatz_sequence.hs
@@ -0,0 +1,59 @@
+-- Longest Collatz sequence
+--
+-- Problem 14
+-- 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
+
+type Sequence = [Int]
+
+main = do
+    print (snd $ maximumBy (\(l0, n0) (l1, n1) -> compare l0 l1)
+            [(length $ collatz n, n) | n <- [1..1000000]]) -- takes 7s
+    -- can be optimise by keeping creating other collatz sequence with the numbers after n
+
+    -- print ([(n, length n_seq) | n <- tails $ collatz 7, length n_seq != 0])
+    -- print (collatzLenFrom 1000000)
+    -- print (snd $ maximumBy (\(l0, n0) (l1, n1) -> compare l0 l1) (collatzLenBellow 10))
+    -- print (collatzLenBellow 10)
+    -- print (collatzUntil 10)
+
+collatz :: Int -> [Int]
+collatz 1 = [1]
+collatz n = case n `mod` 2 of 0 -> n : collatz (n `div` 2)
+                              1 -> n : odd_next : collatz (odd_next `div` 2)
+            where odd_next = 3 * n + 1
+
+-- need to build a tree, a sequence can merge in another one,
+-- reduce calculation cost tremendously (probably)
+--
+-- collatzUntil :: Int -> [[Int]]
+-- collatzUntil n = collatzRange 1 n
+
+-- collatzRange :: Int -> Int -> [[Int]]
+-- collatzRange lo hi
+--     | lo >= hi = []
+--     | otherwise = collatzBase lo
+
+-- collatzLenBellow :: Int -> [(Int, Int)]
+-- collatzLenBellow 1 = [(1, 1)]
+-- collatzLenBellow up = (collatzLenFrom up) `union` collatzLenBellow (up - 1)
+
+-- collatzLenFrom :: Int -> [(Int, Int)]
+-- collatzLenFrom top = [(head seq, length seq) | seq <- init $ tails $ collatz top]
+--
+-- data Tree a = Empty | Tree a [Tree a]
diff --git a/haskell/015-lattice_paths.hs b/haskell/015-lattice_paths.hs
new file mode 100644
index 0000000..4611d97
--- /dev/null
+++ b/haskell/015-lattice_paths.hs
@@ -0,0 +1,33 @@
+-- Lattice paths
+--
+-- Problem 15
+-- Starting in the top left corner of a 2×2 grid, and only being able to
+-- move to the right and down, there are exactly 6 routes to the bottom right corner.
+--
+-- image: https://projecteuler.net/project/images/p015.png
+--
+-- How many such routes are there through a 20×20 grid?
+
+
+main = do
+    print (pascalTriangleEntry (20 + 20) 20)
+    -- counting number of routes of problem 18
+    -- print (sum [pascalTriangleEntry 14 k | k <- [0..14]])
+
+-- https://stackoverflow.com/questions/15580291/how-to-efficiently-calculate-a-row-in-pascals-triangle
+-- https://www.wikiwand.com/en/Pascal's_triangle#/Calculating_a_row_or_diagonal_by_itself
+
+-- using the identity: C(n,k+1) = C(n,k) * (n-k) / (k+1)
+pascalTriangleEntry :: Int -> Int -> Int
+pascalTriangleEntry _ 0 = 1
+pascalTriangleEntry n k = (pascalTriangleEntry n (k - 1)) * (n + 1 - k) `div` k
+
+
+-- naive recursion (factorial are pretty slow)
+-- pascalTriangleEntry :: Int -> Int -> Int
+-- pascalTriangleEntry _ (-1) = 0
+-- pascalTriangleEntry (-1) _ = 0
+-- pascalTriangleEntry _ 0 = 1
+-- pascalTriangleEntry 0 _ = 1
+-- pascalTriangleEntry n k | k == n = 1
+-- pascalTriangleEntry n k = pascalTriangleEntry (n - 1) (k - 1) + pascalTriangleEntry (n - 1) k
diff --git a/haskell/016-power_digit_sum.hs b/haskell/016-power_digit_sum.hs
new file mode 100644
index 0000000..355cfee
--- /dev/null
+++ b/haskell/016-power_digit_sum.hs
@@ -0,0 +1,11 @@
+-- Power digit sum
+--
+-- Problem 16
+-- 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?
+
+
+import Data.Char
+
+main = print (sum [ord x - ord '0' | x <- show (2 ^ 1000)])
diff --git a/haskell/017-number_letter_counts.hs b/haskell/017-number_letter_counts.hs
new file mode 100644
index 0000000..a0449c5
--- /dev/null
+++ b/haskell/017-number_letter_counts.hs
@@ -0,0 +1,62 @@
+-- Number letter counts
+--
+-- Problem 17
+-- 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.
+
+
+-- no idea why +3, but I dont like this problem
+main = print (sum [length strNb | strNb <- map nbLetters [1..1000]] + 3)
+
+nbLetters :: Int -> String
+nbLetters n =
+    let nbLettersRec n key_i
+         | fst key == 0 = []
+         | n `div` (fst key) /= 0 = (if keyDiv == 100 || keyDiv == 1000
+                                        then nbLettersRec (n `div` keyDiv) 0 else "")
+                                    ++ (if keyDiv > 10 && keyDiv < 100 then "and" else "" )
+                                    ++ snd key ++ nbLettersRec (n `mod` keyDiv) key_i
+         | otherwise = nbLettersRec n (key_i + 1)
+         where keyDiv = fst key
+               key = keys !! key_i
+    in nbLettersRec n 0
+
+keys = reverse
+    [ (0, "")
+    , (1, "one")
+    , (2, "two")
+    , (3, "three")
+    , (4, "four")
+    , (5, "five")
+    , (6, "six")
+    , (7, "seven")
+    , (8, "eight")
+    , (9, "nine")
+    , (10, "ten")
+    , (11, "eleven")
+    , (12, "twelve")
+    , (13, "thirteen")
+    , (14, "fourteen")
+    , (15, "fifteen")
+    , (16, "sixteen")
+    , (17, "seventeen")
+    , (18, "eighteen")
+    , (19, "nineteen")
+    , (20, "twenty")
+    , (30, "thirty")
+    , (40, "forty")
+    , (50, "fifty")
+    , (60, "sixty")
+    , (70, "seventy")
+    , (80, "eighty")
+    , (90, "ninety")
+    , (100, "hundred")
+    , (1000, "thousand")
+    ]
diff --git a/haskell/018-maximum_path_sum.hs b/haskell/018-maximum_path_sum.hs
new file mode 100644
index 0000000..fa15fe9
--- /dev/null
+++ b/haskell/018-maximum_path_sum.hs
@@ -0,0 +1,60 @@
+-- Maximum path sum I
+--
+-- Problem 18
+-- 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)
+
+
+main = print (maxPath triangle)
+
+-- recursion is beautiful (sometimes)
+maxPath :: [[Int]] -> Int
+maxPath [[x]] = x
+maxPath (top:rest) = head top + max (maxPath $ map init rest) (maxPath $ map tail rest)
+
+triangle =
+    [ [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]
+    ]
diff --git a/haskell/020-factorial_digit_sum.hs b/haskell/020-factorial_digit_sum.hs
new file mode 100644
index 0000000..cbc404a
--- /dev/null
+++ b/haskell/020-factorial_digit_sum.hs
@@ -0,0 +1,19 @@
+-- Factorial digit sum
+--
+-- Problem 20
+-- 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 Data.Char
+
+main = print (sum [ord x - ord '0' | x <- show $ factorial' 100])
+
+factorial' :: Integer -> Integer
+factorial' 0 = 0
+factorial' 1 = 1
+factorial' n = n * factorial' (n - 1)
diff --git a/python/018-max_path_sum_I.py b/python/018-max_path_sum_I.py
index f091782..e98f272 100644
--- a/python/018-max_path_sum_I.py
+++ b/python/018-max_path_sum_I.py
@@ -22,14 +22,13 @@ def walk_through(triangle, paths=[], x=0, y=0, path=[]):
         if y+1 == len(triangle[-1]):
             return paths
         return [*paths, path]
-        
+
     new_path = [*path, triangle[x][y]]
     return [
         *walk_through(triangle, paths, x+1, y, new_path),
         *walk_through(triangle, paths, x+1, y+1, new_path)
     ]
 
-    
 paths = walk_through(triangle)
 max_path_sum = max([sum(x) for x in paths])