Found a C per-char solution, that is, no lines, splitting, lookahead, etc. It wasn’t even necessary to keep match lengths for the color names because they all have unique characters, e.g. ‘b’ only occurs in “blue” so then you can attribute the count to that color.

int main()
{
	int p1=0,p2=0, id=1,num=0, r=0,g=0,b=0, c;

	while ((c = getchar()) != EOF)
		if (c==',' || c==';' || c==':') num = 0; else
		if (c>='0' && c<='9') num = num*10 + c-'0'; else
		if (c=='d') r = MAX(r, num); else
		if (c=='g') g = MAX(g, num); else
		if (c=='b') b = MAX(b, num); else
		if (c=='\n') {
			p1 += (r<=12 && g<=13 && b<=14) * id;
			p2 += r*g*b;
			r=g=b=0; id++;
		}

	printf("%d %d\n", p1, p2);
	return 0;
}

Golfed:

c,p,P,i,n,r,g,b;main(){while(~
(c=getchar()))c==44|c==58|59==
c?n=0:c>47&c<58?n=n*10+c-48:98
==c?b=b>n?b:n:c=='d'?r=r>n?r:n
:c=='g'?g=g>n?g:n:10==c?p+=++i
*(r<13&g<14&b<15),P+=r*g*b,r=g
=b=0:0;printf("%d %d\n",p,P);}

Rust

Pretty straightforward this time, the bulk of the work was clearly in parsing the input.

Not too tricky today. Part 2 wasn’t as big of a curveball as yesterday thankfully. I don’t think it’s the cleanest code I’ve ever written, but hey - the whole point of this is to get better at Rust, so I’ll definitely be learning as I go, and coming back at the end to clean a lot of these up. I think for this one I’d like to look into a parsing crate like nom to clean up all the spliting and unwrapping in the two from() methods.

https://github.com/capitalpb/advent_of_code_2023/blob/main/src/solvers/day02.rs

#[derive(Debug)]
struct Hand {
    blue: usize,
    green: usize,
    red: usize,
}

impl Hand {
    fn from(input: &str) -> Hand {
        let mut hand = Hand {
            blue: 0,
            green: 0,
            red: 0,
        };

        for color in input.split(", ") {
            let color = color.split_once(' ').unwrap();
            match color.1 {
                "blue" => hand.blue = color.0.parse::().unwrap(),
                "green" => hand.green = color.0.parse::().unwrap(),
                "red" => hand.red = color.0.parse::().unwrap(),
                _ => unreachable!("malformed input"),
            }
        }

        hand
    }
}

#[derive(Debug)]
struct Game {
    id: usize,
    hands: Vec,
}

impl Game {
    fn from(input: &str) -> Game {
        let (id, hands) = input.split_once(": ").unwrap();
        let id = id.split_once(" ").unwrap().1.parse::().unwrap();
        let hands = hands.split("; ").map(Hand::from).collect();
        Game { id, hands }
    }
}

pub struct Day02;

impl Solver for Day02 {
    fn star_one(&self, input: &str) -> String {
        input
            .lines()
            .map(Game::from)
            .filter(|game| {
                game.hands
                    .iter()
                    .all(|hand| hand.blue <= 14 && hand.green <= 13 && hand.red <= 12)
            })
            .map(|game| game.id)
            .sum::()
            .to_string()
    }

