Solution to Advent of Code 2022, Day 4.

Day04.elm

module Day04 exposing (partOne, partTwo)

import Parser exposing ((|.), (|=), Parser, Step(..), int, loop, map, oneOf, run, spaces, succeed, symbol)


type alias Range =
    ( Int, Int )


type alias RangePair =
    ( Range, Range )


rangePairContainment : RangePair -> Bool
rangePairContainment ( ( a1, a2 ), ( b1, b2 ) ) =
    a1 >= b1 && a2 <= b2 || b1 >= a1 && b2 <= a2


rangePairOverlap : RangePair -> Bool
rangePairOverlap ( ( a1, a2 ), ( b1, b2 ) ) =
    a1 >= b1 && a1 <= b2 || b1 >= a1 && b1 <= a2


parseInput : String -> List RangePair
parseInput input =
    let
        parseRange : Parser Range
        parseRange =
            succeed Tuple.pair
                |= int
                |. symbol "-"
                |= int

        parseRangePair : Parser RangePair
        parseRangePair =
            succeed Tuple.pair
                |= parseRange
                |. symbol ","
                |= parseRange
                |. spaces

        parseRangePairs : Parser (List RangePair)
        parseRangePairs =
            loop []
                (\rangePairs ->
                    oneOf
                        [ parseRangePair |> map (\rangePair -> Loop (rangePair :: rangePairs))
                        , succeed <| Done (List.reverse rangePairs)
                        ]
                )
    in
    run parseRangePairs input |> Result.withDefault []


partOne : String -> Int
partOne input =
    input
        |> parseInput
        |> List.filter rangePairContainment
        |> List.length


partTwo : String -> Int
partTwo input =
    input
        |> parseInput
        |> List.filter rangePairOverlap
        |> List.length