Day 2: Cube Conundrum

Game = dict[str, int]

RED_MAX   = 12
GREEN_MAX = 13
BLUE_MAX  = 14

def read_game(stream=sys.stdin) -> Game:
    try:
        game_string, cubes_string = stream.readline().split(':')
    except ValueError:
        return {}

    game: Game = defaultdict(int)
    game['id'] = int(game_string.split()[-1])

    for cubes in cubes_string.split(';'):
        for cube in cubes.split(','):
            count, color = cube.split()
            game[color] = max(game[color], int(count))

    return game

def read_games(stream=sys.stdin) -> Iterator[Game]:
    while game := read_game(stream):
        yield game

def is_valid_game(game: Game) -> bool:
    return all([
        game['red']   <= RED_MAX,
        game['green'] <= GREEN_MAX,
        game['blue']  <= BLUE_MAX,
    ])

def main(stream=sys.stdin) -> None:
    valid_games = filter(is_valid_game, read_games(stream))
    sum_of_ids  = sum(game['id'] for game in valid_games)
    print(sum_of_ids)

For the second part, the main parsing remainded the same. I just had to change what I did with the games I read.

def power(game: Game) -> int:
    return game['red'] * game['green'] * game['blue']

def main(stream=sys.stdin) -> None:
    sum_of_sets = sum(power(game) for game in read_games(stream))
    print(sum_of_sets)

package com.michaeleisemann.aoc23.services;

import com.michaeleisemann.aoc23.interfaces.DayInterface;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

// https://adventofcode.com/2023/day/2
@Service
public class Day2Service implements DayInterface {

    private final static int RED_AMOUNT  = 12;
    private final static int GREEN_AMOUNT  = 13;
    private final static int BLUE_AMOUNT  = 14;

    private static class Game {

        private final List<Round> rounds = new ArrayList<>();

        private final int id;

        private static class Round {

            private int red;
            private int blue;
            private int green;

            public Round(int red, int blue, int green) {
                this.red = red;
                this.blue = blue;
                this.green = green;
            }

            public Round(String round) {
                String[] cubes = round.split(",");
                for (String cube : cubes) {
                    cube = cube.trim();
                    String[] colors = cube.split(" ");
                    switch (colors[1]) {
                        case "red":
                            red = Integer.parseInt(colors[0]);
                            break;
                        case "blue":
                            blue = Integer.parseInt(colors[0]);
                            break;
                        case "green":
                            green = Integer.parseInt(colors[0]);
                            break;
                    }
                }
            }

            public int getRed() {
                return red;
            }

            public int getBlue() {
                return blue;
            }

            public int getGreen() {
                return green;
            }

            @Override
            public String toString() {
                return "Round: " + red + " red, " + blue + " blue, " + green + " green";
            }
        }

        public Game(int id, String rounds) {
            // rounds are semi-colon delimited
            // cubes are comma delimited
            this.id = id;
            String[] roundStrings = rounds.split(";");
            for (String round : roundStrings) {
                this.rounds.add(new Round(round.trim()));
            }
        }

        public int getId() {
            return id;
        }

        public int getMaxRed() {
            int max = 0;
            for (Round round : rounds) {
                if (round.getRed() > max) {
                    max = round.getRed();
                }
            }
            return max;
        }

        public int getMaxBlue() {
            int max = 0;
            for (Round round : rounds) {
                if (round.getBlue() > max) {
                    max = round.getBlue();
                }
            }
            return max;
        }

        public int getMaxGreen() {
            int max = 0;
            for (Round round : rounds) {
                if (round.getGreen() > max) {
                    max = round.getGreen();
                }
            }
            return max;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("Game: ").append(id).append("\n");
            for (Round round : rounds) {
                sb.append(round).append("\n");
            }
            return sb.toString();
        }
    }

    public String part1(String puzzleInput) {
        String[] lines = puzzleInput.split("\n");
        List<Game> games = new ArrayList<>();
        for (String line : lines) {
            games.add(buildGame(line));
        }
        int gameSum = 0;
        for (Game game : games) {
            int reds = game.getMaxRed();
            int blues = game.getMaxBlue();
            int greens = game.getMaxGreen();
            if (reds <= RED_AMOUNT && blues <= BLUE_AMOUNT && greens <= GREEN_AMOUNT) {
                logger.debug("Game {} is valid", game.getId());
                gameSum += game.getId();
            }
        }
        return String.valueOf(gameSum);
    }

    public String part2(String puzzleInput) {
        String[] lines = puzzleInput.split("\n");
        List<Game> games = new ArrayList<>();
        for (String line : lines) {
            games.add(buildGame(line));
        }
        int powerSum = 0;
        for (Game game : games) {
            int reds = game.getMaxRed();
            int blues = game.getMaxBlue();
            int greens = game.getMaxGreen();
            int power = 1;
            power *= reds;
            power *= blues;
            power *= greens;
            powerSum += power;
        }
        return String.valueOf(powerSum);
    }

