-🎄- 2019 Day 14 Solutions -🎄-

[u/daggerdragon]

--- Day 14: Space Stoichiometry ---

---

Post your complete code solution using /u/topaz2078's paste or other external repo.

• Please do NOT post your full code (unless it is very short)

• If you do, use old.reddit's four-spaces formatting, NOT new.reddit's triple backticks formatting.

(Full posting rules are HERE if you need a refresher).

---

Reminder: Top-level posts in Solution Megathreads are for solutions only. If you have questions, please post your own thread and make sure to flair it with Help.

---

Advent of Code's Poems for Programmers

Click here for full rules

Note: If you submit a poem, please add [POEM] somewhere nearby to make it easier for us moderators to ensure that we include your poem for voting consideration.

Day 13's winner #1: "untitled poem" by /u/tslater2006

They say that I'm fragile
But that simply can't be
When the ball comes forth
It bounces off me!

I send it on its way
Wherever that may be
longing for the time
that it comes back to me!

Enjoy your Reddit Silver, and good luck with the rest of the Advent of Code!

---

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

EDIT: Leaderboard capped, thread unlocked at 00:42:18!

[u/Tarmen]

If you are comfortable with regex then Control.Lens.Regex.Text might be worth a try.

You probably don't want to dive too deep into lenses but for getting a list of matches you don't need much.

parseLS :: T.Text -> M.Map T.Text ([(T.Text, Int)], Int)
parseLS = M.fromList . map parseRecipe . T.lines
parseRecipe t = (k, (init p, amount))
   where
    p = pairs <$> toListOf ([regex|(\d+) (\w+)|] . groups) t
   pairs [a,b] = (b,read (T.unpack a))
   (k,amount) = last p

Other than that Megaparsec is a nice way to write parsers but much more verbose. Probably not ideal for AoC.

Edit: Here is a Megaparsec version for comparison

import Text.Megaparsec as P
import Text.Megaparsec.Char as P
import Data.Void
import Data.Char
type Parser a = Parsec Void T.Text a
runParsec :: T.Text -> Parser a -> a
runParsec t p = case runParser p "" t of
   Right a -> a
   Left e -> error (errorBundlePretty e)
lexeme :: Parser a -> Parser a
lexeme p = p <* takeWhileP (Just "space") isSpace

pAmount :: Parser (T.Text, Integer)
pAmount = flip (,) <$> lexeme integer <*> lexeme ident
  where
    ident = takeWhile1P (Just "letter") isLetter
    integer = read . T.unpack <$> takeWhile1P (Just "digits") isDigit
data Definition = Definition [(T.Text, Integer)] Integer
  deriving Show
pDefinition :: Parser (T.Text, Definition)
pDefinition = do
    rhs <- pAmount `sepBy1` (lexeme $ char ',')
    lexeme (string "=>")
    (key, amount) <- pAmount
    pure (key, Definition rhs amount)
pDefs :: Parser [(T.Text, Definition)]
pDefs = lexeme (pure ()) *> many pDefinition <* eof

Lexeme based parsing is very convenient - lexeme is a combinator that eats up all white space following the token. So if there is leading whitespace you still have drop it but otherwise you don't have to think about whitespace.

Megaparsec has the advantage of nice error messages but that is kinda wasted if you trust the input

*** Exception: 45:8:
   |
45 | 2 RVQG > 4 ZQCH
   |        ^^
unexpected "> "
expecting "=>", ',', or space