Advent of Code 2023 2

advent2023-2.fs

open System.Text.RegularExpressions

let input = [|
  "Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green"
  "Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue"
  "Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red"
  "Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red"
  "Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green"
|]

type Set =
    { red: int
      green: int
      blue: int }
    static member Zero = { red = 0; green = 0; blue = 0 }
    static member (+) (a: Set, b: Set) =
        { red = max a.red b.red
          green = max a.green b.green
          blue = max a.blue b.blue }
    member this.Power = this.red * this.green * this.blue
    member this.WithinLimits (limits: Set) =
        this.red <= limits.red
        && this.green <= limits.green
        && this.blue <= limits.blue

let parseGameNumber =
    let r = Regex("Game (\d+):")
    fun line -> r.Match(line).Groups.[1].Value |> int

let parseGameSets =
    let r = Regex("(\d+)\s(blue|green|red)")
    fun (line: string) ->
    let lineWithoutGame = line.Substring(line.IndexOf(":") + 1)
    lineWithoutGame.Split(';')
    |> Array.map (r.Matches >> Seq.map (fun x ->
        x.Groups.[2].Value, x.Groups.[1].Value |> int
    ) >> dict)
    |> Array.map (fun x ->
        let getOrDefault color =
            match x.TryGetValue(color) with
            | true, value -> int value
            | false, _ -> 0
        { red = getOrDefault "red"
          green = getOrDefault "green"
          blue = getOrDefault "blue" }
    )
    
let parseGames input =
    Seq.map (fun x ->
        parseGameNumber x,
        parseGameSets x |> Seq.sum
    ) input

let part1 globalLimits =
    parseGames
    >> Seq.filter (fun (_, gameLimits) -> gameLimits.WithinLimits globalLimits)
    >> Seq.sumBy fst

let limits =
  { red = 12
    green = 13
    blue = 14 }
input
|> part1 limits // 8

let part2 =
    parseGames
    >> Seq.map (fun (_, gameLimits) -> gameLimits.Power)
    >> Seq.sum

input
|> part2 // 2683