    private Game buildGame(String line) {
        String[] parts = line.split(":");
        // remove ervything that is not a number from the first part
        String id = parts[0].replaceAll("\\D+", "");
        String rounds = parts[1].trim();
        return new Game(Integer.parseInt(id), rounds);
    }
}

# Advent of Code 2023
# Day 2: Cube Conundrum

id_sum = 0
power_sum = 0

with open("inputs/day_2.txt") as file:
    for i, line in enumerate(file):
        handfuls = [
            [
                {
                    "amount": int((split := color.split(" "))[0]),
                    "color": split[1],
                }
                for color in handful.split(", ")
            ]
            for handful in line.rstrip("\n").split(": ")[1].split("; ")
        ]

        possible = True

        red_max = 0
        green_max = 0
        blue_max = 0

        for handful in handfuls:
            red = 0
            green = 0
            blue = 0

            for color in handful:
                if color["color"] == "red":
                    red += color["amount"]
                elif color["color"] == "green":
                    green += color["amount"]
                elif color["color"] == "blue":
                    blue += color["amount"]

            if red > 12 or green > 13 or blue > 14:
                possible = False

            if red > red_max:
                red_max = red
            if green > green_max:
                green_max = green
            if blue > blue_max:
                blue_max = blue

        if possible:
            id_sum += i + 1

        power_sum += red_max * green_max * blue_max

print(f"Day 1: {id_sum}")
print(f"Day 2: {power_sum}")

use aoc_runner_derive::aoc;
use regex::Regex;

#[aoc(day2, part1)]
fn part1(input: &str) -> usize {
    let game_re = Regex::new("Game ([0-9]+):").unwrap();
    let set_re = Regex::new("(?::|;)(.*?)(?:;|$)").unwrap();
    let red_re = Regex::new("([0-9]+) red").unwrap();
    let green_re = Regex::new("([0-9]+) green").unwrap();
    let blue_re = Regex::new("([0-9]+) blue").unwrap();
    input
        .lines()
        .filter_map(|line| {
            let game: usize = game_re.captures(line).unwrap()[1].parse().unwrap();
            let mut i = 0;
            while i < line.len() {
                if let Some(s) = set_re.find_at(line, i) {
                    if red_re
                        .captures(s.as_str())
                        .map(|c| c[1].parse().unwrap())
                        .unwrap_or(0)
                        > 12
                    {
                        break;
                    }
                    if green_re
                        .captures(s.as_str())
                        .map(|c| c[1].parse().unwrap())
                        .unwrap_or(0)
                        > 13
                    {
                        break;
                    }
                    if blue_re
                        .captures(s.as_str())
                        .map(|c| c[1].parse().unwrap())
                        .unwrap_or(0)
                        > 14
                    {
                        break;
                    }
                    i = s.start() + 1;
                } else {
                    return Some(game);
                }
            }

            None
        })
        .sum()
}

#[aoc(day2, part2)]
fn part2(input: &str) -> usize {
    let set_re = Regex::new("(?::|;)(.*?)(?:;|$)").unwrap();
    let red_re = Regex::new("([0-9]+) red").unwrap();
    let green_re = Regex::new("([0-9]+) green").unwrap();
    let blue_re = Regex::new("([0-9]+) blue").unwrap();
    input
        .lines()
        .map(|line| {
            let mut max_red = 0;
            let mut max_green = 0;
            let mut max_blue = 0;
            let mut i = 0;
            while i < line.len() {
                if let Some(s) = set_re.find_at(line, i) {
                    max_red = max_red.max(
                        red_re
                            .captures(s.as_str())
                            .map(|c| c[1].parse().unwrap())
                            .unwrap_or(0),
                    );
                    max_green = max_green.max(
                        green_re
                            .captures(s.as_str())
                            .map(|c| c[1].parse().unwrap())
                            .unwrap_or(0),
                    );
                    max_blue = max_blue.max(
                        blue_re
                            .captures(s.as_str())
                            .map(|c| c[1].parse().unwrap())
                            .unwrap_or(0),
                    );
                    i = s.start() + 1;
                } else {
                    break;
                }
            }

            max_red * max_green * max_blue
        })
        .sum()
}

use aoc_runner_derive::aoc;
use logos::{Lexer, Logos};

fn get_count(lex: &mut Lexer<Color>) -> Option<usize> {
    Some(lex.slice().split_once(" ").unwrap().0.parse().unwrap())
}

