projects
/
advent-of-code-19.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
Renamed rule to reaction
[advent-of-code-19.git]
/
advent14
/
src
/
advent14.hs
diff --git
a/advent14/src/advent14.hs
b/advent14/src/advent14.hs
index 1fafe9bce157c425d898d3099832e89265e4ed1d..4e35ee25605fa687e24bf65f88f219f912862f42 100644
(file)
--- a/
advent14/src/advent14.hs
+++ b/
advent14/src/advent14.hs
@@
-17,75
+17,66
@@
import qualified Data.Set as S
data Reagent = Reagent { _quantity :: Int, _chemical :: String } deriving (Ord, Eq, Show)
data Reagent = Reagent { _quantity :: Int, _chemical :: String } deriving (Ord, Eq, Show)
-data R
ule = Rule
{_lhs :: S.Set Reagent, _rhs :: Reagent} deriving (Eq, Show)
+data R
eaction = Reaction
{_lhs :: S.Set Reagent, _rhs :: Reagent} deriving (Eq, Show)
-type R
uleBase = M.Map String Rule
+type R
eactions = M.Map String Reaction
type Requirement = M.Map String Int
main :: IO ()
main = do
text <- TIO.readFile "data/advent14.txt"
type Requirement = M.Map String Int
main :: IO ()
main = do
text <- TIO.readFile "data/advent14.txt"
- -- let rules = successfulParse text
- -- let ruleBase = mkRuleBase rules
- let ruleBase = successfulParse text
- -- print rules
- -- print ruleBase
- print $ part1 ruleBase
- print $ part2 ruleBase
+ let reactions = successfulParse text
+ print $ part1 reactions
+ print $ part2 reactions
oreLimit :: Int
oreLimit = 10^12
oreLimit :: Int
oreLimit = 10^12
-mkRuleBase :: [Rule] -> RuleBase
-mkRuleBase = foldl' addRule M.empty
- where addRule base rule = M.insert (_chemical $ _rhs rule) rule base
-
-
--- part1 rules = required!"ORE"
+-- part1 reactions = required!"ORE"
-- where required0 = M.singleton "FUEL" 1
-- where required0 = M.singleton "FUEL" 1
--- required = produce r
ule
s required
-part1 r
ules = oreForFuel rule
s 1
+-- required = produce r
eaction
s required
+part1 r
eactions = oreForFuel reaction
s 1
-part2 r
ules = searchFuel rule
s (upper `div` 2) upper
- where upper = findUpper r
ule
s (oreLimit `div` base)
- base = oreForFuel r
ule
s 1
+part2 r
eactions = searchFuel reaction
s (upper `div` 2) upper
+ where upper = findUpper r
eaction
s (oreLimit `div` base)
+ base = oreForFuel r
eaction
s 1
-oreForFuel :: R
uleBase
-> Int -> Int
-oreForFuel r
ule
s n = required!"ORE"
+oreForFuel :: R
eactions
-> Int -> Int
+oreForFuel r
eaction
s n = required!"ORE"
where required0 = M.singleton "FUEL" n
where required0 = M.singleton "FUEL" n
- required = produce r
ule
s required0
+ required = produce r
eaction
s required0
-findUpper :: R
uleBase
-> Int -> Int
+findUpper :: R
eactions
-> Int -> Int
-- findUpper _ n | trace ("Upper " ++ show n) False = undefined
-- findUpper _ n | trace ("Upper " ++ show n) False = undefined
-findUpper r
ule
s n = if ore > oreLimit
+findUpper r
eaction
s n = if ore > oreLimit
then n
then n
- else findUpper r
ule
s (n * 2)
- where ore = oreForFuel r
ule
s n
+ else findUpper r
eaction
s (n * 2)
+ where ore = oreForFuel r
eaction
s n
-searchFuel :: R
uleBase
-> Int -> Int -> Int
+searchFuel :: R
eactions
-> Int -> Int -> Int
-- searchFuel _ lower upper | trace ("Search " ++ show lower ++ " - " ++ show upper) False = undefined
-- searchFuel _ lower upper | trace ("Search " ++ show lower ++ " - " ++ show upper) False = undefined
-searchFuel r
ule
s lower upper
+searchFuel r
eaction
s lower upper
| upper == lower = upper
| otherwise = if ore > oreLimit
| upper == lower = upper
| otherwise = if ore > oreLimit
- then searchFuel r
ule
s lower (mid - 1)
- else searchFuel r
ule
s mid upper
+ then searchFuel r
eaction
s lower (mid - 1)
+ else searchFuel r
eaction
s mid upper
where mid = (upper + lower + 1) `div` 2
where mid = (upper + lower + 1) `div` 2
- ore = oreForFuel r
ule
s mid
+ ore = oreForFuel r
eaction
s mid
-produce :: R
uleBase
-> Requirement -> Requirement
-produce r
ule
s required
+produce :: R
eactions
-> Requirement -> Requirement
+produce r
eaction
s required
| M.null outstanding = required
| M.null outstanding = required
- | otherwise = produce r
ule
s required''
+ | otherwise = produce r
eaction
s required''
where outstanding = M.filter (> 0) $ nonOre required
(chem, qty) = M.findMin outstanding
where outstanding = M.filter (> 0) $ nonOre required
(chem, qty) = M.findMin outstanding
- r
ule = rule
s!chem
- productQty = _quantity $ _rhs r
ule
+ r
eaction = reaction
s!chem
+ productQty = _quantity $ _rhs r
eaction
applications = max 1 (qty `div` productQty)
qty' = qty - (applications * productQty)
required' = M.insert chem qty' required
applications = max 1 (qty `div` productQty)
qty' = qty - (applications * productQty)
required' = M.insert chem qty' required
- required'' = S.foldl (addRequrirement applications) required' (_lhs r
ule
)
+ required'' = S.foldl (addRequrirement applications) required' (_lhs r
eaction
)
nonOre :: Requirement -> Requirement
nonOre :: Requirement -> Requirement
@@
-114,16
+105,20
@@
arrowP = symb "=>"
commaP = symb ","
identifierP = some alphaNumChar <* sc
commaP = symb ","
identifierP = some alphaNumChar <* sc
-r
ulesP = mkRuleBase <$> many rule
P
+r
eactionsP = mkReactions <$> many reaction
P
-r
uleP = Rule
<$> reagentsP <* arrowP <*> reagentP
+r
eactionP = Reaction
<$> reagentsP <* arrowP <*> reagentP
reagentP = Reagent <$> integer <*> identifierP
reagentsP = S.fromList <$> reagentP `sepBy` commaP
reagentP = Reagent <$> integer <*> identifierP
reagentsP = S.fromList <$> reagentP `sepBy` commaP
+mkReactions :: [Reaction] -> Reactions
+mkReactions = foldl' addReaction M.empty
+ where addReaction base reaction = M.insert (_chemical $ _rhs reaction) reaction base
+
-- successfulParse :: Text -> [Vec]
-- successfulParse :: Text -> [Vec]
-successfulParse :: Text -> R
uleBase
+successfulParse :: Text -> R
eactions
successfulParse input =
successfulParse input =
- case parse r
ule
sP "input" input of
+ case parse r
eaction
sP "input" input of
Left _err -> M.empty -- TIO.putStr $ T.pack $ parseErrorPretty err
Left _err -> M.empty -- TIO.putStr $ T.pack $ parseErrorPretty err
- Right r
ules -> rule
s
+ Right r
eactions -> reaction
s