commit 5ac29c9401bd8e85846e3abbbf0e4e84d9c970df · drubery.com/aoc2025

+1 -6

src/Day2.hs

···

       1
       1
        
       module Day2 where

     

       2
       2
        
       

     

       3
       3
        
       import Debug.Trace

     

       4
       4
       -
       

     

       5
       5
       -
       split :: Char -> String -> [String]

     

       6
       6
       -
       split c s = case dropWhile (== c) s of

     

       7
       7
       -
                     "" -> []

     

       8
       8
       -
                     s' -> w : split c s''

     

       9
       9
       -
                           where (w, s'') = break (== c) s'

     

       4
       4
       +
       import Util

     

       10
       5
        
       

     

       11
       6
        
       isPartOneCandidate :: Int -> Bool

     

       12
       7
        
       isPartOneCandidate n =

+3 -22

src/Day4.hs

···

       2
       2
        
       

     

       3
       3
        
       import qualified Data.Map as Map

     

       4
       4
        
       import Data.Map (Map)

     

       5
       5
       -
       

     

       6
       6
       -
       type Grid = Map (Int,Int) Char

     

       7
       7
       -
       

     

       8
       8
       -
       enumerate :: [a] -> [(Int,a)]

     

       9
       9
       -
       enumerate l = zip [0..] l

     

       10
       10
       -
       

     

       11
       11
       -
       addRow :: Int -> String -> Grid -> Grid

     

       12
       12
       -
       addRow y row grid =

     

       13
       13
       -
         foldl

     

       14
       14
       -
           (\g (x,c) -> Map.insert (x,y) c g)

     

       15
       15
       -
           grid

     

       16
       16
       -
           (enumerate row)

     

       5
       5
       +
       import Util

     

       17
       6
        
       

     

       18
       7
        
       parse :: String -> Grid

     

       19
       19
       -
       parse s =

     

       20
       20
       -
         foldl

     

       21
       21
       -
           (\g (x,row) -> addRow x row g)

     

       22
       22
       -
           Map.empty

     

       23
       23
       -
           (enumerate $ lines s)

     

       24
       24
       -
       

     

       25
       25
       -
       neighbors :: (Int,Int) -> [(Int,Int)]

     

       26
       26
       -
       neighbors (x,y) =

     

       27
       27
       -
         [(x-1,y-1),(x,y-1),(x+1,y-1),(x-1,y),(x+1,y),(x-1,y+1),(x,y+1),(x+1,y+1)]

     

       8
       8
       +
       parse = toGrid

     

       28
       9
        
       

     

       29
       10
        
       isOccupied :: Grid -> (Int,Int) -> Bool

     

       30
       11
        
       isOccupied grid p = Map.lookup p grid == Just '@'

     

       31
       12
        
       

     

       32
       13
        
       isAccessible :: Grid -> (Int,Int) -> Char -> Bool

     

       33
       14
        
       isAccessible grid p '@' =

     

       34
       34
       -
         length (filter (isOccupied grid) (neighbors p)) < 4

     

       15
       15
       +
         length (filter (isOccupied grid) (neighbors8 p)) < 4

     

       35
       16
        
       isAccessible _ _ _ = False

     

       36
       17
        
       

     

       37
       18
        
       part1 :: String -> String

+43 -2

src/Day5.hs

