Use hlint and hformat.

Author: kdungs

2019/01.hs

@@ -1,11 +1,15 @@
-import Text.ParserCombinators.Parsec
+import           Text.ParserCombinators.Parsec
 
 fuelRequired :: Int -> Int
 fuelRequired mass = mass `div` 3 - 2
 
 fuelRequired_ :: Int -> Int
-fuelRequired_ mass = if f > 0 then f + fuelRequired_ f else 0
-  where f = fuelRequired mass
+fuelRequired_ mass =
+  if f > 0
+    then f + fuelRequired_ f
+    else 0
+  where
+    f = fuelRequired mass
 
 int :: Parser Int
 int = read <$> many1 digit
@@ -14,5 +18,5 @@ main :: IO ()
 main = do
   contents <- getContents
   let ms = parse (sepEndBy int newline) "" contents
-  putStrLn . show $ sum . map fuelRequired <$> ms
-  putStrLn . show $ sum . map fuelRequired_ <$> ms
+  print $ sum . map fuelRequired <$> ms
+  print $ sum . map fuelRequired_ <$> ms

2019/02.hs

@@ -1,22 +1,28 @@
-import qualified Data.Map.Strict as M
-import Text.ParserCombinators.Parsec
+import qualified Data.Map.Strict               as M
+import           Text.ParserCombinators.Parsec
 
-
-data Instruction = Done | Add | Mul deriving Show
+data Instruction
+  = Done
+  | Add
+  | Mul
+  deriving (Show)
 
 applyInstruction :: Instruction -> Int -> Int -> Maybe Int
 applyInstruction Add x y = Just (x + y)
 applyInstruction Mul x y = Just (x * y)
-applyInstruction _ _ _ = Nothing
+applyInstruction _ _ _   = Nothing
 
 type Position = Int
-data Memory = Memory (M.Map Position Int) deriving Show
+
+newtype Memory =
+  Memory (M.Map Position Int)
+  deriving (Show)
 
 instructionFromNumber :: Int -> Maybe Instruction
-instructionFromNumber 1 = Just Add
-instructionFromNumber 2 = Just Mul
+instructionFromNumber 1  = Just Add
+instructionFromNumber 2  = Just Mul
 instructionFromNumber 99 = Just Done
-instructionFromNumber _ = Nothing
+instructionFromNumber _  = Nothing
 
 instructionAt :: Position -> Memory -> Maybe Instruction
 instructionAt pos (Memory mem) = do
@@ -35,31 +41,35 @@ setMemory :: Position -> Int -> Memory -> Memory
 setMemory pos val (Memory mem) = Memory (M.insert pos val mem)
 
 execute :: Position -> Memory -> Maybe Memory
-execute pos mem = case (instructionAt pos mem) of
-                    Nothing -> Nothing
-                    Just Done -> Just mem
-                    Just op -> do
-                      lhs <- dereferenceAt (pos + 1) mem
-                      rhs <- dereferenceAt (pos + 2) mem
-                      dst <- valueAt (pos + 3) mem
-                      val <- applyInstruction op lhs rhs
-                      execute (pos + 4) (setMemory dst val mem)
+execute pos mem =
+  case instructionAt pos mem of
+    Nothing -> Nothing
+    Just Done -> Just mem
+    Just op -> do
+      lhs <- dereferenceAt (pos + 1) mem
+      rhs <- dereferenceAt (pos + 2) mem
+      dst <- valueAt (pos + 3) mem
+      val <- applyInstruction op lhs rhs
+      execute (pos + 4) (setMemory dst val mem)
 
 modify :: Int -> Int -> Memory -> Memory
 modify noun verb (Memory mem) = Memory (M.insert 1 noun (M.insert 2 verb mem))
 
-checkSolution :: Int -> Int ->  Int -> Memory -> Maybe Bool
+checkSolution :: Int -> Int -> Int -> Memory -> Maybe Bool
 checkSolution target noun verb memory = do
   res <- execute 0 (modify noun verb memory)
   val <- valueAt 0 res
-  return (if (target == val) then True else False)
+  pure (target == val)
 
 findSolution :: Int -> Memory -> (Int, Int)
