commit 43f72aff7ef17fb9fe59c1949df7e7e5dee6ebda · drubery.com/aoc2025

+22 -3

src/Day6.hs

···

       1
       1
        
       module Day6 where

     

       2
       2
        
       

     

       3
       3
       +
       import Data.List

     

       4
       4
       +
       import Debug.Trace

     

       5
       5
       +
       import Util

     

       6
       6
       +
       

     

       7
       7
       +
       solveProblem :: ([Int], String) -> Int

     

       8
       8
       +
       solveProblem (terms, "+") = sum terms

     

       9
       9
       +
       solveProblem (terms, "*") = product terms

     

       10
       10
       +
       

     

       3
       11
        
       part1 :: String -> String

     

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

     

       5
       5
       -
       

     

       12
       12
       +
       part1 input =

     

       13
       13
       +
         let l = lines input

     

       14
       14
       +
             terms = map (map read) $ transpose $ map words $ init l

     

       15
       15
       +
             ops = words $ last l

     

       16
       16
       +
          in

     

       17
       17
       +
             show $

     

       18
       18
       +
             sum $

     

       19
       19
       +
             map solveProblem (zip terms ops)

     

       20
       20
       +
             

     

       6
       21
        
       part2 :: String -> String

     

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

     

       22
       22
       +
       part2 input =

     

       23
       23
       +
         let l = lines input

     

       24
       24
       +
             terms :: [[Int]] = map (map read) $ splitOn null $ map trim $ transpose $ init l

     

       25
       25
       +
             ops = words $ last l

     

       26
       26
       +
         in show $ sum $ map solveProblem (zip terms ops)

+9 -4

src/Util.hs

···

       1
       1
        
       module Util where

     

       2
       2
        
       

     

       3
       3
       +
       import Data.Char (isSpace)

     

       3
       4
        
       import qualified Data.Map as Map

     

       4
       5
        
       import Data.Map (Map)

     

       5
       6
        
       

     

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

     

       7
       7
       +
       splitOn :: (a -> Bool) -> [a] -> [[a]]

     

       7
       8
        
       splitOn p s = case dropWhile p s of

     

       8
       8
       -
                     "" -> []

     

       9
       9
       +
                     [] -> []

     

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

     

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

     

       11
       12
        
       

     

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

     

       13
       13
       +
       split :: (Eq a) => a -> [a] -> [[a]]

     

       13
       14
        
       split c = splitOn (== c)

     

       14
       15
        
       

     

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

     
···

       27
       28
        
       

     

       28
       29
        
       neighbors4 :: Point2 -> [Point2]

     

       29
       30
        
       neighbors4 (x,y) =

     

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

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

     

       32
       32
       +
       

     

       33
       33
       +
       trim :: String -> String

     

       34
       34
       +
       trim = f . f

     

       35
       35
       +
         where f = reverse . dropWhile isSpace