diff --git a/11/input.txt b/11/input.txt deleted file mode 100644 index cfbdc33..0000000 --- a/11/input.txt +++ /dev/null @@ -1,10 +0,0 @@ -5421451741 -3877321568 -7583273864 -3451717778 -2651615156 -6377167526 -5182852831 -4766856676 -3437187583 -3633371586 diff --git a/11/octoflash.hs b/11/octoflash.hs deleted file mode 100644 index eb16571..0000000 --- a/11/octoflash.hs +++ /dev/null @@ -1,93 +0,0 @@ -import Data.Char (digitToInt) - -main :: IO () -main = do - input <- getContents - let - octopodes = (map (map digitToInt) . lines) input - (putStrLn . show . solution1) octopodes - (putStrLn . show . solution2) octopodes - -solution1 :: [[Int]] -> Int -solution1 m = snd (iterate flashSimulate (m, 0) !! 100) - -solution2 :: [[Int]] -> Int -solution2 m = countUntil (all (all (==0)) . fst) flashSimulate (m, 0) - -flashSimulate :: ([[Int]], Int) -> ([[Int]], Int) -flashSimulate (octopodes, flashes) = - (refreshOctopodes exhaustedOctopodes, flashes + countExhaustedOctopodes exhaustedOctopodes) - where - exhaustedOctopodes = flashStep octopodes - countExhaustedOctopodes = foldr (\l a -> length l + a) 0 . map (filter (> 9)) - refreshOctopodes = map (map (\o -> if o > 9 then 0 else o)) - -flashStep :: [[Int]] -> [[Int]] -flashStep = propagateFlashes . map (map (+1)) - where - propagateFlashes :: [[Int]] -> [[Int]] - propagateFlashes = until allExhausted flashOctopi - where - allExhausted :: [[Int]] -> Bool - allExhausted = all (all (/= 10)) - flashOctopi :: [[Int]] -> [[Int]] - flashOctopi m = map (map (incrementFlashing m)) - [[(x, y) | y <- [0..length (m !! x) - 1]] | x <- [0..length m - 1]] - where - incrementFlashing ::[[Int]] -> (Int, Int) -> Int - incrementFlashing m' o - | charge < 10 && newCharge > 10 = 10 -- Ensure we don't miss an increment - | otherwise = charge + numFlashingNeighbors o - where - newCharge = charge + numFlashingNeighbors o - charge = m' !!! o - numFlashingNeighbors :: (Int, Int) -> Int - numFlashingNeighbors = length . filter (\o -> (m !!! o) == 10) . (flip adjacent m) - -(!!!) :: [[Int]] -> (Int, Int) -> Int -(!!!) m index = m !! (fst index) !! (snd index) - -countUntil :: (a -> Bool) -> (a -> a) -> a -> Int -countUntil p f = call - where - call x - | p x = 0 - | otherwise = call (f x) + 1 - -adjacent :: (Int, Int) -> [[Int]] -> [(Int, Int)] -adjacent (x, y) m = [(x+i, y+j) | - i <- [-1..1], - j <- [-1..1], - -- (i, j) /= (0, 0), - x+i >= 0, - y+j >= 0, - x+i < length m, - y+j < length (m !! 0)] - --- Tests - -testInput1 = [ - "5483143223", - "2745854711", - "5264556173", - "6141336146", - "6357385478", - "4167524645", - "2176841721", - "6882881134", - "4846848554", - "5283751526" - ] -parsedTestInput1 = map (map digitToInt) testInput1 - -testInput2 = [ - "11111", - "19991", - "19191", - "19991", - "11111" - ] -parsedTestInput2 = map (map digitToInt) testInput2 - -test1 = solution1 parsedTestInput1 -test2 = solution2 parsedTestInput1 diff --git a/12/Parsing.hs b/12/Parsing.hs deleted file mode 100644 index 8ad0f3f..0000000 --- a/12/Parsing.hs +++ /dev/null @@ -1,23 +0,0 @@ -module Parsing ( - splitByString - ) where - -import Data.List (isPrefixOf) - -splitByString :: String -> String -> [String] -splitByString _ "" = [] -splitByString splitter string = - let (chunk, rest) = spanNextSplit string - in - chunk:(splitByString splitter rest) - where - spanNextSplit :: String -> (String, String) - spanNextSplit [] = ([], []) - spanNextSplit everything@(char:rest) - | splitter `isPrefixOf` rest = - ([char], (drop ((length splitter) + 1) everything)) - | otherwise = - let - (start, end) = spanNextSplit rest - in - (char:start, end) diff --git a/12/cavesearcher.hs b/12/cavesearcher.hs deleted file mode 100644 index ed63250..0000000 --- a/12/cavesearcher.hs +++ /dev/null @@ -1,123 +0,0 @@ -import Data.Char (isLower) -import qualified Data.Map.Strict as Map -import qualified Data.Set as Set -import Debug.Trace (traceShow, traceShowId) -import Parsing (splitByString) - -main :: IO () -main = do - input <- getContents - let - caves = parseCaves input - (putStrLn . show . solution1) caves - (putStrLn . show . solution2) caves - -solution1 :: Map.Map String [String] -> Int -solution1 = length . cavePaths - -solution2 :: Map.Map String [String] -> Int -solution2 = length . cavePaths2 - -parseCaves :: String -> Map.Map String [String] -parseCaves = Map.fromListWith (++) . flatmap addReverse . map tupleFromList . map (splitByString "-") . lines - where - addReverse :: (String, [String]) -> [(String, [String])] - addReverse t@(a, b) = [t, (head b, [a])] - tupleFromList :: [String] -> (String, [String]) - tupleFromList [] = undefined - tupleFromList (x:xs) - -- Since the second part is always expected to be a cave label - -- or "end", this should never be > 1 - | length xs > 1 = undefined - | otherwise = (x, xs) - -cavePaths :: Map.Map String [String] -> [[String]] -cavePaths caveMap = followSingle caveMap Set.empty "start" - -cavePaths2 :: Map.Map String [String] -> [[String]] -cavePaths2 caveMap = followOneRepeat caveMap Set.empty "start" - -followSingle :: Map.Map String [String] -> Set.Set String -> String -> [[String]] -followSingle caveMap visited node - | node == "end" = [[node]] - | otherwise = - let - v' = Set.insert node visited - in - map ((:) node) (flatmap (followSingle caveMap v') adjacent) - where - adjacent :: [String] - adjacent = filter (not . visitedSmall) (Map.findWithDefault [] node caveMap) - visitedSmall :: String -> Bool - visitedSmall n = all isLower n && n `elem` visited - -followOneRepeat :: Map.Map String [String] -> Set.Set String -> String -> [[String]] -followOneRepeat caveMap visited node - | node == "end" = [[node]] - | all isLower node && node `elem` visited = - followSingle caveMap visited node - | otherwise = - let - v' = Set.insert node visited - in - map ((:) node) (flatmap (followOneRepeat caveMap v') adjacent) - where - adjacent :: [String] - adjacent = filter (/= "start") (Map.findWithDefault [] node caveMap) - -flatmap :: (t -> [a]) -> [t] -> [a] -flatmap _ [] = [] -flatmap f (x:xs) = f x ++ flatmap f xs - --- Tests - -testInput1 = unlines [ - "start-A", - "start-b", - "A-c", - "A-b", - "b-d", - "A-end", - "b-end" - ] - -testInput2 = unlines [ - "dc-end", - "HN-start", - "start-kj", - "dc-start", - "dc-HN", - "LN-dc", - "HN-end", - "kj-sa", - "kj-HN", - "kj-dc"] - -testInput3 = unlines [ - "fs-end", - "he-DX", - "fs-he", - "start-DX", - "pj-DX", - "end-zg", - "zg-sl", - "zg-pj", - "pj-he", - "RW-he", - "fs-DX", - "pj-RW", - "zg-RW", - "start-pj", - "he-WI", - "zg-he", - "pj-fs", - "start-RW"] - -parsedTestInput1 = parseCaves testInput1 -test1 = cavePaths parsedTestInput1 -test2 = cavePaths2 parsedTestInput1 -test3 = cavePaths2 (parseCaves testInput2) -test4 = cavePaths2 (parseCaves testInput3) - -printPaths :: [[String]] -> IO () -printPaths = putStr . unlines . (map (foldr1 (\c a -> c++"->"++a))) diff --git a/12/input.txt b/12/input.txt deleted file mode 100644 index 4067b56..0000000 --- a/12/input.txt +++ /dev/null @@ -1,24 +0,0 @@ -yb-pi -jg-ej -yb-KN -LD-start -end-UF -UF-yb -yb-xd -qx-yb -xd-end -jg-KN -start-qx -start-ej -qx-LD -jg-LD -xd-LD -ej-qx -end-KN -DM-xd -jg-yb -ej-LD -qx-UF -UF-jg -qx-jg -xd-UF