···

       1
       1
        
       module Day5 where

     

       2
       2
        
       

     

       3
       3
       +
       import Debug.Trace

     

       4
       4
       +
       import Data.Char

     

       5
       5
       +
       import Data.List

     

       6
       6
       +
       import Util

     

       7
       7
       +
       

     

       8
       8
       +
       type Range = (Int,Int)

     

       9
       9
       +
       

     

       10
       10
       +
       parse :: String -> ([Range], [Int])

     

       11
       11
       +
       parse s = foldl addLine ([], []) $ map (map read) $ map (splitOn (not . isDigit)) $ lines s

     

       12
       12
       +
         where addLine (ranges, queries) [lhs, rhs] = ((lhs, rhs) : ranges, queries)

     

       13
       13
       +
               addLine (ranges, queries) [q] = (ranges, q : queries)

     

       14
       14
       +
               addLine (ranges, queries) [] = (ranges, queries)

     

       15
       15
       +
       

     

       16
       16
       +
       inRange :: Range -> Int -> Bool

     

       17
       17
       +
       inRange (lo,hi) q = lo <= q && q <= hi

     

       18
       18
       +
       

     

       19
       19
       +
       inRanges :: [Range] -> Int -> Bool

     

       20
       20
       +
       inRanges rs q = any (\r -> inRange r q) rs

     

       21
       21
       +
       

     

       3
       22
        
       part1 :: String -> String

     

       4
       4
       -
       part1 _ = "Day 5 part 1"

     

       23
       23
       +
       part1 input =

     

       24
       24
       +
         let (rs,qs) = parse input

     

       25
       25
       +
          in show $

     

       26
       26
       +
             length $

     

       27
       27
       +
             filter (inRanges rs) qs

     

       28
       28
       +
       

     

       29
       29
       +
       rangeUnion :: [Range] -> [Range]

     

       30
       30
       +
       rangeUnion rs =

     

       31
       31
       +
         let mergeWith cur [] = [cur]

     

       32
       32
       +
             mergeWith (lo,hi) ((lo',hi') : rest) =

     

       33
       33
       +
               if lo' <= hi then

     

       34
       34
       +
                 mergeWith (lo, max hi hi') rest

     

       35
       35
       +
               else

     

       36
       36
       +
                 (lo, hi) : mergeWith (lo', hi') rest

     

       37
       37
       +
       

     

       38
       38
       +
             merge [] = []

     

       39
       39
       +
             merge (r : rest) = mergeWith r rest

     

       40
       40
       +
          in merge $ sort rs

     

       5
       41
        
       

     

       6
       42
        
       part2 :: String -> String

     

       7
       7
       -
       part2 _ = "Day 5 part 2"

     

       43
       43
       +
       part2 input =

     

       44
       44
       +
         let (rs, _) = parse input

     

       45
       45
       +
          in show $

     

       46
       46
       +
             sum $

     

       47
       47
       +
             map (\(a,b) -> b-a+1) $

     

       48
       48
       +
             rangeUnion rs

+30

src/Util.hs

···

       1
       1
       +
       module Util where

     

       2
       2
       +
       

     

       3
       3
       +
       import qualified Data.Map as Map

     

       4
       4
       +
       import Data.Map (Map)

     

       5
       5
       +
       

     

       6
       6
       +
       splitOn :: (Char -> Bool) -> String -> [String]

     

       7
       7
       +
       splitOn p s = case dropWhile p s of

     

       8
       8
       +
                     "" -> []

     

       9
       9
       +
                     s' -> w : splitOn p s''

     

       10
       10
       +
                           where (w, s'') = break p s'

     

       11
       11
       +
       

     

       12
       12
       +
       split :: Char -> String -> [String]

     

       13
       13
       +
       split c = splitOn (== c)

     

       14
       14
       +
       

     

       15
       15
       +
       enumerate :: [a] -> [(Int,a)]

     

       16
       16
       +
       enumerate l = zip [0..] l

     

       17
       17
       +
       

     

       18
       18
       +
       type Point2 = (Int,Int)

     

       19
       19
       +
       type Grid = Map Point2 Char

     

       20
       20
       +
       

     

       21
       21
       +
       toGrid :: String -> Grid

     

       22
       22
       +
       toGrid s = Map.fromList [((x,y),c) | (y,r) <- enumerate (lines s), (x,c) <- enumerate r]

     

       23
       23
       +
       

     

       24
       24
       +
       neighbors8 :: Point2 -> [Point2]

     

       25
       25
       +
       neighbors8 (x,y) =

     

       26
       26
       +
         [(x-1,y-1),(x,y-1),(x+1,y-1),(x-1,y),(x+1,y),(x-1,y+1),(x,y+1),(x+1,y+1)]

     

       27
       27
       +
       

     

       28
       28
       +
       neighbors4 :: Point2 -> [Point2]

     

       29
       29
       +
       neighbors4 (x,y) =

     

       30
       30
       +
         [(x-1,y), (x+1,y), (x,y-1), (x,y+1)]