#[derive(Logos)]
enum Color {
    #[regex("[0-9]+ red", get_count)]
    Red(usize),
    #[regex("[0-9]+ green", get_count)]
    Green(usize),
    #[regex("[0-9]+ blue", get_count)]
    Blue(usize),

    #[error]
    #[regex(r"(Game [0-9]+|: |, |; )", logos::skip)]
    Error,
}

#[aoc(day2, part1, logos)]
fn part1_logos(input: &str) -> usize {
    input
        .lines()
        .enumerate()
        .filter_map(|(game, line)| {
            let mut possible = true;
            for color in Color::lexer(line) {
                match color {
                    Color::Red(n) if n > 12 => possible = false,
                    Color::Green(n) if n > 13 => possible = false,
                    Color::Blue(n) if n > 14 => possible = false,
                    _ => {},
                }
            }

            if possible {
                Some(game + 1)
            } else {
                None
            }
        })
        .sum()
}

#[aoc(day2, part2, logos)]
fn part2_logos(input: &str) -> usize {
    input
        .lines()
        .map(|line| {
            let mut max_red = 0;
            let mut max_green = 0;
            let mut max_blue = 0;
            for color in Color::lexer(line) {
                match color {
                    Color::Red(n) => max_red = max_red.max(n),
                    Color::Green(n) => max_green = max_green.max(n),
                    Color::Blue(n) => max_blue = max_blue.max(n),
                    _ => {},
                }
            }

            max_red * max_green * max_blue
        })
        .sum()
}

AOC 2023
Day 2 - Part 1 : 3035
	generator: 2.863µs,
	runner: 815.616µs

Day 2 - Part 1 - logos : 3035
	generator: 2.375µs,
	runner: 45.886µs

Day 2 - Part 2 : 66027
	generator: 2.374µs,
	runner: 683.266µs

Day 2 - Part 2 - logos : 66027
	generator: 2.375µs,
	runner: 46.166µs

julia> input = readlines("Downloads/input");

julia> function check(data; red, green, blue)
           limits = Dict("red" => red, "green" => green, "blue" => blue)
           groups = split.(split(data, "; "), ", ")
           for group in groups
               for set in group
                   number, color = split(set, " ")
                   if limits[color] < parse(Int, number)
                       return false
                   end
               end
           end
           return true
       end;

julia> result = 0;

julia> for game in input
           name, data = split(game, ": ")
           if check(data; red=12, green=13, blue=14)
               id = parse(Int, split(name, " ")[2])
               result += id
           end
       end

julia> result
2447

julia> function power(data)
           r = Dict("red" => 0, "green" => 0, "blue" => 0)
           groups = split.(split(data, "; "), ", ")
           for group in groups
               for set in group
                   number, color = split(set, " ")
                   number = parse(Int, number)
                   if r[color] < number
                       r[color] = number
                   end
               end
           end
           return values(r) |> prod
       end

julia> result = 0;

julia> for game in input
           name, data = split(game, ": ")
           result += power(data)
       end

julia> result
56322

// [r, g, b]
local getColor(str, color) =
	local trimmed = std.stripChars(str, " ");
	if std.endsWith(trimmed, " " +color)
		then std.parseInt(std.split(trimmed, " ")[0])
		else 0;
local parseTurns(turnStr) = 
	local turns = std.split(turnStr, ",");
	local sumColor(color) = function(acc, str) acc + getColor(str, color);
	[
		std.foldl(sumColor("red"), turns, 0),
		std.foldl(sumColor("green"), turns, 0),
		std.foldl(sumColor("blue"), turns, 0),
	];
// parseGame(gameStr: str) -> {gameId: number, turns: [[r, g, b], ...]]
local parseGame(gameStr) =
	local parts = std.split(gameStr, ":");
	local gameId = std.parseInt(std.substr(parts[0], std.length("Game "), 999));
	local turns = std.split(parts[1], ";");
	{
		id: gameId,
		turns: std.map(parseTurns, turns),
	};
// isValidTurn(turnColor: [r, g, b]) -> bool
local isValidTurn(turnColor) =
	if turnColor[0] > 12 then false
	else if turnColor[1] > 13 then false
	else if turnColor[2] > 14 then false
	else true;
local isValidGame(turns) = std.foldl(
	function(acc, turn)
		if !acc then false
		else isValidTurn(turn),
	turns, true);
local sum(arr) = std.foldl(function(a, b) a+b, arr, 0);

local solve(problemStr) =
	local lines = std.split(problemStr, "\n");
	local parsedLines = std.map(parseGame, lines);
	local possibleGames = std.filter(function(game) isValidGame(game.turns), parsedLines);
	sum(std.map(function(game) game.id, possibleGames));

