day 4: rewrite

use Data.Text

Signed-off-by: Amneesh Singh <natto@weirdnatto.in>

Lib.hs

@@ -0,0 +1,8 @@
+module Lib (readFile') where
+
+import qualified Data.ByteString as B (readFile)
+import Data.Text (Text)
+import qualified Data.Text.Encoding as T (decodeUtf8)
+
+readFile' :: FilePath -> IO Text
+readFile' f = T.decodeUtf8 <$> B.readFile f

day1.hs

@@ -1,22 +1,21 @@
+import Data.Either (isLeft, rights)
 import Data.List (sortOn)
 import Data.Ord (Down (Down))
+import Data.Text (Text)
+import qualified Data.Text as T (lines)
+import qualified Data.Text.Read as T (decimal)
+import Lib (readFile')
 
 main :: IO ()
 main = do
-  input <- lines <$> readFile "day1.in"
+  input <- map T.decimal . T.lines <$> readFile' "day1.in"
   putStr "Q1: "
-  print $ q1 input
+  print . maximum $ calories input
   putStr "Q2: "
-  print $ q2 input
+  print . sum . take 3 . sortOn Down $ calories input
 
-q1 :: [String] -> Int
+calories :: [Either String (Int, Text)] -> [Int]
-q1 = maximum . calories
-
-q2 :: [String] -> Int
-q2 = sum . take 3 . sortOn Down . calories
-
-calories :: [String] -> [Int]
 calories [] = []
 calories input =
-  let (cur, rest) = break null input
+  let (cur, rest) = break isLeft input
-   in sum (map read cur) : calories (drop 1 rest)
+   in sum (map fst $ rights cur) : calories (drop 1 rest)

day2.hs

@@ -1,8 +1,12 @@
+import Data.Text (Text)
+import qualified Data.Text as T (lines, unpack)
+import Lib (readFile')
+
 -- we do not use a simple 9 value case cuz yeah
 
 main :: IO ()
 main = do
-  choices <- parse <$> readFile "day2.in"
+  choices <- parse <$> readFile' "day2.in"
   putStr "Q1: "
   print $ q1 choices
   putStr "Q2: "
@@ -17,8 +21,8 @@ instance Ord Choice where
   compare Scissors Rock = LT
   compare _ _ = GT
 
-parse :: String -> [(Choice, Choice)]
+parse :: Text -> [(Choice, Choice)]
-parse = map (\[x, _, y] -> (val x 'A', val y 'X')) . lines
+parse = map ((\[x, _, y] -> (val x 'A', val y 'X')) . T.unpack) . T.lines
 
 score :: (Choice, Choice) -> Int
 score (i, j) = 1 + fromEnum j + 3 * fromEnum (compare j i)

day3.hs

@@ -1,24 +1,28 @@
 import Data.Char (isAsciiLower, isAsciiUpper)
 import Data.List (intersect)
+import Data.Text (Text)
+import qualified Data.Text as T (foldl, lines, splitAt)
+import Lib (readFile')
 
 main :: IO ()
 main = do
-  input <- lines <$> readFile "day3.in"
+  input <- map parse . T.lines <$> readFile' "day3.in"
   putStr "Q1: "
   print $ q1 input
   putStr "Q2: "
   print $ q2 input
 
-q1 :: [String] -> Int
+q1 :: [[Int]] -> Int
-q1 =
+q1 = sum . map (\x -> head . uncurry intersect $ splitAt (div (length x) 2) x)
-  sum
-    . map (\x -> val . head . uncurry intersect $ splitAt (div (length x) 2) x)
 
-q2 :: [String] -> Int
+q2 :: [[Int]] -> Int
 q2 [] = 0
 q2 input =
   let (cur, rest) = splitAt 3 input
-   in (val . head . foldr1 intersect) cur + q2 rest
+   in (head . foldr1 intersect) cur + q2 rest
+
+parse :: Text -> [Int]
+parse = T.foldl (\xs x -> val x : xs) []
 
 val :: Char -> Int
 val c

day4.hs

@@ -1,33 +1,28 @@
+{-# LANGUAGE OverloadedStrings #-}
+
 import Data.Char (isDigit)
-import Text.ParserCombinators.ReadP
+import Data.Either (rights)
-  ( ReadP,
+import Data.Maybe (fromJust)
-    char,
+import Data.Text (Text)
-    many1,
+import qualified Data.Text as T (lines, stripPrefix)
-    readP_to_S,
+import qualified Data.Text.Read as T (decimal)
-    satisfy,
+import Lib (readFile')
-  )
 
 main :: IO ()
 main = do
-  input <- map (fst . last . readP_to_S parse) . lines <$> readFile "day4.in"
+  input <- rights . map parse . T.lines <$> readFile' "day4.in"
   putStr "Q1: "
   print $ q1 input
   putStr "Q2: "
   print $ q2 input
 
-parse :: ReadP ((Int, Int), (Int, Int))
+parse :: Text -> Either String ((Int, Int), (Int, Int))
-parse = do
+parse rest = do
-  a <- readInt
+  (a, rest) <- T.decimal rest
-  char '-'
+  (b, rest) <- T.decimal $ fromJust $ T.stripPrefix "-" rest
-  b <- readInt
+  (c, rest) <- T.decimal $ fromJust $ T.stripPrefix "," rest
-  char ','
+  (d, rest) <- T.decimal $ fromJust $ T.stripPrefix "-" rest
-  c <- readInt
-  char '-'
-  d <- readInt
   return ((a, b), (c, d))
-  where
-    readInt :: ReadP Int
-    readInt = read <$> many1 (satisfy isDigit)
 
 q1, q2 :: [((Int, Int), (Int, Int))] -> Int
 q1 = length . filter (\((a, b), (c, d)) -> a >= c && b <= d || c >= a && d <= b)