# Euler problems/151 to 160

### From HaskellWiki

## Contents |

## 1 Problem 151

Paper sheets of standard sizes: an expected-value problem.

Solution:

problem_151 = fun (1,1,1,1) fun (0,0,0,1) = 0 fun (0,0,1,0) = fun (0,0,0,1) + 1 fun (0,1,0,0) = fun (0,0,1,1) + 1 fun (1,0,0,0) = fun (0,1,1,1) + 1 fun (a,b,c,d) = (pickA + pickB + pickC + pickD) / (a + b + c + d) where pickA | a > 0 = a * fun (a-1,b+1,c+1,d+1) | otherwise = 0 pickB | b > 0 = b * fun (a,b-1,c+1,d+1) | otherwise = 0 pickC | c > 0 = c * fun (a,b,c-1,d+1) | otherwise = 0 pickD | d > 0 = d * fun (a,b,c,d-1) | otherwise = 0

## 2 Problem 152

Writing 1/2 as a sum of inverse squares

Note that if p is an odd prime, the sum of inverse squares of all terms divisible by p must have reduced denominator not divisible by p.

Solution:

import Data.Ratio import Data.List invSq n = 1 % (n * n) sumInvSq = sum . map invSq subsets (x:xs) = let s = subsets xs in s ++ map (x :) s subsets _ = [[]] primes = 2 : 3 : 7 : [p | p <- [11, 13..79], all (\q -> p `mod` q /= 0) [3, 5, 7]] -- All subsets whose sum of inverse squares, -- when added to x, does not contain a factor of p pfree s x p = [(y, t) | t <- subsets s, let y = x + sumInvSq t, denominator y `mod` p /= 0] -- All pairs (x, s) where x is a rational number whose reduced -- denominator is not divisible by any prime greater than 3; -- and s is all sets of numbers up to 80 divisible -- by a prime greater than 3, whose sum of inverse squares is x. only23 = foldl fun [(0, [[]])] [13, 7, 5] where fun a p = collect $ [(y, u ++ v) | (x, s) <- a, (y, v) <- pfree (terms p) x p, u <- s] terms p = [n * p | n <- [1..80`div`p], all (\q -> n `mod` q /= 0) $ 11 : takeWhile (>= p) [13, 7, 5] ] collect = map (\z -> (fst $ head z, map snd z)) . groupBy fstEq . sortBy cmpFst fstEq (x, _) (y, _) = x == y cmpFst (x, _) (y, _) = compare x y -- All subsets (of an ordered set) whose sum of inverse squares is x findInvSq x y = fun x $ zip3 y (map invSq y) (map sumInvSq $ init $ tails y) where fun 0 _ = [[]] fun x ((n, r, s):ns) | r > x = fun x ns | s < x = [] | otherwise = map (n :) (fun (x - r) ns) ++ fun x ns fun _ _ = [] -- All numbers up to 80 that are divisible only by the primes -- 2 and 3 and are not divisible by 32 or 27. all23 = [n | a <- [0..4], b <- [0..2], let n = 2^a * 3^b, n <= 80] solutions = [sort $ u ++ v | (x, s) <- only23, u <- findInvSq (1%2 - x) all23, v <- s ] problem_152 = length solutions

## 3 Problem 153

Investigating Gaussian Integers

Solution: This was Rob_Harley 's c code pasted from the Project Euler Forum

## 4 Problem 154

Exploring Pascal's pyramid.

## 5 Problem 155

Counting Capacitor Circuits.

Solution:

--http://www.research.att.com/~njas/sequences/A051389 a051389= [1, 2, 4, 8, 20, 42, 102, 250, 610, 1486, 3710, 9228, 23050, 57718, 145288, 365820, 922194, 2327914 ] problem_155 = sum a051389

## 6 Problem 156

Counting Digits

Solution: This was my code, published here without my permission nor any attribution, shame on whoever put it here. Daniel.is.fischer

## 7 Problem 157

Solving the diophantine equation 1/a+1/b= p/10n

Solution:

-- Call (a,b,p) a primitive tuple of equation 1/a+1/b=p/10^n -- a and b are divisors of 10^n, gcd a b == 1, a <= b and a*b <= 10^n -- I noticed that the number of variants with a primitive tuple -- is equal to the number of divisors of p. -- So I produced all possible primitive tuples per 10^n and -- summed all the number of divisors of every p import Data.List k `deelt` n = n `mod` k == 0 delers n | n == 10 = [1,2,5,10] | otherwise = [ d | d <- [1..n `div` 5], d `deelt` n ] ++ [n `div` 4, n `div` 2,n] fp n = [ n*(a+b) `div` ab | a <- ds, b <- dropWhile (<a) ds, gcd a b == 1, let ab = a*b, ab <= n ] where ds = delers n numDivisors :: Integer -> Integer numDivisors n = product [ toInteger (a+1) | (p,a) <- primePowerFactors n] numVgln = sum . map numDivisors . fp main = do print . sum . map numVgln . takeWhile (<=10^9) . iterate (10*) $ 10 primePowerFactors x = [(head a ,length a)|a<-group$primeFactors x] merge xs@(x:xt) ys@(y:yt) = case compare x y of LT -> x : (merge xt ys) EQ -> x : (merge xt yt) GT -> y : (merge xs yt) diff xs@(x:xt) ys@(y:yt) = case compare x y of LT -> x : (diff xt ys) EQ -> diff xt yt GT -> diff xs yt primes, nonprimes :: [Integer] primes = [2,3,5] ++ (diff [7,9..] nonprimes) nonprimes = foldr1 f . map g $ tail primes where f (x:xt) ys = x : (merge xt ys) g p = [ n*p | n <- [p,p+2..]] primeFactors n = factor n primes where factor n (p:ps) | p*p > n = [n] | n `mod` p == 0 = p : factor (n `div` p) (p:ps) | otherwise = factor n ps

