Compare commits
No commits in common. "8f5004d6ff65bd78ee745cd70fe52cb9ec50cf65" and "a0fef78e65a01709bc32c81b7b7c3ed7b6529531" have entirely different histories.
8f5004d6ff
...
a0fef78e65
|
|
@ -1,7 +0,0 @@
|
|||
{
|
||||
"cSpell.words": [
|
||||
"concat",
|
||||
"coprime",
|
||||
"foldl"
|
||||
]
|
||||
}
|
||||
|
|
@ -45,14 +45,6 @@
|
|||
aeson
|
||||
random
|
||||
neat-interpolation
|
||||
|
||||
# maths
|
||||
primes
|
||||
arithmoi
|
||||
|
||||
# graphing libraries!
|
||||
Chart
|
||||
Chart-cairo
|
||||
]
|
||||
);
|
||||
in
|
||||
|
|
|
|||
|
|
@ -1,121 +0,0 @@
|
|||
{-
|
||||
Summation of Primes
|
||||
Problem 10
|
||||
|
||||
The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
|
||||
|
||||
Find the sum of all the primes below two million.
|
||||
|
||||
|
||||
https://wiki.haskell.org/Prime_numbers
|
||||
|
||||
Compile with `ghc -O3 src/projectEuler/question10.hs`
|
||||
Run with `time src/projectEuler/question10`
|
||||
-}
|
||||
{-# OPTIONS_GHC -O2 #-}
|
||||
|
||||
import Control.Monad (forM_, when)
|
||||
import Data.Array.Base (IArray (unsafeAt),
|
||||
MArray (unsafeWrite),
|
||||
UArray (UArray),
|
||||
unsafeFreezeSTUArray)
|
||||
import Data.Array.ST (MArray (newArray), readArray,
|
||||
runSTUArray, writeArray)
|
||||
import Data.Array.Unboxed (UArray, assocs)
|
||||
import Data.Bits (Bits (shiftL, shiftR))
|
||||
import Data.Int (Int64)
|
||||
import Data.List (genericIndex, genericTake)
|
||||
import Data.Word (Word64)
|
||||
-- https://hackage.haskell.org/package/arithmoi-0.13.0.0
|
||||
import Math.NumberTheory.Primes (Prime (unPrime), primes)
|
||||
|
||||
main :: IO ()
|
||||
main = do
|
||||
print "Hello! Welcome to the prime number generator."
|
||||
-- print "Please enter which nth prime you'd like: "
|
||||
-- n <- getLine
|
||||
-- let n' = read n :: Integer
|
||||
-- print $ "Finding the " ++ n ++ "th prime."
|
||||
-- print $ primes() `genericIndex` (10^ (10 :: Int))
|
||||
print $ last $ take (10^ (10 :: Int)) primes
|
||||
|
||||
ans :: Integer
|
||||
ans = sum $ takeWhile (< 2_000_000) $ map unPrime primes
|
||||
|
||||
|
||||
primes1 :: [Integer]
|
||||
primes1 = sieve [2..]
|
||||
where
|
||||
sieve (p : xs) = p : sieve [x | x <- xs, x `mod` p > 0]
|
||||
|
||||
primes2 :: [Integer]
|
||||
primes2 = 2:([3..] `minus` composites)
|
||||
where
|
||||
composites = union [multiples p | p <- primes2]
|
||||
|
||||
multiples n = map (n*) [n..]
|
||||
|
||||
(x:xs) `minus` (y:ys) | x < y = x:(xs `minus` (y:ys))
|
||||
| x == y = xs `minus` ys
|
||||
| x > y = (x:xs) `minus` ys
|
||||
union = foldr merge [ ]
|
||||
where
|
||||
merge (x:xs) ys = x:merge' xs ys
|
||||
merge' (x:xs) (y:ys) | x < y = x:merge' xs (y:ys)
|
||||
| x == y = x:merge' xs ys
|
||||
| x > y = y:merge' (x:xs) ys
|
||||
|
||||
|
||||
{-
|
||||
https://wiki.haskell.org/Prime_numbers
|
||||
Using Page-Segmented ST-Mutable Unboxed Array
|
||||
-}
|
||||
-- type Prime = Word64
|
||||
|
||||
-- cSieveBufferLimit :: Int
|
||||
-- cSieveBufferLimit = 2^17 * 8 - 1 -- CPU L2 cache in bits
|
||||
|
||||
-- primes :: () -> [Prime]
|
||||
-- primes() = 2 : _Y (listPagePrms . pagesFrom 0) where
|
||||
-- _Y g = g (_Y g) -- non-sharing multi-stage fixpoint combinator
|
||||
-- listPagePrms pgs@(hdpg@(UArray lwi _ rng _) : tlpgs) =
|
||||
-- let loop i | i >= fromIntegral rng = listPagePrms tlpgs
|
||||
-- | unsafeAt hdpg i = loop (i + 1)
|
||||
-- | otherwise = let ii = lwi + fromIntegral i in
|
||||
-- case fromIntegral $ 3 + ii + ii of
|
||||
-- p -> p `seq` p : loop (i + 1) in loop 0
|
||||
-- makePg lwi bps = runSTUArray $ do
|
||||
-- let limi = lwi + fromIntegral cSieveBufferLimit
|
||||
-- bplmt = floor $ sqrt $ fromIntegral $ limi + limi + 3
|
||||
-- strta bp = let si = fromIntegral $ (bp * bp - 3) `shiftR` 1
|
||||
-- in if si >= lwi then fromIntegral $ si - lwi else
|
||||
-- let r = fromIntegral (lwi - si) `mod` bp
|
||||
-- in if r == 0 then 0 else fromIntegral $ bp - r
|
||||
-- cmpsts <- newArray (lwi, limi) False
|
||||
-- fcmpsts <- unsafeFreezeSTUArray cmpsts
|
||||
-- let cbps = if lwi == 0 then listPagePrms [fcmpsts] else bps
|
||||
-- forM_ (takeWhile (<= bplmt) cbps) $ \ bp ->
|
||||
-- forM_ (let sp = fromIntegral $ strta bp
|
||||
-- in [ sp, sp + fromIntegral bp .. cSieveBufferLimit ]) $ \c ->
|
||||
-- unsafeWrite cmpsts c True
|
||||
-- return cmpsts
|
||||
-- pagesFrom lwi bps = map (`makePg` bps)
|
||||
-- [ lwi, lwi + fromIntegral cSieveBufferLimit + 1 .. ]
|
||||
|
||||
|
||||
|
||||
|
||||
-- sieveUA :: Int -> UArray Int Bool
|
||||
-- sieveUA top = runSTUArray $ do
|
||||
-- let m = (top-1) `div` 2
|
||||
-- r = floor . sqrt $ fromIntegral top + 1
|
||||
-- sieve <- newArray (1,m) True -- :: ST s (STUArray s Int Bool)
|
||||
-- forM_ [1..r `div` 2] $ \i -> do
|
||||
-- isPrime <- readArray sieve i
|
||||
-- when isPrime $ do -- ((2*i+1)^2-1)`div`2 == 2*i*(i+1)
|
||||
-- forM_ [2*i*(i+1), 2*i*(i+2)+1..m] $ \j -> do
|
||||
-- writeArray sieve j False
|
||||
-- return sieve
|
||||
|
||||
-- primesToUA :: Int -> [Int]
|
||||
-- primesToUA top = 2 : [i*2+1 | (i,True) <- assocs $ sieveUA top]
|
||||
|
|
@ -1,110 +0,0 @@
|
|||
{-
|
||||
In the 20x20 grid below, four numbers along a diagonal line have been marked in *red*.
|
||||
|
||||
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
|
||||
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
|
||||
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
|
||||
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
|
||||
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
|
||||
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
|
||||
32 98 81 28 64 23 67 10*26*38 40 67 59 54 70 66 18 38 64 70
|
||||
67 26 20 68 02 62 12 20 95*63*94 39 63 08 40 91 66 49 94 21
|
||||
24 55 58 05 66 73 99 26 97 17*78*78 96 83 14 88 34 89 63 72
|
||||
21 36 23 09 75 00 76 44 20 45 35*14*00 61 33 97 34 31 33 95
|
||||
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
|
||||
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
|
||||
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
|
||||
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
|
||||
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
|
||||
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
|
||||
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
|
||||
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
|
||||
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
|
||||
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
|
||||
|
||||
The product of these numbers is 26x63x78x14 = 1788696.
|
||||
|
||||
What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20x20 grid?
|
||||
-}
|
||||
import Data.List (genericDrop, genericIndex, genericTake)
|
||||
|
||||
grid :: [[Integer]]
|
||||
grid =
|
||||
[ [08, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 08]
|
||||
, [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00]
|
||||
, [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65]
|
||||
, [52, 70, 95, 23, 04, 60, 11, 42, 69, 24, 68, 56, 01, 32, 56, 71, 37, 02, 36, 91]
|
||||
, [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80]
|
||||
, [24, 47, 32, 60, 99, 03, 45, 02, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50]
|
||||
, [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70]
|
||||
, [67, 26, 20, 68, 02, 62, 12, 20, 95, 63, 94, 39, 63, 08, 40, 91, 66, 49, 94, 21]
|
||||
, [24, 55, 58, 05, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72]
|
||||
, [21, 36, 23, 09, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95]
|
||||
, [78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 03, 80, 04, 62, 16, 14, 09, 53, 56, 92]
|
||||
, [16, 39, 05, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57]
|
||||
, [86, 56, 00, 48, 35, 71, 89, 07, 05, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58]
|
||||
, [19, 80, 81, 68, 05, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 04, 89, 55, 40]
|
||||
, [04, 52, 08, 83, 97, 35, 99, 16, 07, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66]
|
||||
, [88, 36, 68, 87, 57, 62, 20, 72, 03, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69]
|
||||
, [04, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 08, 46, 29, 32, 40, 62, 76, 36]
|
||||
, [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16]
|
||||
, [20, 73, 35, 29, 78, 31, 90, 01, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 05, 54]
|
||||
, [01, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48]
|
||||
]
|
||||
|
||||
points :: Integer -> [(Integer, Integer)]
|
||||
points n = [ (x,y) | x <- [1..n], y <- [1..n] ]
|
||||
|
||||
allDiagonals :: Integer -> [[(Integer, Integer)]]
|
||||
allDiagonals n =
|
||||
[ [(i, j), b, c, d]
|
||||
| (i, j) <- points n
|
||||
, i+3 <= n
|
||||
, j+3 <= n
|
||||
, b <- [(i + 1, j + 1)]
|
||||
, c <- [(i + 2, j + 2)]
|
||||
, d <- [(i + 3, j + 3)]
|
||||
]
|
||||
|
||||
allUpDown :: Integer -> [[(Integer, Integer)]]
|
||||
allUpDown n =
|
||||
[ [(i, j), b, c, d]
|
||||
| (i, j) <- points n
|
||||
, i <= n
|
||||
, j+3 <= n
|
||||
, b <- [(i, j + 1)]
|
||||
, c <- [(i, j + 2)]
|
||||
, d <- [(i, j + 3)]
|
||||
]
|
||||
|
||||
allLeftRight :: Integer -> [[(Integer, Integer)]]
|
||||
allLeftRight n =
|
||||
[ [(i, j), b, c, d]
|
||||
| (i, j) <- points n
|
||||
, i+3 <= n
|
||||
, j <= n
|
||||
, b <- [(i + 1, j)]
|
||||
, c <- [(i + 2, j)]
|
||||
, d <- [(i + 3, j)]
|
||||
]
|
||||
|
||||
allSequences :: Integer -> [[(Integer, Integer)]]
|
||||
allSequences n = allDiagonals n ++ allUpDown n ++ allLeftRight n
|
||||
|
||||
s20x20 :: [[(Integer, Integer)]]
|
||||
s20x20 = allSequences 20
|
||||
|
||||
getValue :: [[Integer]] -> (Integer, Integer) -> Integer
|
||||
getValue grid (x,y) = row `genericIndex` y'
|
||||
where row = (head . genericDrop (x-1) . genericTake x) grid
|
||||
y' = y-1 -- compensate for 1 index numbering above
|
||||
|
||||
-- |
|
||||
-- λ> ans
|
||||
-- 51267216
|
||||
-- (0.13 secs, 38,281,312 bytes)
|
||||
ans :: Integer
|
||||
ans = maximum $ map (product . map (getValue grid)) s20x20
|
||||
|
||||
main :: IO ()
|
||||
main = print ans
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
-- module Main where
|
||||
import Data.IntSet (size)
|
||||
import Data.List (unfoldr)
|
||||
import Math.NumberTheory.ArithmeticFunctions (divisorsSmall)
|
||||
|
||||
main :: IO ()
|
||||
main = print ans
|
||||
|
||||
-- triangleNumber :: Integer -> [Integer]
|
||||
-- triangleNumber 1 = [1]
|
||||
-- triangleNumber n = sum [1..n] : triangleNumber (n-1)
|
||||
triangleNumber i = (i * (i + 1)) `div` 2
|
||||
triangleNumbers = map triangleNumber [1..]
|
||||
-- triangleNumbers :: [Int]
|
||||
-- triangleNumbers = unfoldr (\b-> Just (sum [1..b],b+1)) 1
|
||||
|
||||
-- isDivisible a b = a `rem` b == 0
|
||||
-- divisors n = filter (isDivisible n) [1..(floor . sqrt) n ]
|
||||
|
||||
-- Triangle Numbers With More than N divisors
|
||||
tnwmtNd :: Int -> [Int]
|
||||
tnwmtNd n = filter ((>= n) . size . divisorsSmall) triangleNumbers
|
||||
|
||||
ans :: Int
|
||||
ans = head $ tnwmtNd 500
|
||||
{-
|
||||
λ> main
|
||||
76576500
|
||||
(0.00 secs, 114,944 bytes)
|
||||
|
||||
First triangle number to have over 500 divisors is 76576500
|
||||
-}
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
-- https://projecteuler.net/problem=7
|
||||
-- Find the 10_001 prime number
|
||||
|
||||
primes1 :: [Integer]
|
||||
primes1 = 2:3:prs
|
||||
where
|
||||
1:p:candidates = [6*k+r | k <- [0..], r <- [1,5]]
|
||||
prs = p : filter isPrime candidates
|
||||
isPrime n = not (any (divides n) (takeWhile (\p -> p*p <= n) prs))
|
||||
divides n p = n `mod` p == 0
|
||||
|
||||
|
||||
primes2 = 2:([3..] `minus` composites)
|
||||
where
|
||||
composites = union [multiples p | p <- primes2]
|
||||
|
||||
multiples n = map (n*) [n..]
|
||||
|
||||
(x:xs) `minus` (y:ys) | x < y = x:(xs `minus` (y:ys))
|
||||
| x == y = xs `minus` ys
|
||||
| x > y = (x:xs) `minus` ys
|
||||
union = foldr merge [ ]
|
||||
where
|
||||
merge (x:xs) ys = x:merge' xs ys
|
||||
merge' (x:xs) (y:ys) | x < y = x:merge' xs (y:ys)
|
||||
| x == y = x:merge' xs ys
|
||||
| x > y = y:merge' (x:xs) ys
|
||||
|
||||
|
||||
primes3 = sieve [2..]
|
||||
where
|
||||
sieve (p : xs) = p : sieve [x | x <- xs, x `mod` p > 0]
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
{-
|
||||
The four adjacent digits in the 1000-digit number that have the greatest product are 9 x 9 x 8 x 9 = 5832.
|
||||
|
||||
73167176531330624919225119674426574742355349194934
|
||||
96983520312774506326239578318016984801869478851843
|
||||
85861560789112949495459501737958331952853208805511
|
||||
12540698747158523863050715693290963295227443043557
|
||||
66896648950445244523161731856403098711121722383113
|
||||
62229893423380308135336276614282806444486645238749
|
||||
30358907296290491560440772390713810515859307960866
|
||||
70172427121883998797908792274921901699720888093776
|
||||
65727333001053367881220235421809751254540594752243
|
||||
52584907711670556013604839586446706324415722155397
|
||||
53697817977846174064955149290862569321978468622482
|
||||
83972241375657056057490261407972968652414535100474
|
||||
82166370484403199890008895243450658541227588666881
|
||||
16427171479924442928230863465674813919123162824586
|
||||
17866458359124566529476545682848912883142607690042
|
||||
24219022671055626321111109370544217506941658960408
|
||||
07198403850962455444362981230987879927244284909188
|
||||
84580156166097919133875499200524063689912560717606
|
||||
05886116467109405077541002256983155200055935729725
|
||||
71636269561882670428252483600823257530420752963450
|
||||
|
||||
Find the thirteen adjacent digits in the 1000-digit number that have the greatest product.
|
||||
What is the value of this product?
|
||||
-}
|
||||
module Main where
|
||||
|
||||
import Data.Char (ord)
|
||||
import Data.List (sort)
|
||||
import Data.List.Split (splitOn)
|
||||
|
||||
thousandDigitNum :: Integer
|
||||
thousandDigitNum = 7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450
|
||||
|
||||
digits :: Integer -> [Integer]
|
||||
digits = go []
|
||||
where
|
||||
go acc 0 = acc
|
||||
go acc n = go (digit:acc) rest
|
||||
where
|
||||
digit = n `rem` 10
|
||||
rest = n `div` 10
|
||||
|
||||
main :: IO ()
|
||||
main = print ans
|
||||
|
||||
ans :: [[Integer]]
|
||||
ans = (windowsOf 13 . digits) thousandDigitNum
|
||||
-- "9878799272442"
|
||||
|
||||
-- what dose it mean to have the greatest product in adjacent digits?
|
||||
-- why ask it like that???
|
||||
-- doesn't have 0
|
||||
-- otherwise is the largest number in the larger 1000-digit number
|
||||
chunksWithoutZero :: Int -> [String]
|
||||
chunksWithoutZero n = (filter (\str -> length str >= n) . filter (/= "") . splitOn "0" . show) thousandDigitNum
|
||||
|
||||
windowsOf :: Int -> [a] -> [[a]]
|
||||
windowsOf n = drop (n-1) . go []
|
||||
where
|
||||
go acc [] = acc
|
||||
go acc lst = go (lst':acc) (tail lst)
|
||||
where
|
||||
lst' = take n lst
|
||||
|
|
@ -1,105 +0,0 @@
|
|||
import Debug.Trace (trace)
|
||||
import Graphics.Rendering.Chart.Backend.Cairo
|
||||
import Graphics.Rendering.Chart.Easy
|
||||
{-
|
||||
Special Pythagorean Triplet
|
||||
Problem 9
|
||||
|
||||
A Pythagorean triplet is a set of three natural numbers, `a < b < c`, for which,
|
||||
|
||||
`a^2 + b^2 = c^2`.
|
||||
|
||||
For example, `3^2 + 4^2 = 9 + 16 = 25 = 5^2`.
|
||||
|
||||
There exists exactly one Pythagorean triplet for which `a + b + c = 1000`.
|
||||
|
||||
Find the product `abc`.
|
||||
-}
|
||||
|
||||
main :: IO ()
|
||||
main = print answer
|
||||
|
||||
answer :: String
|
||||
answer = "I dunno"
|
||||
|
||||
|
||||
solve :: Integer -> [(Integer, Integer, Integer)]
|
||||
solve x = takeWhile (\(a,b,c) -> a + b + c <= 1000) $ primitiveTriplesUnder x
|
||||
|
||||
euclid'sFormula :: Num c => (c, c) -> (c, c, c)
|
||||
euclid'sFormula (m, n) = (a,b,c)
|
||||
where
|
||||
a = m^2 - n^2
|
||||
b = 2*m*n
|
||||
c = m^2 + n^2
|
||||
|
||||
listOfMNs :: Integer -> [(Integer, Integer)]
|
||||
listOfMNs x =
|
||||
[ (m,n)
|
||||
| n <- [2,4..x] -- one of them is even
|
||||
, m <- [n+1,n+3..x]
|
||||
, gcd m n == 1 -- coprime
|
||||
]
|
||||
|
||||
listOfMNs' :: Integer -> [(Integer, Integer)]
|
||||
listOfMNs' x =
|
||||
[ (m,n)
|
||||
| n <- [2,4..] -- one of them is even
|
||||
, m <- [n+1,n+3..]
|
||||
, gcd m n == 1 -- coprime
|
||||
, a m n + b m n + c m n <= x
|
||||
] where
|
||||
a m n = m^2 - n^2
|
||||
b m n = 2*m*n
|
||||
c m n = m^2 + n^2
|
||||
|
||||
|
||||
primitiveTriplesUnder :: Integer -> [(Integer, Integer, Integer)]
|
||||
primitiveTriplesUnder = map euclid'sFormula . listOfMNs
|
||||
|
||||
|
||||
test :: [(Integer, Integer, Integer)]
|
||||
test = [ (a,b,c)
|
||||
| a <- [3..],
|
||||
b <- take 10 [a+1..],
|
||||
c <- takeWhile (\c -> a^2 + b^2 <= c^2) [b+1..]
|
||||
]
|
||||
|
||||
ls :: [(Integer, Integer)]
|
||||
ls = filter (\(m,n) -> gcd m n == 1) $ zip [5,9..] [2,4..]
|
||||
|
||||
diags :: Integer -> [(Integer, Integer)]
|
||||
diags n = [(x,y) | x<-[0..n], y<-[0..n]]
|
||||
|
||||
|
||||
graph :: IO ()
|
||||
graph = toFile def "test.png" $ do
|
||||
layout_title .= "Points"
|
||||
plot (line "points" [ [ (x,y) | (x,y) <- listOfMNs 30] ])
|
||||
|
||||
|
||||
-- main'' = print ans'
|
||||
ans' :: Integer -> [(Integer, Integer, Integer)]
|
||||
ans' limit = [(a, b, c)
|
||||
| a <- [1 .. limit]
|
||||
, b <- [a + 1 .. limit]
|
||||
, c <- [limit - a - b]
|
||||
, b < c
|
||||
]
|
||||
|
||||
{-
|
||||
- Solution to Project Euler problem 9
|
||||
- Copyright (c) Project Nayuki. All rights reserved.
|
||||
-
|
||||
- https://www.nayuki.io/page/project-euler-solutions
|
||||
- https://github.com/nayuki/Project-Euler-solutions
|
||||
-}
|
||||
|
||||
|
||||
-- Computers are fast, so we can implement a brute-force search to directly solve the problem.
|
||||
perim = 1000
|
||||
main = putStrLn (show ans)
|
||||
ans = head [a * b * (perim - a - b) | a <- [1..perim], b <- [a+1..perim], isIntegerRightTriangle a b]
|
||||
isIntegerRightTriangle a b = a < b && b < c
|
||||
&& a * a + b * b == c * c
|
||||
where c = perim - a - b
|
||||
Loading…
Reference in New Issue