-findSolution target mem = head (dropWhile isNotSolution [(n, v) | n <- [0..100], v <- [0..100]])
-  where isNotSolution :: (Int, Int) -> Bool
-        isNotSolution (noun, verb) = case (checkSolution target noun verb mem) of
-                                       Nothing -> True  -- meh!
-                                       (Just b) -> not b
+findSolution target mem =
+  head (dropWhile isNotSolution [(n, v) | n <- [0 .. 100], v <- [0 .. 100]])
+  where
+    isNotSolution :: (Int, Int) -> Bool
+    isNotSolution (noun, verb) =
+      case checkSolution target noun verb mem of
+        Nothing  -> True -- meh!
+        (Just b) -> not b
 
 -- Parser
 int :: Parser Int
@@ -68,16 +78,13 @@ int = read <$> many1 digit
 memory :: Parser Memory
 memory = do
   code <- sepBy int (char ',')
-  return (Memory (M.fromList (zip [0..] code)))
+  pure (Memory (M.fromList (zip [0 ..] code)))
 
 -- Main
 main :: IO ()
 main = do
   contents <- getContents
   let mem = parse memory "" contents
-  let res = (execute 0) . (modify 12 2) <$> mem
-  putStrLn $ case res of
-               (Left err) -> show err
-               (Right (Just m)) -> show $ valueAt 0 m
-               _ -> "Nothing"
-  putStrLn . show $ findSolution 19690720 <$> mem
+  let res = execute 0 . modify 12 2 <$> mem
+  print $ (\mem -> valueAt 0 <$> mem) <$> res
+  print $ findSolution 19690720 <$> mem

2019/03.hs

@@ -1,65 +1,79 @@
-import qualified Data.List as List
-import qualified Data.Map.Strict as Map
-import qualified Data.Set as Set
-import Text.ParserCombinators.Parsec
-
-data Point = Point { x :: Int,
-                     y :: Int } deriving (Eq, Ord, Show)
-
-data Direction = UP | RIGHT | DOWN | LEFT deriving (Eq, Ord, Show)
-
-data Instruction = Instruction Direction Int deriving Show
-
-data Step = Step { idx :: Int,
-                   ins :: Instruction } deriving Show
+import           Data.Functor                  (($>))
+import qualified Data.List                     as List
+import qualified Data.Map.Strict               as Map
+import qualified Data.Set                      as Set
+import           Text.ParserCombinators.Parsec
+
+data Point =
+  Point
+    { x :: Int
+    , y :: Int
+    }
+  deriving (Eq, Ord, Show)
+
+data Direction
+  = UP
+  | RIGHT
+  | DOWN
+  | LEFT
+  deriving (Eq, Ord, Show)
+
+data Instruction =
+  Instruction Direction Int
+  deriving (Show)
+
+data Step =
+  Step
+    { idx :: Int
+    , ins :: Instruction
+    }
+  deriving (Show)
 
 movePoint :: Point -> Direction -> Point
-movePoint p UP = p { y = y p + 1}
-movePoint p RIGHT = p { x = x p + 1}
-movePoint p DOWN = p { y = y p - 1}
-movePoint p LEFT = p { x = x p - 1}
+movePoint p UP    = p {y = y p + 1}
+movePoint p RIGHT = p {x = x p + 1}
+movePoint p DOWN  = p {y = y p - 1}
+movePoint p LEFT  = p {x = x p - 1}
 
 unrollInstruction :: Instruction -> [Direction]
 unrollInstruction (Instruction dir cnt) = replicate cnt dir
 
 unrollInstructions :: [Instruction] -> [Direction]
-unrollInstructions = concat . List.map unrollInstruction
+unrollInstructions = List.concatMap unrollInstruction
 
 wirePoints :: [Instruction] -> [Point]
 wirePoints ins = scanl movePoint (Point 0 0) (unrollInstructions ins)
 
 stepMap :: [Point] -> Map.Map Point Int
-stepMap ps = Map.fromListWith min (zip ps [1..])
+stepMap ps = Map.fromListWith min (zip ps [1 ..])
 
 intersectStepMaps :: Map.Map Point Int -> Map.Map Point Int -> Map.Map Point Int
-intersectStepMaps m1 m2 = Map.intersectionWith (\a b -> a + b) m1 m2
+intersectStepMaps = Map.intersectionWith (+)
 
 manhattenDist :: Point -> Int
