From 83849a30ae502f32d5e5ef9a7f23da434fb50be7 Mon Sep 17 00:00:00 2001 From: Julien Dessaux Date: Sun, 12 Mar 2023 23:17:24 +0100 Subject: 2020-05 in haskell --- 2020/05-Binary_Boarding/example | 3 + 2020/05-Binary_Boarding/first.hs | 55 +++ 2020/05-Binary_Boarding/input | 826 ++++++++++++++++++++++++++++++++++++++ 2020/05-Binary_Boarding/second.hs | 48 +++ 4 files changed, 932 insertions(+) create mode 100644 2020/05-Binary_Boarding/example create mode 100644 2020/05-Binary_Boarding/first.hs create mode 100644 2020/05-Binary_Boarding/input create mode 100644 2020/05-Binary_Boarding/second.hs (limited to '2020/05-Binary_Boarding') diff --git a/2020/05-Binary_Boarding/example b/2020/05-Binary_Boarding/example new file mode 100644 index 0000000..b036d3e --- /dev/null +++ b/2020/05-Binary_Boarding/example @@ -0,0 +1,3 @@ +BFFFBBFRRR +FFFBBBFRRR +BBFFBBFRLL diff --git a/2020/05-Binary_Boarding/first.hs b/2020/05-Binary_Boarding/first.hs new file mode 100644 index 0000000..2f3ad7b --- /dev/null +++ b/2020/05-Binary_Boarding/first.hs @@ -0,0 +1,55 @@ +-- requires cabal install --lib megaparsec parser-combinators +module Main (main) where + +import Control.Monad (void, when) +import Data.List (foldl') +import Data.Void (Void) +import Text.Megaparsec +import Text.Megaparsec.Char +import System.Exit (die) + +exampleExpectedOutput = 820 + +data BoardingPass = BoardingPass { row :: Int + , column :: Int + } deriving (Show) + +type Parser = Parsec Void String + +parseColumn :: Parser Int +parseColumn = do + colStr <- some (char 'L' <|> char 'R') + return $ foldl' (\acc c -> acc * 2 + if c == 'R' then 1 else 0) 0 colStr + +parseRow :: Parser Int +parseRow = do + rowStr <- some (char 'B' <|> char 'F') + return $ foldl' (\acc c -> acc * 2 + if c == 'B' then 1 else 0) 0 rowStr + +parseBP :: Parser BoardingPass +parseBP = do + row <- parseRow + column <- parseColumn + void (char '\n') + return $ BoardingPass { row=row, column=column } + +parseBPs :: Parser [BoardingPass] +parseBPs = some (parseBP) <* eof + +parseInput :: String -> IO [BoardingPass] +parseInput filename = do + input <- readFile filename + case runParser parseBPs filename input of + Left bundle -> die $ errorBundlePretty bundle + Right bps -> return bps + +compute :: [BoardingPass]-> Int +compute = foldl' (\max BoardingPass{row=r, column=c} -> let n = r * 8 + c in if max >= n then max else n) 0 + +main :: IO () +main = do + example <- parseInput "example" + let exampleOutput = compute example + when (exampleOutput /= exampleExpectedOutput) (die $ "example failed: got " ++ show exampleOutput ++ " instead of " ++ show exampleExpectedOutput) + input <- parseInput "input" + print $ compute input diff --git a/2020/05-Binary_Boarding/input b/2020/05-Binary_Boarding/input new file mode 100644 index 0000000..3c51b57 --- /dev/null +++ b/2020/05-Binary_Boarding/input @@ -0,0 +1,826 @@ +FFBBFFBRRR +FBFBBBBLRR +BFBBBBBLRR +FBBFFFBLLR +FFBBFBBLLR +FBFFFBBLRL +FBFFFFBRRL +FBBBBBFLLR +BFFFBBFLRR +FFBBFBFRLL +BFFFBFBLRL +BFBBBFBLLL +FFFBFBBLLR +FFBBBFBRLR +FFFBBBBLRR +BFFFFBFRRL +FBFFBBBRLR +BFFFFBFRLR +BFBFBFBRLR +FFBFBFFLLR +BBFBBFFRLL +BFFBBFFRRR +BBFBBFFRLR +FFBBBBFLRR +FFFFBBBLLR +FBBBBBBRRR +FBFFFBBRLL +FFBFBFFLLL +FFFBBFFRRL +BBFFBBFLRL +BFFFBBBLRR +FFBFFBFLLR +FFBFBFBRRR +FBBFBBFRLL +FFFBBFFLLR +FBFFBFBLLR +FBFFBBFLRL +BBFFFFFLRL +FBBBFFFLRR +BBFFBBBLRR +BFFFFFFRLL +BFFBFFFLRL +FFBFBBBLRR +BFBBBBBLRL +FFBBBFFRRR +BFBBFBBLLL +FFFBFBBLRL +BFFFFBBLLL +BBFFFBFRRL +BFFBFBBLRR +BFBFFFBLLL +FBFBBFBLRR +BBFFBBFRLR +FFBFFFBLLL +FBBBFBBRLL +FBFBFFBRLL +BBFBFFBLRR +BBFFBFBRLR +BBFFFFFRRR +FFFFBBFLRL +FFFBFFFRRL +BFFFBBFLRL +FFFBBBBRRR +FBBBBFBRRR +FBFBBBFLLR +BFBBBFFRRL +FFBFBFFLRL +FBBBFBFLLR +BFFBBFFRLL +BFBFFBFRRL +FBFFBFFLRR +FFBFFFFLLL +FFBBBBBRLR +FBBFBFBRRL +FFBFBBFRRL +FBFFFFFLLL +BFFBBBBRLR +FFBFBFBLLL +FBBFFBFLRR +FBBBFFFLLR +BFFFFFFLRL +FFFBBBFLRR +BBFFFBBLRR +FBFBFBBLRR +BFBFBFFRLL +FFBBFFBLLL +BBFFBFFLLL +FFBFFBBRLL +BFBBFFBLLR +BFFBBFBLLL +FFFBBBFRRL +FFBFFBBRRL +FFFBFBFLRL +FBFFBBBLRL +BFBBBBFLRR +BFFFBFBRLR +BFFBBBBLLL +FFBBBBFRLR +FFFBFFFLRR +BBFFBFFRLL +FBBFBBFRLR +FBFFBBBLRR +FBFBFFFLRR +BBFBFFBRLR +FBFFBFBRLR +FBBBBBFRLR +FBBBBFBLRL +FBBFBBBLLR +BBFFFFBLLR +FFFBFFBLRL +BFBBFBFLLR +FBFBBBBRRR +FBBFFBBRRR +FBFBFBBRLL +BFFFFBFLRL +FBBBFBBLLL +FBBFBFFRRL +BFFBBBBLRL +BBFFBFFRRL +BFFBBFFLLL +BFBBBFFRLL +FFFBBBFLRL +FFBFFBFRLR +BFFBBBFRRR +FBFBFBBLLL +BBFBFFBRRR +FFFBFBFLLR +FFBBFFFRLL +BFFFBFBRRL +BFFFBFBRLL +BFBFFBBRLR +BFFBFBBLRL +BFBFFFFRLL +FBFFBFFRRL +BBFFFBFLLR +FBBFBFBRLR +BFBFBBBLLL +BFBFBBBLRL +BBFFBBBLLL +BBFBFBFLRL +BFBFBBFRLR +FBFBBFBRRR +FBBBFBBLRL +FFFBBBFRRR +FBFFFBFRRR +BFBBBBFRLR +FFFBFBFRLL +BFFBFFBRRL +FBBFBBFLLL +BBFBFBBRLR +FFFBBFBLLL +FBFBBBFLRR +BFBBBBFLLL +BBFBFFBLRL +BFBFFBFRLR +FBFFBBBRLL +BFFFFBBLRR +BFFFFFFRRR +BBFFBBBRRR +BBFBFBFLLR +BFFBFFFRRR +FBBBFFFLLL +BFFBFFFLLL +FFBFBBFLRR +FFBBFFFLRR +BFFBBFFLLR +FFBBBBFRLL +BFFBBBFRRL +FBBFFFFLRR +FBBFFFBLRL +BFFBBBFLLR +FFBFBFFRRL +BFBBFFBRRL +BFFFFFFLLL +FFFBBFFLLL +FBBBFBFLRR +FBBFFBFLRL +BFBBFFBRLR +BBFBFBFLRR +FFBBBBFRRR +BBFFBBBLLR +FFBBBFFLRR +BBFFFBBRRL +BBFBFFFLRR +BFBFBBFRRR +BFFFFBBRLR +FFFBFFBLLL +FBFBFBBRRR +FFBFBBBRRL +BFBFBFFRRL +FBBBBFBLRR +BFFFFFBRRR +FBBBFFBRLR +BFBFFBBLLL +FFBBFFFRLR +FBFBBFBRRL +FFFBFBBRRL +BFBFFFBRRR +FBFBFFFRRR +BFBFFFBLRR +BFBBFBFRRL +FFFBBBFRLR +FFFBBFBLRL +FBBBFFBLLR +BFFFBFBLLR +BFBFBFBLLR +BFBBBFFRRR +FBBBBFBLLL +BBFFFBBLRL +FBBBBBBRRL +FBBBFBBRRR +FFBFFBFLLL +FBFFFFBLRL +FBBFFBFLLR +FFFFBBFRRL +BFFFFFBLLR +BFFFBBBLLL +FBBBBBFRRR +FFBFFBBLRL +FBFFFBBLLR +FBBBBBBLLR +FBFFBFBRLL +FBBBBFFRLR +FFBBFBFLRL +BFBBBBBRLL +BBFBFFBRRL +FFBFBFFRLR +FFFBFBFLRR +FFBBBBBLRL +BBFBBFFLRL +BFBBFFFLLR +BFBFFBFLRL +FBFBBFFRLR +FBFFFFFLRR +BFBFBBFLLL +BFBBBBFRRL +FFFFBBBRLL +FFBBFFBRLR +FBBBFBFLRL +FBFFBBFLLL +BFBFBFBRRR +BFFBFBBLLL +BBFBFFBLLR +FFFBBBBLRL +FBBBFBBLRR +FBFFBFFRRR +BBFBFBBRLL +FFFBBFBLRR +FFBFFBFRRL +FBBFFFFRRR +FBFBBFBLRL +BFFFBFFLRL +FFBFFFFRLR +BFBFBFFLRL +FFBFFFFRRR +BFFBBBFLLL +FBBFBFBRRR +FFBBBBBLLL +FBBFFBBLLL +FFFBBBBLLL +BBFBFBBLLL +BBFFBFFRLR +BFFFBFFLRR +BFFFBBBRLL +FFBBFBFLLL +BFBFFFBRLL +FFFFBBBRRL +FFBBFBBRRL +FBBFFBBLRL +FFBFBBBRLR +FBFBFFBRLR +FFBBFFBLLR +BFFBFBBRRL +BBFFFBFRLR +FBBFFFBRLL +BFFFBBBRRR +FFBFFFBRLL +BFBBFFFLLL +BFFBBFFRRL +BFBBFFBRLL +FBBBBFFLLL +FBBBFBBRRL +FFFFBBFLRR +BBFBBFFRRL +BFFBFFFLRR +FFFBFFBLRR +BFFBBFBRRR +BFBFBBBRLR +BFFBBBBLLR +BFFFFBBRRL +FFFBBBBRRL +FFBBBFFRRL +FBBBBBFLRR +BFFBFBFLLR +BFBFBBBRLL +FFBFBFFRRR +BFBBBFBLLR +FBFFBFFLLL +BFBBBBBLLL +BFBFBBFRLL +BFFBBBFLRL +BFBBFBFRLR +BBFFBBBRLR +BFFFBBFRLL +FFBBFBBRRR +FBFBFBFRLL +FBBFFBFRLR +FBFFBBBLLL +BFBFFFFRRL +BFBBBBFLRL +BFBFFBFRLL +BFBFBFBRLL +FBBFFFFLLR +BFBBBFBLRL +FFBBFFBRLL +BFBBFBFLLL +BBFFFBFLRR +FFBBFFFLLL +BBFBBFFRRR +FBBBBBFRRL +FBBFBFBLRL +BFFFFFBRLR +BFBBBBBRRR +FBFFFBBLRR +FBFBBFFLRL +FFBBBBFRRL +BFFFBBFLLR +BFFBFBFRRL +FBFFFFBRLL +FBFFFBFRLR +FFFFBBFRLR +BFFBBFFLRL +FBFBFFFRRL +BFFFBFFRRR +FFBFFFBRRL +FBFFBBFRLL +BFFBFBFRLL +FBBBBBFLRL +FFBBBFBRLL +FFFBBFFLRL +BFFBFBFLLL +FBBBFFFRLR +FBFBBFFLRR +FBBBBFBRLL +FBBFFBFLLL +BBFFFFFLRR +FFFBBFBRRL +FBFBBFBLLR +FFBFBBFRRR +FBFBBFBLLL +FBBFBFFRLR +BBFFBFBLLR +BBFFFFBRRR +FFBFBBFLRL +BFBBFBBLLR +FFBBBFFLRL +FFFBFBBLLL +BBFFBBFLRR +FFBBBFBRRR +FFBFBBFRLR +BBFFBFFLRR +FFBBBBFLLL +FFFBBBFRLL +FBBBBBBLRR +FBBBBBFRLL +FBFBBBBRRL +FBBBFFFRLL +BFBFBFFLRR +FFBFBBBLLL +FFBFBBFLLL +FFBBFBFRLR +BBFFFBFRLL +FBFBFBFLLR +FFBBBFFLLL +FFBFFFFLLR +FFBBBBBRLL +FFBBFFFLLR +BBFFFBFLLL +BFFFBBFRRR +FBBBBFBRRL +BFBBFFFRRL +BFFFFBBLRL +FFBBBBBLLR +BFBBFFFRLL +FBFBFBBLLR +FBBFBBBRRL +BFBBFFBLRR +FBFBBBFLRL +FBFBBFFRLL +BFBBBBBLLR +FBBFFFBRLR +BBFFFBBRRR +FBFBFFBRRR +FFFBBBBRLL +FFBFFFBLRL +FFBFFBFLRR +BFFFBBBLLR +FBFFBBBLLR +FFFBFFFRLL +FBBBFBBLLR +BBFBBFFLLL +FBBFBFBLLR +FBFFBBFLRR +BFBFFBBRLL +BBFFBFFRRR +FBBFFBBRRL +BFFBFFBLRL +FFBFFFBLRR +FBFBFFBLLL +FBBFBFBLLL +BBFBFBFRRL +BFBFFBBLRR +FFBFFBBLRR +FBBBBFFLRR +BFBBFBFLRR +FFBFBFFRLL +BBFFBFFLRL +BFBBBFBRLR +FBBFBBFLRR +FBBBBBBLLL +FFFBFFBRRR +FFBBBFFRLR +BFFBFBBLLR +FBFBFFFLLL +FBBFFBFRRL +FBBFBBBRLL +FBFBBBFRLR +BFFBBFBLRR +BBFFFFFLLL +BFFBBBFRLR +BFFFBFFRLL +FFFBBBFLLR +BFFFFFFRRL +FBBBBFFLRL +FBFFFFFLLR +FFBFBFBLLR +FFBBFFFLRL +FFFBFFBRLL +FFBBFBFLLR +FFFBFFBRRL +FFFBBFBLLR +BBFFFBBRLR +BFFFFBFRLL +FFBFFBBLLL +FBFBBBFLLL +FBBBFFFRRR +BFBFBFFRRR +FFFBFFBLLR +BFFBFFBLRR +BBFBFBFRLR +FFFFBBBLRL +FFFBFBFLLL +BFFFFBBRRR +BBFBFFBLLL +BFBFBBFRRL +FFBFFBBRLR +FFBBFFFRRL +BBFFBFBRRL +BBFFFFFRLR +BFFBBFBRLL +BBFFFFBRRL +FFBBBFBLLL +FBBFBBBRRR +BFFBBBBRRL +BFFFFFFRLR +FBBFFFBLRR +FBBBBFFRRR +FBFBFFFLRL +FBFBBFFLLL +BFBFBBBLLR +FBBBFFBLLL +FBFFBFBLLL +BBFBFFFRLR +FBFFFBBLLL +BFFFFFBRRL +FBBFBBFLRL +FBFFFBBRRL +BFFFBFBLLL +FFFFBBFRRR +FBFBBFFRRR +BBFBBFBLRL +BBFBFFFRRL +BFBFFFFRLR +FFFBBFBRRR +FFBFFBFLRL +FFFBBFFRLL +BFFBBBFRLL +FFFBFBBRLR +BFBBBBFRLL +BFBFFFBRLR +BBFFBBFLLR +FFFFBBFRLL +FBBBFFBLRL +BBFBFFBRLL +FBFFBFBLRL +BBFFFBFLRL +FFFFBBBLLL +FBFFFFBLRR +FBFBBFFLLR +FFBBFFFRRR +BFBBFFBLLL +BFBBBFFLLL +FBBBBBBLRL +FFBFFFFLRR +FBFFBFBLRR +BFFBBBBRLL +BFFBFFBLLR +BBFFFFFLLR +BFBFFBFLRR +BBFFBBFRLL +BFFFBBFRRL +FFBFFBBLLR +BFBBFBBRLR +BFFBFFFRLL +FFBBBFFLLR +BBFBBFFLLR +BBFBFBBLLR +FFBFBFBRRL +BFBFFBFLLR +BFFBFBFRRR +FBBBFBFRLL +FFBFBFBLRR +FBFFFFFRRL +BFBBBBFLLR +FBFBFFFRLL +BBFFFFBLRL +FFBFBFFLRR +FBFBBBBLLL +FBFBFBFLRL +BFBBBFBRLL +FBFBFBBRLR +FBBBBBBRLL +BFBBBFBRRR +FBBBFBFRLR +FBFFFFFRRR +BFFFFFFLLR +BFBBFBBRRR +BBFBFBBRRR +BFBFBFBLRR +BFBBFBFLRL +BFFFBBBRRL +BFFBFBBRLL +FBFFFBBRLR +FFBBBFBRRL +BFBFFFBLRL +FFFFBBBRLR +BFBFFBBRRR +FBFFBBFRLR +FBFFFBFLLR +FBFBFFBLLR +BFFFFBFLRR +BFBFBFFLLR +FBFFBFFLRL +BFBBFFBRRR +BBFFBBFLLL +FFFBFBFRLR +FBBBBBFLLL +FBFFFFBRLR +BFFBBBBRRR +BFBBBBBRRL +FFFBBFFLRR +FBBBFBFRRR +BBFBFBBRRL +FFBBFFBLRL +FFFBBBBLLR +BFFFFFBRLL +FFBFFFBLLR +BFFBFBBRRR +FFBFBFBLRL +FBFBBFBRLR +BFFBFBBRLR +BFBFFFFLRR +FFBFBBBRLL +BFBBBFBLRR +BBFFBFBRLL +FFFBBFBRLL +BBFFBFBLRR +BFBBFFFLRL +BFBBFBBRLL +BFFFBBBLRL +BBFBFBFLLL +BFBFFBBRRL +BFBFFFFLLL +BBFFFBFRRR +FBFBBBFRRL +BFFBBBBLRR +BFBBBBFRRR +FFFFBBFLLL +FFFBFBBRLL +FBBFBBFLLR +FBFBFBFLRR +BFFFFFFLRR +FBFFFFFRLR +BFBFFFFLLR +BBFBFBFRLL +FBFFFFBLLL +BBFBFBFRRR +FBBBBBBRLR +BBFFBBFRRR +BFFBFBFLRR +FBBFBFFRLL +BBFFFBBRLL +BBFFBBBRRL +BFFBBBFLRR +FFFBBFFRLR +FBFFBBBRRR +FFFBFFFLRL +BBFBBFBLLL +FBBFBBFRRL +FBBFBFBRLL +FBFFBBFRRR +FBFFFBFRLL +FFBFBBFLLR +FBFBBBBRLR +BFFBBFBLRL +FFFBBBBRLR +BFFFFBFLLR +FFBBFBFLRR +FFFFBBBRRR +FBFBFBFRRR +FFBBFBBLRL +BFBFBFBRRL +BBFBFBBLRR +FBFFFFFLRL +FBFBFBFLLL +FBFBBBFRLL +FFBBBBBRRL +FFFBBFFRRR +BFBBFFFRLR +FFBFFFFRRL +BFBBBFFLRL +FBBFBBFRRR +FBBBFBBRLR +BFBBFBBLRR +FBBFFFBRRL +FBFFBBFLLR +FBBFFBBRLR +FFFBFBFRRR +FBBFBFFRRR +BFBBFBBLRL +FFBFFBFRRR +BFFBBFFLRR +FBFFBFBRRL +FFBFFBFRLL +FFBBBFBLLR +FBFFBBBRRL +FFBFBBBLRL +BFFFBFFLLR +FBFBBBFRRR +FFFBBFBRLR +BFFBFFBLLL +FBFFBFFRLR +BBFBBFBLLR +BFFFFBBLLR +BFBBFBFRLL +FBFBBBBLRL +FBBFBBBRLR +BFBFBBBLRR +BBFBFFFLRL +FFBBBBBLRR +FBBFBBBLLL +BFFFFBFLLL +FBBFFFBRRR +FBBBFBFLLL +FFFBFFBRLR +FFFBFFFLLL +FFFBFFFRRR +FBFFFBFRRL +BBFBFFFLLR +FFBBBBFLRL +FBFBFFBLRR +FBBBFFFLRL +FBFFFFFRLL +BFFBBFBRLR +BBFFBBBLRL +BFBBBFBRRL +BFBFFFFRRR +FBBFFFBLLL +FFBFBBBRRR +FFBBFBFRRR +FFBBFBBRLR +BFBBBBBRLR +FBFFBFBRRR +FBFBFBBRRL +BBFFFFBLLL +FBFBFFBRRL +FFBFBBBLLR +FFBBFFBLRR +FBBFFFFLRL +BFFBFFBRLR +FFBBFBBLLL +FBBFBBBLRL +BFFFFBFRRR +BBFFFBBLLL +BBFFBFBLRL +BFBFBFBLLL +FBFFBBFRRL +FFFBFBFRRL +BFBFFBBLRL +FFFFBBFLLR +FBFBBFFRRL +BFBFBBBRRR +FFBBBBFLLR +FFBFBBFRLL +FBBFBFFLLL +FBFBBFBRLL +BFBBBFFLRR +FBBBFFBLRR +BFFBBFBLLR +FFFFBBBLRR +BBFFFFFRLL +BFBFFBFLLL +BFBFFFBLLR +BFBFFBFRRR +BFFFFFBLRL +BBFFBBBRLL +BFFFBBBRLR +FBBFBFFLLR +FBFFFBFLRR +FBBBFFBRRL +BFBBFFBLRL +BFFFBBFRLR +BFFFBFBLRR +FBFBFBFRLR +FBBBFFBRRR +FFBBBFFRLL +FBFFFFBRRR +FFBBFBBRLL +FBBFFBFRLL +FFFBFBBRRR +FBBFFFFLLL +FBFFFFBLLR +BFBBFFFRRR +FBBBBFBRLR +FFBBFBFRRL +FFFBBBFLLL +BFFBBFBRRL +FBFFFBFLRL +BBFBFFFLLL +BFFFBFFRRL +BFBFBBBRRL +BFFBFFFLLR +FBBFBFFLRL +FBFBFFFLLR +BFBFBBFLRL +FBBBFFBRLL +BFBBBFFRLR +FFFBFFFRLR +FBFBBBBLLR +FBFFBFFLLR +BFFFBFFRLR +FFBBBFBLRR +FFBFFFBRRR +FFBFBFBRLR +FFBBFFBRRL +BFFFFFBLLL +FBBFFBBRLL +BFFFBFBRRR +BBFFBBFRRL +FBBFBFFLRR +FBBBBFFLLR +BBFFFFBRLL +FFBFFFFLRL +FBBFFFFRLL +FBBFFFFRRL +BFFFBBFLLL +FBBFFFFRLR +BFBBBFFLLR +BFBBFBBRRL +BBFFFFBRLR +FBBBFBFRRL +FBBFFBBLRR +FBBFFBFRRR +BBFBFFFRRR +BBFFFFBLRR +BFFFBFFLLL +FFFBFFFLLR +FBBBFFFRRL +BBFFFFFRRL +BFBFBFFLLL +BFBFBBFLLR +FBBBBFFRLL +BFBBFBFRRR +BFFFFFBLRR +FFBBBBBRRR +FFBFFBBRRR +FFBBBFBLRL +FFBFFFBRLR +FBBFFBBLLR +BFFBBFFRLR +BFFBFFBRRR +FBFBFBFRRL +BBFBFFFRLL +BFFBFFFRRL +BFBFFFBRRL +BBFFFBBLLR +BBFFBFFLLR +BBFBFBBLRL +FBFBBBBRLL +BBFFBFBRRR +BFFBFFFRLR +BFFFFBBRLL +BBFBBFFLRR +FBBBBFBLLR +FBBFBBBLRR +FBFFFBFLLL +FBBFBFBLRR +FBFBFFBLRL +BFBBFFFLRR +FBFBFFFRLR +FBFFBFFRLL +FFFBFBBLRR +FBBBBFFRRL +BBFFBFBLLL +FBFBFBBLRL +BFBFBBFLRR +BFFBFBFRLR +BFBFFFFLRL +BFBFFBBLLR +BFFBFFBRLL +BFBFBFFRLR +FBFFFBBRRR +BFBFBFBLRL +FFBFFFFRLL +FFBBFBBLRR +FFBFBFBRLL diff --git a/2020/05-Binary_Boarding/second.hs b/2020/05-Binary_Boarding/second.hs new file mode 100644 index 0000000..9f85b7e --- /dev/null +++ b/2020/05-Binary_Boarding/second.hs @@ -0,0 +1,48 @@ +-- requires cabal install --lib megaparsec parser-combinators +module Main (main) where + +import Control.Monad (void, when) +import Data.List (foldl', sort) +import Data.Void (Void) +import Text.Megaparsec +import Text.Megaparsec.Char +import System.Exit (die) + +type BoardingPass = Int + +type Parser = Parsec Void String + +parseColumn :: Parser Int +parseColumn = do + colStr <- some (char 'L' <|> char 'R') + return $ foldl' (\acc c -> acc * 2 + if c == 'R' then 1 else 0) 0 colStr + +parseRow :: Parser Int +parseRow = do + rowStr <- some (char 'B' <|> char 'F') + return $ foldl' (\acc c -> acc * 2 + if c == 'B' then 1 else 0) 0 rowStr + +parseBP :: Parser BoardingPass +parseBP = do + row <- parseRow + column <- parseColumn + void (char '\n') + return $ row * 8 + column + +parseBPs :: Parser [BoardingPass] +parseBPs = some (parseBP) <* eof + +parseInput :: String -> IO [BoardingPass] +parseInput filename = do + input <- readFile filename + case runParser parseBPs filename input of + Left bundle -> die $ errorBundlePretty bundle + Right bps -> return bps + +compute :: [BoardingPass]-> Int +compute bps = snd . head $ filter (\(x, y) -> x /= y) $ zip (sort bps) [48..] + +main :: IO () +main = do + input <- parseInput "input" + print $ compute input -- cgit v1.2.3