1
0
Fork 0

Compare commits

..

5 Commits

10 changed files with 157 additions and 20 deletions

14
.gitignore vendored
View File

@ -1 +1,15 @@
# Ignore all executables
### Ignore all
*
### Unignore all with extensions
!*.*
### Unignore all dirs
!*/
# Regular gitignore
.direnv .direnv
# Haskell IR files
*.hi
*.o

View File

@ -2,6 +2,7 @@
"cSpell.words": [ "cSpell.words": [
"concat", "concat",
"coprime", "coprime",
"elems",
"foldl" "foldl"
] ]
} }

View File

@ -55,6 +55,18 @@
Chart-cairo Chart-cairo
] ]
); );
clean = pkgs.writeShellScriptBin "clean" ''
# Delete executables
find . -type f -executable -not -path '*/.git/*' -delete
# Delete all Haskell IR files
find . -type f -name '*.hi' -delete
find . -type f -name '*.o' -delete
# Delete any test graphs created
find . -type f -name 'test.png' -delete
'';
in in
pkgs.mkShell { pkgs.mkShell {
buildInputs = with pkgs.haskellPackages; [ buildInputs = with pkgs.haskellPackages; [
@ -63,6 +75,9 @@
haskell-language-server haskell-language-server
ghcid ghcid
hlint hlint
# Scripts
clean
]; ];
shellHook = '' shellHook = ''

View File

@ -0,0 +1,49 @@
import qualified Data.List as List
import qualified Data.Maybe as Maybe
import Data.Set (Set)
import qualified Data.Set as Set
{-
interviewing.io question:
<https://interviewing.io/mocks/linked-in-python-matching-pairs>
Given a list of whole positive numbers, how would you go about finding two numbers in that list that sum up to a given target number. Assume no duplicates in list.
-}
wholePositiveNumbers :: Set Integer
wholePositiveNumbers = Set.fromAscList [1..1_000_000]
-- findTargetSumIn xs n =
-- (if abs (x-n) `member` xs
-- && abs (x-n) + x == n
-- then Just (abs (x-n), x)
-- else Nothing) : findTargetSumIn xs n
-- where
-- x =
ans lst sum = List.nubBy isMirror $ Maybe.catMaybes $ Set.elems $ Set.map (\x ->
let x' = abs (x-sum)
in
if x' `Set.member` lst
&& x' + x == sum
then Just (x',x)
else Nothing
) lst
isMirror (a,a') (b,b')
= a == b'
&& b == a'
example = Set.fromList [14,13,6,7,8,10,1,2]
example' = Set.fromList [14,13,6,7,8,10,1]
example'' = Set.fromList [1,14,13,3,6,7,2,8,10,4]
main = do
print "Quick 3 answers:"
print $ ans example 3
print $ ans example' 3
print $ ans example'' 5
print "Long answer"
print $ ans wholePositiveNumbers 3

View File

@ -221,4 +221,6 @@ ans :: [Integer]
ans = take 10 $ reverse . digits $ sum oneHundredFiftyDigitNumbers ans = take 10 $ reverse . digits $ sum oneHundredFiftyDigitNumbers
main :: IO () main :: IO ()
main = print ans main = do
print ans
print (sum oneHundredFiftyDigitNumbers)

View File

@ -63,3 +63,5 @@ test = map (filter . multipleOf) [1..10]
-- lol -- lol
solve = foldl1 lcm [1..20] solve = foldl1 lcm [1..20]
main = print solve

View File

@ -13,16 +13,29 @@ Find the difference between the sum of the squares
of the first one hundred natural numbers of the first one hundred natural numbers
and the square of the sum. and the square of the sum.
-} -}
upperRange = 100 upperRange :: Integer
upperRange = 1_000_000
square :: Num a => a -> a
square n = n^2 square n = n^2
squares :: [Integer]
squares = map square [1..upperRange] squares = map square [1..upperRange]
sum' :: [Integer] -> Integer
sum' = go 0 sum' = go 0
where where
go acc [] = acc go acc [] = acc
go acc (x:xs) = go (acc+x) xs go acc (x:xs) = go (acc+x) xs
sumOfSquares = sum' squares sumOfSquares :: Integer
sumOfSquares = sum squares
squareOfTheSum = (sum [1..upperRange])^2 squareOfTheSum :: Integer
squareOfTheSum = sum [1..upperRange] ^2
solution :: Integer
solution = squareOfTheSum - sumOfSquares solution = squareOfTheSum - sumOfSquares
main :: IO ()
main = print solution

View File

@ -1,6 +1,9 @@
-- https://projecteuler.net/problem=7 -- https://projecteuler.net/problem=7
-- Find the 10_001 prime number -- Find the 10_001 prime number
-- import Data.Numbers.Primes (primes)
import Math.NumberTheory.Primes (primes)
primes1 :: [Integer] primes1 :: [Integer]
primes1 = 2:3:prs primes1 = 2:3:prs
where where
@ -30,3 +33,8 @@ primes2 = 2:([3..] `minus` composites)
primes3 = sieve [2..] primes3 = sieve [2..]
where where
sieve (p : xs) = p : sieve [x | x <- xs, x `mod` p > 0] sieve (p : xs) = p : sieve [x | x <- xs, x `mod` p > 0]
main :: IO ()
main = print $ "Arithmoi - Math.NumberTheory.Primes: " <> show ans
ans = primes !! 10_000_000

View File

@ -28,6 +28,7 @@ What is the value of this product?
module Main where module Main where
import Data.Char (ord) import Data.Char (ord)
import Data.Foldable (maximumBy)
import Data.List (sort) import Data.List (sort)
import Data.List.Split (splitOn) import Data.List.Split (splitOn)
@ -46,9 +47,16 @@ digits = go []
main :: IO () main :: IO ()
main = print ans main = print ans
ans :: [[Integer]] ans :: ([Integer], Integer)
ans = (windowsOf 13 . digits) thousandDigitNum ans = (l, p)
-- "9878799272442" where
l = maximumBy c $ (windowsOf 13 . digits) thousandDigitNum
p = product l
c a b
| product a > product b = GT
| product a < product b = LT
| otherwise = EQ
-- "([5,5,7,6,6,8,9,6,6,4,8,9,5],23514624000)"
-- what dose it mean to have the greatest product in adjacent digits? -- what dose it mean to have the greatest product in adjacent digits?
-- why ask it like that??? -- why ask it like that???

View File

@ -17,14 +17,39 @@ Find the product `abc`.
-} -}
main :: IO () main :: IO ()
main = print answer main = do
print answer
print (product answer)
answer :: String -- head $ [(a,b,c) | a <- [1..limit], b <- [a+1..limit], c <- [limit - a - b], a < b, b < c, a^2 + b^2 == c^2]
answer = "I dunno" answer :: [Integer]
answer = head $
[ [a, b, c] |
a <- [1 .. limit],
b <- [a + 1 .. limit],
c <- [limit - a - b],
b < c,
a ^ 2 + b ^ 2 == c ^ 2]
where limit = 1000
limit = 1000
version1 = [ [a, b, c] |
a <- [1 .. limit],
b <- [a + 1 .. limit],
c <- [limit - a - b],
b < c,
a ^ 2 + b ^ 2 == c ^ 2]
version2 = [ [a, b, c] |
a <- [1 .. limit],
b <- [a + 1 .. limit],
c <- [limit - a - b],
b < c,
a ^ 2 + b ^ 2 == c ^ 2]
solve :: Integer -> [(Integer, Integer, Integer)] solve :: Integer -> [(Integer, Integer, Integer)]
solve x = takeWhile (\(a,b,c) -> a + b + c <= 1000) $ primitiveTriplesUnder x solve x = takeWhile (\(a,b,c) -> a + b + c == 1000) $ primitiveTriplesUnder x
euclid'sFormula :: Num c => (c, c) -> (c, c, c) euclid'sFormula :: Num c => (c, c) -> (c, c, c)
euclid'sFormula (m, n) = (a,b,c) euclid'sFormula (m, n) = (a,b,c)
@ -96,10 +121,10 @@ ans' limit = [(a, b, c)
-} -}
-- Computers are fast, so we can implement a brute-force search to directly solve the problem. -- -- Computers are fast, so we can implement a brute-force search to directly solve the problem.
perim = 1000 -- perim = 1000
main = putStrLn (show ans) -- main = putStrLn (show ans)
ans = head [a * b * (perim - a - b) | a <- [1..perim], b <- [a+1..perim], isIntegerRightTriangle a b] -- ans = head [a * b * (perim - a - b) | a <- [1..perim], b <- [a+1..perim], isIntegerRightTriangle a b]
isIntegerRightTriangle a b = a < b && b < c -- isIntegerRightTriangle a b = a < b && b < c
&& a * a + b * b == c * c -- && a * a + b * b == c * c
where c = perim - a - b -- where c = perim - a - b