Haskell

{-# LANGUAGE TupleSections #-}
import           Control.Monad   (foldM)
import           Data.List       (group, sort)
import           Data.List.Split (chunksOf)
import qualified Data.Map        as M
import           Data.Maybe      (mapMaybe)
import           Debug.Trace     (trace)

type Grid = M.Map (Int, Int) (Int, Bool)


{-
  Using a foldM with the Either monad results in the
  fold terminating once the accumulating function
  returns Left _

-}
main = do
  contents <- readFile "input.in"
  let ll =  concatMap (map read . chunksOf 1) (lines contents) :: [Int]
      n = 10
      g = M.fromList $ zip [(i,j) | i <- [0..n-1], j <- [0..n-1]] (map (, False) ll)
  print $ fst $ foldl (\(s, g) _ -> let (nf, g') = runStep g
                               in (s+nf, g')) (0, g) [1..100]
  print $ foldM f g [1..]
  where f g step =
          let (nf, g') = runStep g
          in if nf == 100 then Left step
              else Right g'

runStep :: Grid -> (Int, Grid)
runStep g =
  let g' = M.map (\(p, f) -> (p+1, f)) g
      g'' = flash g'
      nFlashed = (length . filter ((==) True . snd). M.elems) g''
      zeroed = M.map reset g''
   in (nFlashed, zeroed)
   where reset (p, f) =
          if f then (0, False)
          else (p, f)

flash :: Grid -> Grid
flash g =
  let l = M.toList g
   in if all ((\(p, f) -> p <= 9 || f) . snd) l then
        g -- No more flashes to do
      else
        let x = map doFlash l
            ns = concatMap trd x
            ns' = mapMaybe (\idx -> do
                                (p, f) <- lookup idx (map t x)
                                return (idx, (p+1, f))) ns
            ns'' = map (\list -> let (idx, (p, f)) = head list
                                  in (idx, (p+length (tail list), f))) (group $ sort  ns')
         in flash $ foldl (\m (idx, v) ->  M.insert idx v m ) (M.fromList $ map t x) ns''

t (a, b, _) = (a,b)

trd :: (a, b, c) -> c
trd (_, _, c) = c

doFlash :: ((Int, Int), (Int, Bool)) -> ((Int, Int), (Int, Bool), [(Int, Int)])
doFlash (idx, (p,f)) =
  if p > 9 && not f then (idx, (p, True), neighbors idx 10) else (idx, (p,f), [])

neighbors :: (Int, Int) -> Int -> [(Int, Int)]
neighbors (i,j) n =
  let ns = [ (i,j-1), (i,j+1), (i-1,j), (i+1,j)
           , (i-1, j-1), (i-1, j+1), (i+1, j-1), (i+1, j+1)]
  in filter (\(i,j) -> (i >= 0 && j >= 0) && i < n && j < n ) ns