diff options
Diffstat (limited to 'haskell')
| -rw-r--r-- | haskell/007-10001st_prime.hs | 4 | ||||
| -rw-r--r-- | haskell/013-large_sum.hs | 111 | ||||
| -rw-r--r-- | haskell/014-longest_collatz_sequence.hs | 59 | ||||
| -rw-r--r-- | haskell/015-lattice_paths.hs | 33 | ||||
| -rw-r--r-- | haskell/016-power_digit_sum.hs | 11 | ||||
| -rw-r--r-- | haskell/017-number_letter_counts.hs | 62 | ||||
| -rw-r--r-- | haskell/018-maximum_path_sum.hs | 60 | ||||
| -rw-r--r-- | haskell/020-factorial_digit_sum.hs | 19 |
8 files changed, 359 insertions, 0 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) |