    fn star_two(&self, input: &str) -> String {
        input
            .lines()
            .map(Game::from)
            .map(|game| {
                let max_blue = game.hands.iter().map(|hand| hand.blue).max().unwrap();
                let max_green = game.hands.iter().map(|hand| hand.green).max().unwrap();
                let max_red = game.hands.iter().map(|hand| hand.red).max().unwrap();

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

Factor on github (with comments and imports):

: known-color ( color-phrases regexp -- n )
  all-matching-subseqs [ 0 ] [
    [ split-words first string>number ] map-supremum
  ] if-empty
;

: line>known-rgb ( str -- game-id known-rgb )
  ": " split1 [ split-words last string>number ] dip
  R/ \d+ red/ R/ \d+ green/ R/ \d+ blue/
  [ known-color ] tri-curry@ tri 3array
;

: possible? ( known-rgb test-rgb -- ? )
  v<= [ ] all?
;

: part1 ( -- )
  "vocab:aoc-2023/day02/input.txt" utf8 file-lines
  [ line>known-rgb 2array ]
  [ last { 12 13 14 } possible? ] map-filter
  [ first ] map-sum .
;

: part2 ( -- )
  "vocab:aoc-2023/day02/input.txt" utf8 file-lines
  [ line>known-rgb nip product ] map-sum .
;

Ruby

https://github.com/snowe2010/advent-of-code/blob/master/ruby_aoc/2023/day02/day02.rb

Second part was soooo much easier today than yesterday. Helps I solved it exactly how he wanted you to solve it I think.

I’m going to work on some code golf now.

Golfed P2 down to 133 characters:

p g.map{_1.sub!(/.*:/,'')
m=Hash.new(0)
_1.split(?;){|r|r.split(?,){|a|b,c=a.split
m[c]=[m[c],b.to_i].max}}
m.values.reduce(&:*)}.sum

This was mostly straightforward… basically just parsing input. Here are my condensed solutions in Python

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)

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)

GitHub Repo

I had some time, so here’s a terrible solution in Uiua (Run it here) :

Lim ← [14 13 12]
{"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"}

LtoDec ← ∧(+ ×10:) :0
StoDec ← LtoDec▽≥0. ▽≤9. -@0
FilterMax! ← /↥≡(StoDec⊢↙ ¯1)⊔⊏⊚≡(/×^1⊢).⊔
# Build 'map' of draws for each game
∵(□≡(∵(⬚@\s↙2 ⊔) ⇌) ↯¯1_2 ↘ 2⊜□≠@\s . ⊔)
# Only need the max for each colour
≡(⊂⊂⊃⊃(FilterMax!(="bl")) (FilterMax!(="gr")) (FilterMax!(="re")))
# part 1 - Compare against limits, and sum game numbers
/+▽:+1⇡⧻. ≡(/×≤0-Lim).
# part 2 - Multiply the maxes in each game and then sum.
/+/×⍉:

C# - a tad bit overkill for this. I was worried that we’d need more statistical analysis in part 2, so I designed my solution around that. I ended up cutting everything back when Max() was enough for both parts.

https://github.com/warriordog/advent-of-code-2023/tree/main/Solutions/Day02

A solution in Nim language. Pretty straightforward code. Most logic is just parsing input + a bit of functional utils: allIt checks if all items in a list within limits to check if game is possible and mapIt collects red, green, blue cubes from each set of game.

https://codeberg.org/Archargelod/aoc23-nim/src/branch/master/day_02/solution.nim

import std/[strutils, strformat, sequtils]

type AOCSolution[T] = tuple[part1: T, part2: T]

type
  GameSet = object
    red, green, blue: int
  Game = object
    id: int
    sets: seq[GameSet]

const MaxSet = GameSet(red: 12, green: 13, blue: 14)

func parseGame(input: string): Game =
  result.id = input.split({':', ' '})[1].parseInt()
  let sets = input.split(": ")[1].split("; ").mapIt(it.split(", "))
  for gSet in sets:
    var gs = GameSet()
    for pair in gSet:
      let
        pair = pair.split()
        cCount = pair[0].parseInt
        cName = pair[1]

      case cName:
      of "red":
        gs.red = cCount
      of "green":
        gs.green = cCount
      of "blue":
        gs.blue = cCount

    result.sets.add gs

func isPossible(g: Game): bool =
  g.sets.allIt(
    it.red <= MaxSet.red and
    it.green <= MaxSet.green and
    it.blue <= MaxSet.blue
  )


func solve(lines: seq[string]): AOCSolution[int]=
  for line in lines:
    let game = line.parseGame()

    block p1:
      if game.isPossible():
        result.part1 += game.id

    block p2:
      let
        minRed = game.sets.mapIt(it.red).max()
        minGreen = game.sets.mapIt(it.green).max()
        minBlue = game.sets.mapIt(it.blue).max()

      result.part2 += minRed * minGreen * minBlue


when isMainModule:
  let input = readFile("./input.txt").strip()
  let (part1, part2) = solve(input.splitLines())

  echo &"Part 1: The sum of valid game IDs equals {part1}."
  echo &"Part 2: The sum of the sets' powers equals {part2}."

Late as always, as I’m on UK time and can’t work on these until late evening.

Part 01 and Part 02 in Rust 🦀 :

use std::{
    env, fs,
    io::{self, BufRead, BufReader},
};

#[derive(Debug)]
struct Sample {
    r: u32,
    g: u32,
    b: u32,
}

fn split_cube_set(set: &[&str], colour: &str) -> Option {
    match set.iter().find(|x| x.ends_with(colour)) {
        Some(item) => item
            .trim()
            .split(' ')
            .next()
            .expect("Found item is present")
            .parse::()
            .ok(),
        None => None,
    }
}

fn main() -> io::Result<()> {
    let args: Vec = env::args().collect();
    let filename = &args[1];
    let file = fs::File::open(filename)?;
    let reader = BufReader::new(file);
    let mut valid_game_ids_sum = 0;
    let mut game_power_sum = 0;
    let max_r = 12;
    let max_g = 13;
    let max_b = 14;
    for line_result in reader.lines() {
        let mut valid_game = true;
        let line = line_result.unwrap();
        let line_split: Vec<_> = line.split(':').collect();
        let game_id = line_split[0]
            .split(' ')
            .collect::>()
            .last()
            .expect("item exists")
            .parse::()
            .expect("is a number");
        let rest = line_split[1];
        let cube_sets = rest.split(';');
        let samples: Vec = cube_sets
            .map(|set| {
                let set_split: Vec<_> = set.split(',').collect();
                let r = split_cube_set(&set_split, "red").unwrap_or(0);
                let g = split_cube_set(&set_split, "green").unwrap_or(0);
                let b = split_cube_set(&set_split, "blue").unwrap_or(0);
                Sample { r, g, b }
            })
            .collect();
        let mut highest_r = 0;
        let mut highest_g = 0;
        let mut highest_b = 0;
        for sample in &samples {
            if !(sample.r <= max_r && sample.g <= max_g && sample.b <= max_b) {
                valid_game = false;
            }
            highest_r = u32::max(highest_r, sample.r);
            highest_g = u32::max(highest_g, sample.g);
            highest_b = u32::max(highest_b, sample.b);
        }
        if valid_game {
            valid_game_ids_sum += game_id;
        }
        game_power_sum += highest_r * highest_g * highest_b;
    }
    println!("Sum of game ids: {valid_game_ids_sum}");
    println!("Sum of game powers: {game_power_sum}");
    Ok(())
}

Today in Zig

Spent most of the time running down annoying typos in the tokenizer.

Did mine in Odin. Found this day’s to be super easy, most of the challenge was just parsing.

package day2

import "core:fmt"
import "core:strings"
import "core:strconv"
import "core:unicode"

Round :: struct {
    red: int,
    green: int,
    blue: int,
}

parse_round :: proc(s: string) -> Round {
    ret: Round

    rest := s
    for {
        nextNumAt := strings.index_proc(rest, unicode.is_digit)
        if nextNumAt == -1 do break
        rest = rest[nextNumAt:]

        numlen: int
        num, ok := strconv.parse_int(rest, 10, &numlen)
        rest = rest[numlen+len(" "):]

        if rest[:3] == "red" {
            ret.red = num
        } else if rest[:4] == "blue" {
            ret.blue = num
        } else if rest[:5] == "green" {
            ret.green = num
        }
    }

    return ret
}

Game :: struct {
    id: int,
    rounds: [dynamic]Round,
}

parse_game :: proc(s: string) -> Game {
    ret: Game

    rest := s[len("Game "):]

    idOk: bool
    idLen: int
    ret.id, idOk = strconv.parse_int(rest, 10, &idLen)
    rest = rest[idLen+len(": "):]

    for len(rest) > 0 {
        endOfRound := strings.index_rune(rest, ';')
        if endOfRound == -1 do endOfRound = len(rest)

        append(&ret.rounds, parse_round(rest[:endOfRound]))
        rest = rest[min(endOfRound+1, len(rest)):]
    }

    return ret
}

is_game_possible :: proc(game: Game) -> bool {
    for round in game.rounds {
        if round.red   > 12 ||
           round.green > 13 ||
           round.blue  > 14 {
            return false
        }
    }
    return true
}

p1 :: proc(input: []string) {
    totalIds := 0

    for line in input {
        game := parse_game(line)
        defer delete(game.rounds)

        if is_game_possible(game) do totalIds += game.id
    }

    fmt.println(totalIds)
}

p2 :: proc(input: []string) {
    totalPower := 0

    for line in input {
        game := parse_game(line)
        defer delete(game.rounds)

        minRed   := 0
        minGreen := 0
        minBlue  := 0
        for round in game.rounds {
            minRed   = max(minRed  , round.red  )
            minGreen = max(minGreen, round.green)
            minBlue  = max(minBlue , round.blue )
        }

        totalPower += minRed * minGreen * minBlue
    }

    fmt.println(totalPower)
}

Getting my head around parsing tricks for python, maybe abusing dicts as a replacement for a types, but appears to be working: https://gist.github.com/purplemonkeymad/983eec7ff0629e8834163b17ec673958

Was pretty simple in Python with a regex to get the game number, and then the count of color. for part 2 instead of returning true/false whether the game is valid, you just max the count per color. No traps like in the first one, that I’ve seen, so it was surprisingly easy

def process_game(line: str):
    game_id = int(re.findall(r'game (\d+)*', line)[0])

    colon_idx = line.index(":")
    draws = line[colon_idx+1:].split(";")
    # print(draws)
    
    if is_game_valid(draws):
        # print("Game %d is possible"%game_id)
        return game_id
    return 0

            
def is_game_valid(draws: list):
    for draw in draws:
        red = get_nr_of_in_draw(draw, 'red')
        if red > MAX_RED:
            return False
        
        green = get_nr_of_in_draw(draw, 'green')
        if green > MAX_GREEN:
            return False
        
        blue = get_nr_of_in_draw(draw, 'blue')
        if blue > MAX_BLUE:
            return False    
    return True
        
            
def get_nr_of_in_draw(draw: str, color: str):
    if color in draw:
        nr = re.findall(r'(\d+) '+color, draw)
        return int(nr[0])
    return 0


# f = open("input.txt", "r")
f = open("input_real.txt", "r")
lines = f.readlines()
sum = 0
for line in lines:
    sum += process_game(line.strip().lower())
print("Answer: %d"%sum)

My (awful) Python solves. Much easier than day 1’s, although I did run into an issue with trimming whitespace characters with my approach (Game 96 wouldn’t flag properly).

with open('02A_input.txt', 'r') as file:
    data = file.readlines()
    
possibleGames=[]

for game in data:
    # Find Game number
    game = game.removeprefix("Game ")
    gameNumber = int(game[0:game.find(":")])
    # Break Game into rounds (split using semicolons)
    game=game[game.find(":")+1:]
    rounds=game.split(";")
    # For each round, determine the maximum number of Red, Blue, Green items shown at a time
    rgb=[0,0,0]
    for round in rounds:
        combos=round.split(",")
        for combo in combos:
            combo=combo.strip()
            number=int(combo[0:combo.find(" ")])
            if combo.endswith("red"):
                if number>rgb[0]:
                    rgb[0]=number
            elif combo.endswith("green"):
                if number>rgb[1]:
                    rgb[1]=number
            elif combo.endswith("blue"):
                if number>rgb[2]:
                    rgb[2]=number
    # If Red>12, Green>13, Blue>14, append Game number to possibleGames
    if not (rgb[0]>12 or rgb[1]>13 or rgb[2]>14):
        possibleGames.append(gameNumber)

print(sum(possibleGames))

with open('02A_input.txt', 'r') as file:
    data = file.readlines()
    
powers=[]

for game in data:
    # Find Game number
    game = game.removeprefix("Game ")
    # Break Game into rounds (split using semicolons)
    game=game[game.find(":")+1:]
    rounds=game.split(";")
    # For each round, determine the maximum number of Red, Blue, Green items shown at a time
    # Note: This could be faster, since we don't need to worry about actual rounds
    rgb=[0,0,0]
    for round in rounds:
        combos=round.split(",")
        for combo in combos:
            combo=combo.strip()
            number=int(combo[0:combo.find(" ")])
            if combo.endswith("red"):
                if number>rgb[0]:
                    rgb[0]=number
            elif combo.endswith("green"):
                if number>rgb[1]:
                    rgb[1]=number
            elif combo.endswith("blue"):
                if number>rgb[2]:
                    rgb[2]=number
    # Multiple R, G, B to find the "power" of the game
    # Append Power to the list
    powers.append(rgb[0]*rgb[1]*rgb[2])
    
print(sum(powers))