Keep range mappings separate from ranges

Author: mnvr

05.hs

@@ -6,7 +6,7 @@ main = interact $ (++ "\n") . show . ((,) <$> p1 <*> p2) . parseAlmanac
 
 data Almanac = Almanac { seeds :: [Int], maps :: [Map] }
 type Map = [RangeMapping]
-data RangeMapping = RangeMapping { from :: Range, to :: Range }
+data RangeMapping = RangeMapping { from :: Int, to :: Int, rlen :: Int }
 data Range = Range { start :: Int, len :: Int }
 
 parseAlmanac :: String -> Almanac
@@ -20,11 +20,10 @@ parseAlmanac s = case parse almanac "" s of
      seeds = string "seeds: " *> nums <* count 2 newline
      mapHeader = many1 (letter <|> char '-' <|> sp) >> char ':'
      endOfLineOrFile = void endOfLine <|> eof
-     rangeMapping = mkRangeMapping <$> (num <* sp) <*> (num <* sp) <*> num
+     rangeMapping = flip RangeMapping <$> (num <* sp) <*> (num <* sp) <*> num
      map = mapHeader *> newline *> (rangeMapping `endBy` endOfLineOrFile)
      maps = map `endBy` endOfLineOrFile
      almanac = Almanac <$> seeds <*> maps
-     mkRangeMapping a b c = RangeMapping (Range b c) (Range a c)
 
 p1, p2 :: Almanac -> Int
 p1 Almanac { seeds, maps } = solve (map (`Range` 1) seeds) maps
@@ -44,14 +43,14 @@ transformRanges rs m = concatMap (`transformRange` m) rs
 -- may cause the range to split.
 transformRange :: Range -> [RangeMapping] -> [Range]
 transformRange r [] = [r]
-transformRange r (rm:rms) = concatMap transform (intersections r (from rm))
+transformRange r (rm:rms) = concatMap transform (intersections r rm)
   where transform x = case mapRange rm x of
           Nothing -> transformRange x rms
           Just y -> [y]
 
 -- Not necessarily symmetric.
-intersections :: Range -> Range -> [Range]
-intersections r@Range { start = s, len = n } r'@Range { start = s', len = n' }
+intersections :: Range -> RangeMapping -> [Range]
+intersections r@Range { start = s, len = n } RangeMapping { from = s', rlen = n' }
   | s > e' = [r]
   | e < s' = [r]
   | s < s' = mk s (s' - 1) : if e <= e' then [mk s' e] else [mk s' e', mk (e' + 1) e]
@@ -64,9 +63,9 @@ intersections r@Range { start = s, len = n } r'@Range { start = s', len = n' }
 -- boundaries of the 'from' range mapping (i.e. either it falls completely
 -- within, or is completely outside).
 mapRange :: RangeMapping -> Range -> Maybe Range
-mapRange RangeMapping { from, to } r@Range { start = s, len = n }
-  | inRange from s = Just $ Range (s - start from + start to) n
+mapRange rm@RangeMapping { from, to, rlen } r@Range { start, len }
+  | within rm start = Just $ Range (start - from + to) len
   | otherwise = Nothing
 
-inRange :: Range -> Int -> Bool
-inRange r i = i >= start r && i <= (start r + len r)
+within :: RangeMapping -> Int -> Bool
+within RangeMapping { from, rlen } i = i >= from && i <= from + rlen