feat(2024/Day11): part1, part2 too slow

Author: goblivend

2024/Day11/Day11.hs

@@ -0,0 +1,62 @@
+module Main where
+
+import Control.Parallel.Strategies
+import Data.List.Split
+import Debug.Trace
+import System.Environment
+
+-- TODO: Cleanup imports after day done
+
+type Input = [Int]
+
+type Output = Int
+
+parseInput :: String -> Input
+parseInput = map read . splitOn " " . head . lines
+
+digitCount :: Int -> Int
+digitCount 0 = 1
+digitCount n = countThem n
+  where
+    countThem i
+      | i < 10 = 1
+      | otherwise = 1 + countThem (div i 10)
+
+splitNumber :: Int -> Int -> [Int]
+splitNumber n lengthn = [firstHalf, secondHalf]
+  where
+    -- lengthn = digitCount n
+    powered10 = {-# SCC powered10 #-} (10 ^ (div lengthn 2))
+    firstHalf = {-# SCC firstHalf #-} div n powered10
+    secondHalf = {-# SCC secondHalf #-} n - (firstHalf * powered10)
+
+iterateStones :: [Int] -> [Int]
+iterateStones stones = concat $ map iterateStone stones
+  where
+    iterateStone 0 = [1]
+    iterateStone stone
+      | isSplitable = splitNumber stone stoneLength
+      | otherwise = [stone * 2024]
+      where
+        isSplitable = {-# SCC isSplitable #-} (== 0) $ (`mod` 2) stoneLength
+        stoneLength = {-# SCC stoneLength #-} digitCount stone
+
+solve :: Int -> Input -> Output
+solve n arr = length . fst . head . drop n $ iterate (\(l, i) -> trace (show (i, length l)) (iterateStones l, i + 1)) (arr, 0)
+
+part1 :: Input -> Output
+part1 = solve 25
+
+part2 :: Input -> Output
+part2 = solve 35
+
+main :: IO ()
+main = do
+  args <- getArgs
+  content <- readFile (last args)
+  let input = parseInput content
+
+  print input
+
+  print $ part1 input
+  print $ part2 input

2024/Day11/Makefile

@@ -0,0 +1,28 @@
+CONTAINER_NAME=haskell-aoc
+SRC=./Day11.hs
+TARGET=Day11
+all: $(TARGET)
+
+$(TARGET): $(SRC)
+	ghc -O3 $(SRC)
+
+profile: $(SRC)
+
+
+clean:
+	$(RM) ./Day11 ./Day11.o ./Day11.hi
+
+setup: $(SRC)
+	docker cp $(SRC) $(CONTAINER_NAME):/home/haskell/Main.hs
+	docker cp input.txt $(CONTAINER_NAME):/home/haskell/input.txt
+	docker cp shortinput.txt $(CONTAINER_NAME):/home/haskell/shortinput.txt
+
+profiling: setup
+	docker exec -it $(CONTAINER_NAME) cabal build --enable-profiling
+	docker exec -it $(CONTAINER_NAME) ./profile shortinput.txt
+
+run: setup
+	docker exec -it $(CONTAINER_NAME) cabal build
+	docker exec -it $(CONTAINER_NAME) ./run input.txt
+
+.PHONY: all $(TARGET) clean setup profiling run

2024/Day11/input.txt

@@ -0,0 +1 @@
+8069 87014 98 809367 525 0 9494914 5

2024/Day11/shortinput.txt

@@ -0,0 +1 @@
+125 17

2024/README.md

@@ -131,3 +131,17 @@ Tried more optimizations such as saving the first valid free spot but this was o
 Today was so short that I didn't even take time to enjoy it...
 
 It was like asking 2+2...
+
+### Day 11:
+
+First part was interesting, managed to realize that `++` is the worst operator ever and that you should always use `concat` instead
+
+For the second part, I managed to optimize and go up to `38` quite far from the required `75`
+
+Tried to multithread it (in the `iterateStones` change `map` to `parMap rseq`) but it only slowed things down...
+(for target 35 had 4s in normal map and 12 using rseq...)
+
+- rseq : 12
+- r0 : 11.7
+- rdeepseq: 9.6
+- rpar : 12.7