-manhattenDist (Point x y) = (abs x) + (abs y)
+manhattenDist (Point x y) = abs x + abs y
 
 prepareMap :: [Instruction] -> [Instruction] -> Map.Map Point Int
 prepareMap ins1 ins2 = intersectStepMaps m1 m2
-  where m1 = convert ins1
-        m2 = convert ins2
-        convert = stepMap . tail . wirePoints
+  where
+    m1 = convert ins1
+    m2 = convert ins2
+    convert = stepMap . tail . wirePoints
 
 -- Parser
 int :: Parser Int
 int = read <$> many1 digit
 
 instruction :: Parser Instruction
 instruction = do
-  direction <- char 'U' *> pure UP
-           <|> char 'R' *> pure RIGHT
-           <|> char 'D' *> pure DOWN
-           <|> char 'L' *> pure LEFT
-  count <- int
-  pure (Instruction direction count)
+  direction <-
+    choice
+      [char 'U' $> UP, char 'R' $> RIGHT, char 'D' $> DOWN, char 'L' $> LEFT]
+  Instruction direction <$> int
 
 instructions :: Parser [Instruction]
 instructions = sepBy instruction (char ',')
 
-
 -- Solvers
 part1 :: Map.Map Point Int -> Int
 part1 m = List.minimum (List.map manhattenDist (Map.keys m))
@@ -75,5 +89,5 @@ main = do
   let ins1 = head <$> wireInstructions
   let ins2 = head . tail <$> wireInstructions
   let smap = prepareMap <$> ins1 <*> ins2
-  putStrLn . show $ part1 <$> smap
-  putStrLn . show $ part2 <$> smap
+  print $ part1 <$> smap
+  print $ part2 <$> smap

2019/04.hs

@@ -1,10 +1,11 @@
-import Text.ParserCombinators.Parsec
-import qualified Data.List as List
+import qualified Data.List                     as List
+import           Text.ParserCombinators.Parsec
 
 digits :: Int -> [Int]
 digits i = List.reverse (rdigits i)
-  where rdigits 0 = []
-        rdigits x = (x `mod` 10):(rdigits (x `div` 10))
+  where
+    rdigits 0 = []
+    rdigits x = x `mod` 10 : rdigits (x `div` 10)
 
 -- Part 1
 groupLengths :: [Int] -> [Int]
@@ -14,24 +15,25 @@ hasMatchingAdjacentDigits :: [Int] -> Bool
 hasMatchingAdjacentDigits ds = List.any (>= 2) (groupLengths ds)
 
 isMonotonous :: [Int] -> Bool
-isMonotonous (x:y:rest) = (x <= y) && (isMonotonous (y:rest))
-isMonotonous _ = True
+isMonotonous (x:y:rest) = x <= y && isMonotonous (y : rest)
+isMonotonous _          = True
 
 isCandidate :: Int -> Bool
-isCandidate i = (List.length ds == 6)
-             && (hasMatchingAdjacentDigits ds)
-             && (isMonotonous ds)
-  where ds = digits i
+isCandidate i =
+  List.length ds == 6 && hasMatchingAdjacentDigits ds && isMonotonous ds
+  where
+    ds = digits i
 
 countInRange :: (Int -> Bool) -> (Int, Int) -> Int
-countInRange pred (left, right) = List.sum (List.map (fromEnum . pred) [left..right])
+countInRange pred (left, right) =
+  List.sum (List.map (fromEnum . pred) [left .. right])
 
 -- Part 2
 hasTwoMatchingAdjacentDigits :: [Int] -> Bool
-hasTwoMatchingAdjacentDigits ds = List.any (== 2) (groupLengths ds)
+hasTwoMatchingAdjacentDigits ds = 2 `List.elem` groupLengths ds
 
 isCandidate2 :: Int -> Bool
-isCandidate2 i = (isCandidate i) && (hasTwoMatchingAdjacentDigits (digits i))
+isCandidate2 i = isCandidate i && hasTwoMatchingAdjacentDigits (digits i)
 
 -- Parser
 int :: Parser Int
@@ -48,5 +50,5 @@ main :: IO ()
 main = do
   contents <- getContents
   let r = parse range "" contents
-  putStrLn . show $ (countInRange isCandidate) <$> r
-  putStrLn . show $ (countInRange isCandidate2) <$> r
+  print $ countInRange isCandidate <$> r
+  print $ countInRange isCandidate2 <$> r