Difference between revisions of "Euler problems/151 to 160"

== [http://projecteuler.net/index.php?section=problems&id=151 Problem 151] ==

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>