Adding in clean script

.gitignore

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

.vscode/settings.json

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

flake.nix

@@ -55,6 +55,18 @@
             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
       pkgs.mkShell {
         buildInputs = with pkgs.haskellPackages; [
@@ -63,6 +75,9 @@
           haskell-language-server
           ghcid
           hlint
+
+          # Scripts
+          clean
         ];
 
         shellHook = ''

src/interviewing.io/2023-09-16-question1.hs

@@ -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

src/projectEuler/question13.hs

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

src/projectEuler/question5.hs

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

src/projectEuler/question6.hs

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

src/projectEuler/question7.hs

@@ -1,6 +1,9 @@
 -- https://projecteuler.net/problem=7
 -- Find the 10_001 prime number
 
+-- import           Data.Numbers.Primes (primes)
+import           Math.NumberTheory.Primes (primes)
+
 primes1 :: [Integer]
 primes1 = 2:3:prs
   where
@@ -30,3 +33,8 @@ primes2 = 2:([3..] `minus` composites)
 primes3 = sieve [2..]
   where
     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

src/projectEuler/question8.hs

@@ -28,6 +28,7 @@ What is the value of this product?
 module Main where
 
 import           Data.Char       (ord)
+import           Data.Foldable   (maximumBy)
 import           Data.List       (sort)
 import           Data.List.Split (splitOn)
 
@@ -46,9 +47,16 @@ digits = go []
 main :: IO ()
 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?
 --  why ask it like that???

src/projectEuler/question9.hs

@@ -17,14 +17,39 @@ Find the product `abc`.
 -}
 
 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 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 (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