commit fce814616623d597974ab1958a6ee0f6f875536c · drubery.com/aoc2025

+57 -2
src/Day4.hs
···

       1
       1
        
       module Day4 where

     

       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)

     

       17
       17
       +
       

     

       18
       18
       +
       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)]

     

       28
       28
       +
       

     

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

     

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

     

       31
       31
       +
       

     

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

     

       33
       33
       +
       isAccessible grid p '@' =

     

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

     

       35
       35
       +
       isAccessible _ _ _ = False

     

       36
       36
       +
       

     

       3
       37
        
       part1 :: String -> String

     

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

     

       38
       38
       +
       part1 input =

     

       39
       39
       +
         let grid = parse input

     

       40
       40
       +
          in show $

     

       41
       41
       +
             length $

     

       42
       42
       +
             Map.filterWithKey (isAccessible grid) grid

     

       43
       43
       +
       

     

       44
       44
       +
       removeAccessible :: Grid -> Grid

     

       45
       45
       +
       removeAccessible grid =

     

       46
       46
       +
         let accessible = Map.filterWithKey (isAccessible grid) grid

     

       47
       47
       +
          in Map.difference grid accessible

     

       48
       48
       +
       

     

       49
       49
       +
       removeAll :: Grid -> Grid

     

       50
       50
       +
       removeAll grid =

     

       51
       51
       +
         let grids = iterate removeAccessible grid

     

       52
       52
       +
             stabilized (x : y : gs) =

     

       53
       53
       +
               if Map.size x == Map.size y then

     

       54
       54
       +
                 x

     

       55
       55
       +
               else

     

       56
       56
       +
                 stabilized (y : gs)

     

       57
       57
       +
          in stabilized grids

     

       5
       58
        
       

     

       6
       59
        
       part2 :: String -> String

     

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

     

       60
       60
       +
       part2 input =

     

       61
       61
       +
         let grid = parse input

     

       62
       62
       +
          in show $ Map.size $ Map.difference grid (removeAll grid)