## 8 Problem 158

Exploring strings for which only one character comes lexicographically after its neighbour to the left.

Solution:

factorial n = product [1..toInteger n] fallingFactorial x n = product [x - fromInteger i | i <- [0..toInteger n - 1] ] choose n k = fallingFactorial n k `div` factorial k fun n=(2 ^ n - n - 1) * choose 26 n problem_158=maximum$map fun [1..26]

## 9 Problem 159

Digital root sums of factorisations.

Solution:

import Control.Monad import Data.Array.ST import qualified Data.Array.Unboxed as U spfArray :: U.UArray Int Int spfArray = runSTUArray (do arr <- newArray (0,m-1) 0 loop arr 2 forM_ [2 .. m - 1] $ \ x -> loop2 arr x 2 return arr ) where m=10^6 loop arr n |n>=m=return () |otherwise=do writeArray arr n (n-9*(div (n-1) 9)) loop arr (n+1) loop2 arr x n |n*x>=m=return () |otherwise=do incArray arr x n loop2 arr x (n+1) incArray arr x n = do a <- readArray arr x b <- readArray arr n ab <- readArray arr (x*n) when(ab<a+b) (writeArray arr (x*n) (a + b)) writ x=appendFile "p159.log"$foldl (++) "" [show x,"\n"] main=do mapM_ writ $U.elems spfArray problem_159 = main --at first ,make main to get file "p159.log" --then ,add all num in the file

## 10 Problem 160

Factorial trailing digits

We use the following two facts:

Fact 1:We really only need these two facts for the special case of

evaluating the above two Haskell expressions.

More generally:

Fact 1 follows from the fact that the group of invertible elements

of the ring of integers moduloFact 2 follows from the fact that the group of invertible elements

of the ring of integers moduloof a cyclic group of order 2 and another cyclic group.

Solution:

problem_160 = trailingFactorialDigits 5 (10^12) trailingFactorialDigits d n = twos `times` odds where base = 10 ^ d x `times` y = (x * y) `mod` base multiply = foldl' times 1 x `toPower` k = multiply $ genericReplicate n x e = facFactors 2 n - facFactors 5 n twos | e <= d = 2 `toPower` e | otherwise = 2 `toPower` (d + (e - d) `mod` (4 * 5 ^ (d - 1))) odds = multiply [odd | a <- takeWhile (<= n) $ iterate (* 2) 1, b <- takeWhile (<= n) $ iterate (* 5) a, odd <- [3, 5 .. n `div` b `mod` base], odd `mod` 5 /= 0] -- The number of factors of the prime p in n! facFactors p = sum . zipWith (*) (iterate (\x -> p * x + 1) 1) . tail . radix p -- The digits of n in base b representation radix p = map snd . takeWhile (/= (0, 0)) . iterate ((`divMod` p) . fst) . (`divMod` p)

it have another fast way to do this .

Solution:

import Data.List mulMod :: Integral a => a -> a -> a -> a mulMod a b c= (b * c) `rem` a squareMod :: Integral a => a -> a -> a squareMod a b = (b * b) `rem` a pow' :: (Num a, Integral b) => (a -> a -> a) -> (a -> a) -> a -> b -> a pow' _ _ _ 0 = 1 pow' mul sq x' n' = f x' n' 1 where f x n y | n == 1 = x `mul` y | r == 0 = f x2 q y | otherwise = f x2 q (x `mul` y) where (q,r) = quotRem n 2 x2 = sq x powMod :: Integral a => a -> a -> a -> a powMod m = pow' (mulMod m) (squareMod m) productMod =foldl (mulMod (10^5)) 1 hFacial 0=1 hFacial a |gcd a 5==1=mod (a*hFacial(a-1)) (5^5) |otherwise=hFacial(a-1) fastFacial a= hFacial $mod a 6250 numPrime x p=takeWhile(>0) [div x (p^a)|a<-[1..]] p160 x=mulMod t5 a b where t5=10^5 lst=numPrime x 5 a=powMod t5 1563 $mod c 2500 b=productMod c6 c=sum lst c6=map fastFacial $x:lst problem_160 = p160 (10^12)