|
|
| Line 1: |
Line 1: |
| − | == [http://projecteuler.net/index.php?section=problems&id=151 Problem 151] ==
| + | Do them on your own! |
| − | Paper sheets of standard sizes: an expected-value problem.
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | problem_151 = undefined
| |
| − | </haskell>
| |
| − | | |
| − | == [http://projecteuler.net/index.php?section=problems&id=152 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:
| |
| − | <haskell>
| |
| − | 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]
| |
| − | | |
| − | -- Verify that we need not consider terms divisible by 11, or by any
| |
| − | -- prime greater than 13. Nor need we consider any term divisible
| |
| − | -- by 25, 27, 32, or 49.
| |
| − | verify = all (\p -> null $ tail $ pfree [p, 2*p..85] 0 p) $
| |
| − | 11 : dropWhile (< 17) primes ++ [25, 27, 32, 49]
| |
| − | | |
| − | -- 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 f [(0, [[]])] [13, 7, 5]
| |
| − | where
| |
| − | f 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 = f x $ zip3 y (map invSq y) (map sumInvSq $ init $ tails y)
| |
| − | where
| |
| − | f 0 _ = [[]]
| |
| − | f x ((n, r, s):ns)
| |
| − | | r > x = f x ns
| |
| − | | s < x = []
| |
| − | | otherwise = map (n :) (f (x - r) ns) ++ f x ns
| |
| − | f _ _ = []
| |
| − | | |
| − | -- 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 = if verify
| |
| − | then [sort $ u ++ v | (x, s) <- only23,
| |
| − | u <- findInvSq (1%2 - x) all23,
| |
| − | v <- s]
| |
| − | else undefined
| |
| − | | |
| − | problem_152 = length solutions
| |
| − | </haskell>
| |
| − | | |
| − | == [http://projecteuler.net/index.php?section=problems&id=153 Problem 153] ==
| |
| − | Investigating Gaussian Integers
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | problem_153 = undefined
| |
| − | </haskell>
| |
| − | | |
| − | == [http://projecteuler.net/index.php?section=problems&id=154 Problem 154] ==
| |
| − | Exploring Pascal's pyramid.
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | #include <stdio.h>
| |
| − | int main(){
| |
| − | int bound = 200000;
| |
| − | long long sum = 0;
| |
| − | int val2[bound+1], val5[bound+1]; // number of factors 2/5 in i!
| |
| − | int v2 = 0, v5 = 0;
| |
| − | int i;
| |
| − | int n;
| |
| − | for(n=0;n<=bound;n++)
| |
| − | {val5[n]=n/5+n/25+n/125+n/625+n/3125+n/15625+n/78125;
| |
| − | val2[n]=n/2+n/4+n/8+n/16+n/32+n/64+n/128+n/256+n/512+n/1024
| |
| − | +n/2048+n/4096+n/8192+n/16384+n/32768+n/65536+n/131072;}
| |
| − | | |
| − | v2 =val2[bound]- 11;
| |
| − | v5 = val5[bound]-11;
| |
| − | int j,k,vi2,vi5;
| |
| − | for(i = 2; i < 65625; i++){
| |
| − | if (!(i&1023)){
| |
| − | // look how many we got so far
| |
| − | printf("%d:\t%lld\n",i,sum);
| |
| − | }
| |
| − | vi5 = val5[i];
| |
| − | vi2 = val2[i];
| |
| − | int jb = ((bound - i) >> 1)+1;
| |
| − | // I want i <= j <= k
| |
| − | // by carry analysis, I know that if i < 4*5^5+2, then
| |
| − | // j must be at least 2*5^6+2
| |
| − | for(j = (i < 12502) ? 31252 : i; j < jb; j++){
| |
| − | k = bound - i - j;
| |
| − | if (vi5 + val5[j] + val5[k] < v5
| |
| − | && vi2 + val2[j] + val2[k] < v2){
| |
| − | if (j == k || i == j){
| |
| − | sum += 3;
| |
| − | } else {
| |
| − | sum += 6;
| |
| − | }
| |
| − | }
| |
| − | }
| |
| − | }
| |
| − | printf("Total:\t%lld\n",sum);
| |
| − | return 0;
| |
| − | }
| |
| − | problem_154 = main
| |
| − | </haskell>
| |
| − | | |
| − | == [http://projecteuler.net/index.php?section=problems&id=155 Problem 155] ==
| |
| − | Counting Capacitor Circuits.
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | problem_155 = undefined
| |
| − | </haskell>
| |
| − | | |
| − | == [http://projecteuler.net/index.php?section=problems&id=156 Problem 156] ==
| |
| − | Counting Digits
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | digits =reverse.digits'
| |
| − | where
| |
| − | digits' n
| |
| − | |n<10=[n]
| |
| − | |otherwise= y:digits' x
| |
| − | where
| |
| − | (x,y)=divMod n 10
| |
| − | digitsToNum n=foldl dmm 0 n
| |
| − | where
| |
| − | dmm=(\x y->x*10+y)
| |
| − | countA :: Int -> Integer
| |
| − | countA 0 = 0
| |
| − | countA k = fromIntegral k * (10^(k-1))
| |
| − |
| |
| − | countFun :: Integer -> Integer -> Integer
| |
| − | countFun _ 0 = 0
| |
| − | countFun d n = countL ds k
| |
| − | where
| |
| − | ds = digits n
| |
| − | k = length ds - 1
| |
| − | countL [a] _
| |
| − | | a < d = 0
| |
| − | | otherwise = 1
| |
| − | countL (a:tl) m
| |
| − | | a < d = a*countA m + countL tl (m-1)
| |
| − | | a == d = a*countA m + digitsToNum tl + 1 + countL tl (m-1)
| |
| − | | otherwise = a*countA m + 10^m + countL tl (m-1)
| |
| − |
| |
| − | fixedPoints :: Integer -> [Integer]
| |
| − | fixedPoints d
| |
| − | = [a*10^10+b | a <- [0 .. d-1], b <- findFrom 0 (10^10-1)]
| |
| − | where
| |
| − | fun = countFun d
| |
| − | good r = r == fun r
| |
| − | findFrom lo hi
| |
| − | | hi < lo = []
| |
| − | | good lo = lgs ++ findFrom (last lgs + 2) hi
| |
| − | | good hi = findFrom lo (last hgs - 2) ++ reverse hgs
| |
| − | | h1 < l1 = []
| |
| − | | l1 == h1 = if good l1 then [l1] else []
| |
| − | | m0 == m1 = findFrom l1 (head mgs - 2) ++ mgs
| |
| − | ++ findFrom (last mgs + 2) h1
| |
| − | | m0 < m1 = findFrom l1 (m0-1) ++ findFrom (goUp h1 m1) h1
| |
| − | | otherwise = findFrom l1 (goDown l1 m1) ++ findFrom (m0+1) h1
| |
| − | where
| |
| − | l1 = goUp hi lo
| |
| − | h1 = goDown l1 hi
| |
| − | goUp bd k
| |
| − | | k < k1 && k < bd = goUp bd k1
| |
| − | | otherwise = k
| |
| − | where
| |
| − | k1 = fun k
| |
| − | goDown bd k
| |
| − | | k1 < k && bd < k = goDown bd k1
| |
| − | | otherwise = k
| |
| − | where
| |
| − | k1 = fun k
| |
| − | m0 = (l1 + h1) `div` 2
| |
| − | m1 = fun m0
| |
| − | lgs = takeWhile good [lo .. hi]
| |
| − | hgs = takeWhile good [hi,hi-1 .. lo]
| |
| − | mgs = reverse (takeWhile good [m0,m0-1 .. l1])
| |
| − | ++ takeWhile good [m0+1 .. h1]
| |
| − | problem_156=sum[sum $fixedPoints a|a<-[1..9]]
| |
| − | </haskell>
| |
| − | | |
| − | == [http://projecteuler.net/index.php?section=problems&id=157 Problem 157] ==
| |
| − | Solving the diophantine equation 1/a+1/b= p/10n
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | problem_157 = undefined
| |
| − | </haskell>
| |
| − | | |
| − | == [http://projecteuler.net/index.php?section=problems&id=158 Problem 158] ==
| |
| − | Exploring strings for which only one character comes lexicographically after its neighbour to the left.
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | problem_158 = undefined
| |
| − | </haskell>
| |
| − | | |
| − | == [http://projecteuler.net/index.php?section=problems&id=159 Problem 159] ==
| |
| − | Digital root sums of factorisations.
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | 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
| |
| − | </haskell>
| |
| − | | |
| − | == [http://projecteuler.net/index.php?section=problems&id=160 Problem 160] ==
| |
| − | Factorial trailing digits
| |
| − | | |
| − | We use the following two facts:
| |
| − | | |
| − | Fact 1: <hask>(2^(d + 4*5^(d-1)) - 2^d) `mod` 10^d == 0</hask>
| |
| − | | |
| − | Fact 2: <hask>product [n | n <- [0..10^d], gcd n 10 == 1] `mod` 10^d == 1</hask>
| |
| − | | |
| − | We really only need these two facts for the special case of
| |
| − | <hask>d == 5</hask>, and we can verify that directly by
| |
| − | 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 modulo <hask>5^d</hask> has
| |
| − | <hask>4*5^(d-1)</hask> elements.
| |
| − | | |
| − | Fact 2 follows from the fact that the group of invertible elements
| |
| − | of the ring of integers modulo <hask>10^d</hask> is isomorphic to the product
| |
| − | of a cyclic group of order 2 and another cyclic group.
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | 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)
| |
| − | </haskell>
| |
| − | it have another fast way to do this .
| |
| − | | |
| − | Solution:
| |
| − | <haskell>
| |
| − | 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)
| |
| − | | |
| − | </haskell>
| |