// part 2
local maxColor(turns) = std.foldl(
	function(acc, turn) [
		std.max(acc[0], turn[0]),
		std.max(acc[1], turn[1]),
		std.max(acc[2], turn[2]),
	],
	turns, [0, 0, 0]
);
local solve2(problemStr) =
	local lines = std.split(problemStr, "\n");
	local parsedLines = std.map(parseGame, lines);
	local gameMaxColors = std.map(function(game) maxColor(game.turns), parsedLines);
	sum(std.map(function(colors) colors[0] * colors[1] * colors[2], gameMaxColors));

local assertEq(a, b) = assert a == b : std.format("%s != %s", [a, b]); "pass";

{
	input:: std.stripChars(importstr "./input.txt", " \n"),
	part1: solve($.input),
	part2: solve2($.input),
	test:: {
		exampleProblem:: "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",
		exampleGame:: "Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green",

		parseGame: assertEq(parseGame(self.exampleGame), {id: 1, turns: [[4, 0, 3], [1, 2, 6], [0, 2, 0]]}),
		isValidTurn: assertEq(isValidTurn([4, 0, 3]), true),
		isValidTurnR: assertEq(isValidTurn([13, 0, 0]), false),
		isValidTurnG: assertEq(isValidTurn([0, 14, 0]), false),
		isValidTurnB: assertEq(isValidTurn([0, 0, 15]), false),
		isValidGame: assertEq(isValidGame([[4, 0, 3], [1, 2, 6], [0, 2, 0]]), true),
		isValidGameR: assertEq(isValidGame([[4, 0, 3], [13, 0, 0]]), false),

		part1Example: assertEq(solve(self.exampleProblem), 8),

		maxColor: assertEq(maxColor([[4, 0, 3], [1, 2, 6], [0, 2, 0]]), [4, 2, 6]),

		part2Example: assertEq(solve2(self.exampleProblem), 2286),
	}
}

use std::env;
use std::io::{self, prelude::*, BufReader};
use std::fs::File;

extern crate regex;
use regex::Regex;

const MAX_RED: usize = 12;
const MAX_GREEN: usize = 13;
const MAX_BLUE: usize = 14;

struct Game {
    id: usize,
    hands: Vec<Hand>,
}
impl From<&String> for Game {
    fn from(s: &String) -> Self {
        let re = Regex::new(r"Game (\d+): (.+)$").unwrap();
        let matches = re.captures(&s).unwrap();
        let hands = matches[2]
            .split(";")
            .map(Hand::from)
            .collect::<Vec<_>>();
        Game {
            id: matches[1].parse().unwrap(),
            hands: hands,
        }
    }
}
impl Game {
    pub fn is_possible(&self) -> bool {
        self.hands.len() == self.hands.iter().filter(|h| h.is_valid()).count()
    }
    pub fn power(&self) -> usize {
        self.hands.iter().map(|x| x.red  ).max().unwrap() *
        self.hands.iter().map(|x| x.green).max().unwrap() *
        self.hands.iter().map(|x| x.blue ).max().unwrap()
    }
}

struct Hand {
    red: usize,
    green: usize,
    blue: usize,
}
impl Hand {
    pub fn is_valid(&self) -> bool {
        self.red <= MAX_RED && self.green <= MAX_GREEN && self.blue <= MAX_BLUE
    }
}
impl From<&str> for Hand {
    fn from(s: &str) -> Self {
        Hand {
            red:   cubes_for_color("red",  &s),
            green: cubes_for_color("green",&s),
            blue:  cubes_for_color("blue", &s),
        }
    }
}

fn cubes_for_color(color: &str, hand: &str) -> usize {
    let re = format!(r"(\d+) {color}");
    let re_color = Regex::new(&re).unwrap();
    if let Some(matches) = re_color.captures(hand) {
        return matches[1].parse().unwrap();
    }
    0
}

fn solve(input: &str) -> io::Result<()> {
    let file = File::open(input).expect("Input file not found.");
    let reader = BufReader::new(file);

    // Input
    let input: Vec<String> = match reader.lines().collect() {
        Err(err) => panic!("Unknown error reading input: {}", err),
        Ok(result) => result,
    };

    let games: Vec<_> = input.iter().map(Game::from).collect();
    let part1: usize = games.iter().filter(|x| x.is_possible()).map(|g| g.id).sum();

    println!("Part 1: {part1}"); // 2369

    let part2: usize = games.iter().map(|g| g.power()).sum();
    println!("Part 2: {part2}"); // 66363

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    solve(&filename).unwrap();
}

