commit 4920f68745f444e1e27cb2c9186d6ea48724d861 · drubery.com/aoc2025

+48 -7
src/Day10.hs
···

       64
       64
        
                else

     

       65
       65
        
                  (0 : go (n+1) (b:bs))

     

       66
       66
        
       

     

       67
       67
       -
       gaussJordan :: Map (Int,Int) (Ratio Int) -> Map Int (Ratio Int) -> (Map (Int,Int) (Ratio Int), Map Int (Ratio Int), Int)

     

       68
       68
       -
       gaussJordan m g = error "GJ"

     

       67
       67
       +
       type Matrix = (Int, Int, Map (Int,Int) (Ratio Int))

     

       68
       68
       +
       

     

       69
       69
       +
       cols :: Matrix -> Int

     

       70
       70
       +
       cols (_, c, _) = c - 1

     

       71
       71
       +
       

     

       72
       72
       +
       rows :: Matrix -> Int

     

       73
       73
       +
       rows (r, _, _) = r

     

       74
       74
       +
       

     

       75
       75
       +
       mat :: Matrix -> Map (Int,Int) (Ratio Int)

     

       76
       76
       +
       mat (_, _, m) = m

     

       77
       77
       +
       

     

       78
       78
       +
       minimum' :: Ord a => [a] -> Maybe a

     

       79
       79
       +
       minimum' [] = Nothing

     

       80
       80
       +
       minimum' as = Just $ minimum as

     

       81
       81
       +
       

     

       82
       82
       +
       pivotCell :: Matrix -> Int -> Int -> Maybe (Int, Int)

     

       83
       83
       +
       pivotCell m minRow minCol =

     

       84
       84
       +
         minimum' [(i,j) | i <- [minCol..cols m - 1],

     

       85
       85
       +
                           j <- [minRow..rows m - 1],

     

       86
       86
       +
                           (mat m) Map.! (i,j) /= 0]

     

       87
       87
       +
       

     

       88
       88
       +
       eraseColumn :: Int -> Int -> Matrix -> Matrix

     

       89
       89
       +
       eraseColumn i j m = error "TODO"

     

       90
       90
       +
       

     

       91
       91
       +
       swapCols :: Int -> Int -> Matrix -> Matrix

     

       92
       92
       +
       swapCols i i' m = error "TODO"

     

       93
       93
       +
         -- let (r,c,d) = m

     

       94
       94
       +
         --     d' = Map.fromList

     

       95
       95
       +
         --            ([((i,j), d Map.! (i',j)) | j <- [0..rows - 1]] ++

     

       96
       96
       +
         --             [((i',j), d Map.! (i,j)) | j <- [0..rows - 1]])

     

       97
       97
       +
         --  in (r,c,Map.union d' d)

     

       98
       98
       +
       

     

       99
       99
       +
       gaussJordan :: Map (Int,Int) (Ratio Int) -> Map (Int,Int) (Ratio Int)

     

       100
       100
       +
       gaussJordan mat = error "TODO" -- go mat 0 0

     

       101
       101
       +
        -- where go m minRow minCol =

     

       102
       102
       +
        --         case pivotCell m minRow minCol of

     

       103
       103
       +
        --           Nothing -> m

     

       104
       104
       +
        --           Just (i,j) ->

     

       105
       105
       +
        --             let m' = eraseColumn minCol minRow $

     

       106
       106
       +
        --                      normalizeRow minCol minRow $

     

       107
       107
       +
        --                      swapRows j minRow $

     

       108
       108
       +
        --                      swapCols i minCol m

     

       109
       109
       +
        --              in go m' (minRow + 1) (minCol + 1)

     

       69
       110
        
       

     

       70
       111
        
       solveMachine2 :: [Button] -> [Int] -> Maybe Int

     

       71
       71
       -
       solveMachine2 buttons goal =

     

       72
       72
       -
         let mat = Map.fromList [((i,j),1 % 1) | (i,b) <- zip [0..] buttons, j <- b]

     

       73
       73
       -
             g = Map.fromList $ zip [0..] (map (% 1) goal)

     

       74
       74
       -
             (mat', g', rank) = gaussJordan mat g

     

       75
       75
       -
          in Just 0

     

       112
       112
       +
       solveMachine2 buttons goal = error "TODO"

     

       113
       113
       +
         -- let mat = Map.fromList [((i,j),1 % 1) | (i,b) <- zip [0..] buttons, j <- b]

     

       114
       114
       +
         --     g = Map.fromList $ zip [0..] (map (% 1) goal)

     

       115
       115
       +
         --     (mat', g', rank) = gaussJordan mat g

     

       116
       116
       +
         --  in Just 0

     

       76
       117
        
       

     

       77
       118
        
       part2 :: String -> String

     

       78
       119
        
       part2 input =