=ARRAYFORMULA(
  IF(F2=FALSE,,
   SUM(
    IFERROR(
     FILTER(
      --REGEXEXTRACT(A2:A,"Game (\d+): "), 
      MAP(
       A2:A,
       LAMBDA(
        i,
        LET(
         s,SPLIT(
          TOCOL(
           SPLIT(REGEXEXTRACT(i,": (.*)"),
            ";,"),
           3),
          " "),
           SUM(
            COUNTIFS(
             INDEX(s,0,2),{"red","green","blue"},
             INDEX(s,0,1),{">12",">13",">14"})))))=0)))))

=ARRAYFORMULA(
  SUM(
   BYROW(
    MAP(
     {"r","g","b"},
     LAMBDA(
      x,
      BYROW(
       IFERROR(--REGEXEXTRACT(SPLIT(A2:A,";"),"(\d+) "&x)),
       LAMBDA(
        x,
        MAX(x))))),
    LAMBDA(
     x,
     PRODUCT(x)))))

defmodule AdventOfCode.Solution.Year2023.Day02 do
  def part1(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(&parse_game/1)
    |> Enum.filter(&valid_for_part1?/1)
    |> Enum.map(fn {game_id, _plays} -> game_id end)
    |> Enum.sum()
  end

  def part2(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(&parse_game/1)
    |> Enum.map(&min_cube_power/1)
    |> Enum.sum()
  end

  @bag %{red: 12, green: 13, blue: 14}
  @default_play %{red: 0, green: 0, blue: 0}

  defp valid_for_part1?({_game_id, plays}) do
    Enum.all?(plays, &(&1.red <= @bag.red and &1.green <= @bag.green and &1.blue <= @bag.blue))
  end

  defp min_cube_power({_game_id, plays}) do
    plays
    |> Enum.reduce(@default_play, fn play, acc ->
      Map.merge(acc, play, fn _k, acc_val, play_val -> max(acc_val, play_val) end)
    end)
    |> Map.values()
    |> Enum.product()
  end

  @type parsed_game :: {pos_integer, list(play)}
  @type play :: %{red: non_neg_integer, green: non_neg_integer, blue: non_neg_integer}

  @spec parse_game(String.t()) :: parsed_game
  defp parse_game(line) do
    ["Game " <> game_id, plays] = String.split(line, ": ")

    game_id = String.to_integer(game_id)

    plays =
      plays
      |> String.split("; ")
      |> Enum.map(&parse_play/1)

    {game_id, plays}
  end

  defp parse_play(play) do
    counts =
      ~r/(\d+) (\w+)/
      |> Regex.scan(play, capture: :all_but_first)
      |> Map.new(fn [count, color] ->
        {String.to_existing_atom(color), String.to_integer(count)}
      end)

    Map.merge(@default_play, counts)
  end
end

#!/usr/bin/awk -f
BEGIN {
	FS = "; "
	max["red"] = 12
	max["green"] = 13
	max["blue"] = 14
}

{
	sub(/Game [0-9]*: /, "")
	for (i = 1; i <= NF; ++i) {
		split($i, set, ", ")
		for (j in set) {
			split(set[j], cube, " ")
			if (max[cube[2]] < cube[1])
				next
		}
	}

	total += NR
}

END { print total}

#!/usr/bin/awk -f
BEGIN { FS = "; " }

{
	split("", max)
	sub(/Game [0-9]*: /, "")

	for (i = 1; i <= NF; ++i) {
		split($i, set, ", ")
		for (j in set) {
			split(set[j], cube, " ")
			if (cube[1] > max[cube[2]])
				max[cube[2]] = cube[1]
		}
	}

	total += max["red"] * max["green"] * max["blue"]
}

END { print total }

(define (and-map proc lst)
  (define (and-inner p ls cur-val)
    (cond
      [(null? ls) cur-val]
      [else (and (p (car ls)) (and-inner p (cdr ls) cur-val))]))
  (and-inner proc lst #t))

(use-modules (ice-9 regex)
             (ice-9 format)
             (srfi srfi-1))
(load "utils.scm")

(define (is-game-possible round-dicts cubes)
  (define (is-round-possible round-dict)
    (and (<= (hash-ref round-dict "red" 0) ; defaults to zero, because not all colors get drawn each time
             (hash-ref cubes      "red"))
         (<= (hash-ref round-dict "green" 0)
             (hash-ref cubes      "green"))
         (<= (hash-ref round-dict "blue" 0)
             (hash-ref cubes      "blue"))))
  (and-map is-round-possible round-dicts))

(define (round-parser current-round)
  (define round-dict (make-hash-table 3)) ; one each for red, blue, and green
  (define matches (list-matches "([0-9]+) (red|green|blue)" current-round))
  (map (lambda (m)
         (let [(key (match:substring m 2)) ; the second group in the regex
               (value (string->number (match:substring m 1)))] ; the first group in the regex
           (hash-set! round-dict key (+ value (hash-ref round-dict key 0)))))
       matches)
  round-dict)

(define (game-parser line)
  (map round-parser (string-split line #\;)))

(define (prepare-cubes)
  (let [(t (make-hash-table 3))]
    (hash-set! t "red" 12)
    (hash-set! t "green" 13)
    (hash-set! t "blue" 14)
    t))

(define (count-games games)
  (define (counter gs index sum)
    (cond
      [(null? gs) sum]
      [(eq? #t (car gs)) (counter (cdr gs) (1+ index) (+ sum index))]
      [else (counter (cdr gs) (1+ index) sum)]))
  (counter games 1 0))

(define (proc-task-02a filename)
  (define cubes (prepare-cubes))
  (define games (map game-parser (reverse (slurp filename))))
  (define possible-games (map (lambda (round-dicts)
                                (is-game-possible round-dicts cubes))
                              games))
  (count-games possible-games))

(if (= (proc-task-02a "tiny_input_02") 8)
  (format #t "Task 02, part 1: ~a\n" (proc-task-02a "input_02"))
  (error "tiny-task-02a didn't pass sanity checks"))

;; update table-1 with values from table-2, for key
(define (hash-updater table-1 table-2 key)
  (let [(val-1 (hash-ref table-1 key 0))
        (val-2 (hash-ref table-2 key 0)) ]
    (when (< val-1 val-2)
      (hash-set! table-1 key val-2))))

(define (calculate-powers game)
  (define cube-minimus (make-hash-table 3))
  (define (calculate-round-power rnd)
    (map (lambda (key)
           (hash-updater cube-minimus rnd key))
         '("red" "green" "blue")))
  (map calculate-round-power game)
  (hash-fold (lambda (k v prev)
               (* prev v))
             1 cube-minimus))

(define (proc-task-02b filename)
  (define games (map game-parser (reverse (slurp filename))))
  (define powers (map calculate-powers games))
  (apply + powers))

(if (= (proc-task-02b "tiny_input_02") 2286)
  (format #t "Task 02, part 2: ~a\n" (proc-task-02b "input_02"))
  (error "tiny-task-02b didn't pass sanity checks"))

#!/usr/bin/env ruby

require 'benchmark'
require 'minitest'
require 'pry-byebug'

TEST_STR = "\
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"

class Test < MiniTest::Test
  def test_p1
    assert_equal(8, compute_p1(TEST_STR))
  end

  def test_p2
    assert_equal(2286, compute_p2(TEST_STR))
  end
end

def parse_game(line)
  m = line.match(/Game (\d+): (.+;?)/)
  id = m[1].to_i
  draws = m[2]
            .split(";")
            .map { |cubes| cubes.split(",")
                        .map { |s| s.strip.split(" ") }}
            .map { |cubes|
              cubes.reduce({}) { |h,a| h[a[1].to_sym] = a[0].to_i; h }}
  {id: id, draws: draws}
end

def is_possible?(game, limits)
  game[:draws].each do |draw|
    return false unless draw.all? do |color, count|
      count <= limits[color]
    end
  end
  return true
end

def minimum_cubes_power(game)
  game[:draws].reduce(Hash.new(0)) { |maximums,draw|
    draw.each { |color, count|
      if maximums[color] < count
        maximums[color] = count
      end
    }
    maximums
  }.reduce(1) { |product,kv| kv.last * product }
end

def compute_p1(input)
  limits = {red: 12, green: 13, blue: 14}
  input
    .lines
    .map { |l| parse_game(l) }
    .filter { |g| is_possible?(g, limits) }
    .map { |g| g[:id] }
    .sum
end

def compute_p2(input)
  input.lines
    .map { |l| parse_game(l) }
    .map { |g| minimum_cubes_power(g) }
    .sum
end

if MiniTest.run
  puts 'Test case OK, running...'

  @input = File.read(ARGV[0] || 'input')
  do_p2 = defined?(compute_p2)

  Benchmark.bm do |bm|
    bm.report('Part 1:') { @p1 = compute_p1(@input) }
    bm.report('Part 2:') { @p2 = compute_p2(@input) } if do_p2
  end

  puts "\nResults:"
  puts 'Part 1: %i' % @p1
  puts 'Part 2: %i' % @p2 if do_p2

else
  puts 'Test case ERR'
end

use std::convert::TryFrom;

use crate::{load_input, Puzzle, Result};

fn first() -> Result<String> {
    let id_sum = load_input(2)?
        .lines()
        .map(Game::try_from)
        .filter(|game| game.as_ref().is_ok_and(|v| v.valid_for(12, 13, 14)))
        .try_fold(0, |acc, x| x.map(|game| acc + game.id))?
        .to_string();
    Ok(id_sum)
}

fn second() -> Result<String> {
    let power_sum = load_input(2)?
        .lines()
        .map(Game::try_from)
        .try_fold(0, |acc, x| x.map(|game| acc + game.power()))?
        .to_string();
    Ok(power_sum)
}

#[derive(Debug)]
struct Game {
    pub id: u32,
    pub red: u32,
    pub green: u32,
    pub blue: u32,
}

impl Game {
    fn valid_for(&self, r: u32, g: u32, b: u32) -> bool {
        self.red <= r && self.green <= g && self.blue <= b
    }

    fn power(&self) -> u32 {
        self.red * self.green * self.blue
    }
}

impl TryFrom<&str> for Game {
    type Error = Box<dyn std::error::Error>;
    fn try_from(value: &str) -> Result<Self> {
        use std::cmp::max;

        let (id, rounds) = value.split_once(':').ok_or(format!("No ':' in {value}"))?;
        let id = id
            .strip_prefix("Game ")
            .ok_or(format!("{id} doesn't start with 'Game '"))?
            .parse::<u32>()?;

        let (red, green, blue) = rounds
            .split(';')
            .map(|round| {
                let (mut r, mut g, mut b) = (0, 0, 0);
                for pull in round.split(',') {
                    let (count, color) = pull
                        .trim()
                        .split_once(' ')
                        .ok_or(format!("No ' ' in pull {pull}"))?;
                    let count = count.parse::<u32>()?;
                    match color {
                        "red" => r = count,
                        "green" => g = count,
                        "blue" => b = count,
                        x => Err(format!("Color {x} is invalid"))?,
                    };
                }
                Ok((r, g, b))
            })
            .try_fold((0, 0, 0), |a, x: Result<_>| {
                x.map(|x| (max(a.0, x.0), max(a.1, x.1), max(a.2, x.2)))
            })?;
        Ok(Self {
            id,
            red,
            green,
            blue,
        })
    }
}

#!/usr/bin/env pypy3

from collections import defaultdict

total = 0
constraints = {'red': 12, 'green': 13, 'blue': 14}
for i, line in enumerate(open(0), start=1):
    game = defaultdict(int)
    for handful in line.strip().split(':')[1].split(';'):
        for n, color in map(str.split, handful.split(',')):
            game[color] = max(game[color], int(n))
    if all(constraints[color] >= game[color] for color in constraints):
        total += i

print(total)

#!/usr/bin/env pypy3

from collections import defaultdict
from math import prod

total = 0
for i, line in enumerate(open(0), start=1):
    game = defaultdict(int)
    for handful in line.strip().split(':')[1].split(';'):
        for n, color in map(str.split, handful.split(',')):
            game[color] = max(game[color], int(n))
    total += prod(game.values())

print(total)

class Day2 {
    // Parse each line into a game and filter games where all bags are less than the limit. Then sum the game ids.
    fun part1(lines: List<String>) = let {
        val limit = mapOf("red" to 12, "green" to 13, "blue" to 14)
        fun isPossible(game: Game) = game.bags.all { bag -> bag.entries.all { (k, v) -> v <= limit[k]!! } }
        lines.map { parseGame(it) }.filter { isPossible(it) }.sumOf { it.id }
    }

    // Parse each line into a game and take the union of all bags in a game. Take the product of each bag's counts and
    // then sum the products.
    fun part2(lines: List<String>) = let {
        fun Map<String, Int>.union(that: Map<String, Int>) =
            (this.keys + that.keys).associateWith { (this[it] ?: 0).coerceAtLeast(that[it] ?: 0) }
        lines.sumOf {
            val game = parseGame(it)
            val bag = game.bags.reduce { prev, next -> prev.union(next) }
            val power = bag.values.reduce { prev, next -> prev * next }
            power
        }
    }

    data class Game(val id: Int, val bags: List<Map<String, Int>>)

    private fun parseGame(line: String) = let {
        fun parseBag(s: String) =
            Regex("""(\d+) (\w+)""").findAll(s).map { it.groupValues[2] to it.groupValues[1].toInt() }.toMap()

        fun parseBags(s: String) = s.split(";").map { parseBag(it) }
        Regex("""Game (\d+): (.*)""").find(line)!!.groupValues.let { Game(it[1].toInt(), parseBags(it[2])) }
    }

    val input = javaClass.getResourceAsStream("${javaClass.name}.txt")!!.reader().readLines()
}

fun main() {
    val example1 = """
        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
    """.trimIndent().lines()

    val example1Expected1 = 8
    val example2Expected2 = 2286
    val inputExpected1 = 2331
    val inputExpected2 = 71585

    val day = Day2()
    check(day.part1(example1) == example1Expected1)
    check(day.part2(example1) == example2Expected2)
    day.part1(day.input).also { println(it) }.also { check(it == inputExpected1) }
    day.part2(day.input).also { println(it) }.also { check(it == inputExpected2) }
}

package main

import (
	"aoc2023/internal/helpers"
	"fmt"
	"os"
	"strings"
)

func main() {

	d := &Day2{}

	err := helpers.Dispatch(os.Args, d)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(1)
	}

}

type ColorSet struct {
	Red   int
	Blue  int
	Green int
}

func (t ColorSet) IsPossible(red int, green int, blue int) bool {
	return t.Red <= red && t.Blue <= blue && t.Green <= green
}

func (t *ColorSet) Parse(input string) {
	colorTokens := strings.Split(input, ",")

	//assign colors for each token
	for _, token := range colorTokens {
		colorNum, colorLabel := helpers.ParseLabeledValue(strings.TrimSpace(token), true)
		if colorLabel == "red" {
			t.Red = colorNum
		} else if colorLabel == "blue" {
			t.Blue = colorNum
		} else if colorLabel == "green" {
			t.Green = colorNum
		} else {
			panic(fmt.Sprintf("Unrecognized color %s", colorLabel))
		}
	}
}

type Game struct {
	ID    int
	Tries []ColorSet
}

func (g Game) IsPossible(red int, green int, blue int) bool {
	for _, try := range g.Tries {
		if !try.IsPossible(red, green, blue) {
			return false
		}
	}
	return true
}

func (g Game) GetMinColorSet() ColorSet {
	minSet := ColorSet{
		Red:   0,
		Green: 0,
		Blue:  0,
	}

	//the minset is the smallest set of cubes that contains all the observed values, so we're actually
	//looking for the max of each value
	for _, try := range g.Tries {
		minSet.Red = max(try.Red, minSet.Red)
		minSet.Green = max(try.Green, minSet.Green)
		minSet.Blue = max(try.Blue, minSet.Blue)
	}

	return minSet
}

func (g *Game) Parse(input string) {
	gameTokens := strings.Split(input, ":")
	helpers.Assert(len(gameTokens) == 2, "token length != 2")

	//get the ID
	gameID, gameStr := helpers.ParseLabeledValue(strings.TrimSpace(gameTokens[0]), false)
	helpers.Assert(gameStr == "Game", "Expected Game label")
	g.ID = gameID

	//process the remainder as tries
	tryTokens := strings.Split(gameTokens[1], ";")
	for _, tryToken := range tryTokens {
		try := ColorSet{}
		try.Parse(tryToken)
		g.Tries = append(g.Tries, try)
	}
}

type Day2 struct {
}

func (d *Day2) Part1(filename string) error {

	lines := helpers.ReadFileToLines(filename)

	possibleRed := 12
	possibleGreen := 13
	possibleBlue := 14
	possibleSum := 0

	for _, line := range lines {
		game := Game{}
		game.Parse(line)
		fmt.Printf("%#v\n", game)

		if game.IsPossible(possibleRed, possibleGreen, possibleBlue) {
			possibleSum += game.ID
			fmt.Printf("  IS possible\n")
		} else {
			fmt.Printf("  NOT possible\n")
		}
	}

	fmt.Println("Possible sum is", possibleSum)

	return nil
}

func (d *Day2) Part2(filename string) error {

	lines := helpers.ReadFileToLines(filename)

	powerSum := 0

	for _, line := range lines {
		game := Game{}
		game.Parse(line)
		fmt.Printf("game %#v\n", game)

		minSet := game.GetMinColorSet()
		fmt.Printf("  minset %#v\n", minSet)

		power := minSet.Red * minSet.Blue * minSet.Green
		fmt.Printf("  power %d\n", power)

		powerSum += power
	}

	fmt.Println("Power sum is", powerSum)

	return nil
}

Plus the parsing helper function

package helpers

import (
	"fmt"
	"strconv"
	"strings"
)

// ParselabeledValue expects a string like "7 sheep" and returns 7 as an int and the string "sheep"
// if numberFirst is true, it processes the string like "7 sheep"
// if numberFirst is false, it processes the string liek "Game 12"
// if the string does not conform to the pattern, then it panics
func ParseLabeledValue(s string, numberFirst bool) (int, string) {
	tokens := strings.Split(s, " ")
	Assert(len(tokens) == 2, "token len != 2")

	numIndex := 0
	labelIndex := 1
	if !numberFirst {
		numIndex = 1
		labelIndex = 0
	}

	numVal, err := strconv.Atoi(tokens[numIndex])
	if err != nil {
		panic(fmt.Sprintf("number token '%s' is not an int: %s", tokens[numIndex], err))
	}

	return numVal, tokens[labelIndex]
}