Day 2: Cube Conundrum
Megathread guidelines
- Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
- Code block support is not fully rolled out yet but likely will be in the middle of the event. Try to share solutions as both code blocks and using something such as https://topaz.github.io/paste/ or pastebin (code blocks to future proof it for when 0.19 comes out and since code blocks currently function in some apps and some instances as well if they are running a 0.19 beta)
FAQ
- What is this?: Here is a post with a large amount of details: https://programming.dev/post/6637268
- Where do I participate?: https://adventofcode.com/
- Is there a leaderboard for the community?: We have a programming.dev leaderboard with the info on how to join in this post: https://programming.dev/post/6631465
🔒This post will be unlocked when there is a decent amount of submissions on the leaderboard to avoid cheating for top spots
🔓 Edit: Post has been unlocked after 6 minutes
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);}
My solutions in C: https://git.sr.ht/~aidenisik/aoc23/tree/master/item/day2
Most of this is just reading the data, surely there's a better way to do this lol.
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() } }
Python
Questions and feedback welcome!
import collections from .solver import Solver class Day02(Solver): def __init__(self): super().__init__(2) self.games = [] def presolve(self, input: str): lines = input.rstrip().split('\n') for line in lines: draws = line.split(': ')[1].split('; ') draws = [draw.split(', ') for draw in draws] self.games.append(draws) def solve_first_star(self): game_id = 0 total = 0 for game in self.games: game_id += 1 is_good = True for draw in game: for item in draw: count, colour = item.split(' ') if (colour == 'red' and int(count) > 12 or # pylint: disable=too-many-boolean-expressions colour == 'blue' and int(count) > 14 or colour == 'green' and int(count) > 13): is_good = False if is_good: total += game_id return total def solve_second_star(self): total = 0 for game in self.games: minimums = collections.defaultdict(lambda: 0) for draw in game: for item in draw: count, colour = item.split(' ') minimums[colour] = max(minimums[colour], int(count)) power = minimums['red'] * minimums['blue'] * minimums['green'] total += power return total
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
That's a nice golf! Clever use of the hash and nice compact reduce. I got my C both-parts solution down to 210 but it's not half as nice.
Thanks! Your C solution includes main, whereas I do some stuff to parse the lines before hand. I think it would only be 1 extra character if I wrote it to parse the input manually, but I just care for ease of use with these AoC problems so I don't like counting that, makes it harder to read for me lol. Your solution is really inventive. I was looking for something like that, but didn't ever get to your conclusion. I wonder if that would be longer in my solution or shorter 🤔
String parsing! Always fun in C!
https://github.com/sjmulder/aoc/blob/master/2023/c/day02.c
int main(int argc, char **argv) { char ln[256], *sr,*srd,*s; int p1=0,p2=0, id, r,g,b; for (id=1; (sr = fgets(ln, sizeof(ln), stdin)); id++) { strsep(&sr, ":"); r = g = b = 0; while ((srd = strsep(&sr, ";"))) while ((s = strsep(&srd, ","))) if (strchr(s, 'd')) r = MAX(r, atoi(s)); else if (strchr(s, 'g')) g = MAX(g, atoi(s)); else if (strchr(s, 'b')) b = MAX(b, atoi(s)); p1 += (r <= 12 && g <= 13 && b <= 14) * id; p2 += r * g * b; } printf("%d %d\n", p1, p2); return 0; }
Python, interesting that the readMax function that I created on part 1 was also what I needed for part 2. https://github.com/massahud/advent-of-code-2023/blob/main/day02/day02.ipynb
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(()) }
[LANGUAGE: C#]
Part 1:
var list = new List((await File.ReadAllLinesAsync(@".\Day 2\PuzzleInput.txt"))); int conter = 0; foreach (var line in list) { string[] split = line.Split(":"); int game = Int32.Parse( split[0].Split(" ")[1]); string[] bagContents = split[1].Split(";"); var max = new Dictionary() { { "red", 0 }, { "green", 0 }, { "blue", 0 } }; foreach (var content in bagContents) { string pattern = @"(\d+) (\w+)"; MatchCollection matches = Regex.Matches(content, pattern); foreach (Match match in matches) { int number = Int32.Parse(match.Groups[1].Value); string color = match.Groups[2].Value; max[color] = (max[color] >= number)? max[color] : number; } } conter += (max["red"] <= 12 && max["green"] <= 13 && max["blue"] <= 14) ? game : 0; } Console.WriteLine(conter);
Part 2:
var list = new List((await File.ReadAllLinesAsync(@".\Day 2\PuzzleInput.txt"))); int conter = 0; foreach (var line in list) { string[] split = line.Split(":"); int game = Int32.Parse(split[0].Split(" ")[1]); string[] bagContents = split[1].Split(";"); var max = new Dictionary(); foreach (var content in bagContents) { string pattern = @"(\d+) (\w+)"; MatchCollection matches = Regex.Matches(content, pattern); foreach (Match match in matches) { int number = Int32.Parse(match.Groups[1].Value); string color = match.Groups[2].Value; if (!max.ContainsKey(color)) max[color] = number; else if(max[color] < number) max[color] = number; } } conter += max.Values.Aggregate(1, (total, value) => total * value ); } Console.WriteLine(conter);
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)
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
Spent most of the time running down annoying typos in the tokenizer.
I'm a bit late to the party for day 2. Here's my answer:
use std::rc::Rc; use crate::utils::read_lines; #[derive(Clone, Copy, PartialEq, Eq)] enum Cube { Red(usize), Green(usize), Blue(usize), } #[derive(Clone, Copy, PartialEq, Eq)] struct Bag { pub red: usize, pub green: usize, pub blue: usize, } fn parse_num<'a, I>(mut group: I) -> usize where I: Iterator, { group .next() .expect("Should be number") .parse::() .expect("Should be number") } fn process_lines() -> impl Iterator> { read_lines("src/day_2/input.txt") .expect("Could not read file") .map(|line| { let line = line.expect("Should be line"); (&line[(line.find(':').unwrap() + 1)..]) .split(';') .flat_map(|section| section.split(",")) .map(|group| { let mut group = group.trim().split(' '); match group.next_back().expect("Should be color") { "red" => Cube::Red(parse_num(group)), "green" => Cube::Green(parse_num(group)), "blue" => Cube::Blue(parse_num(group)), c @ _ => panic!("Color {c} not recognized"), } }) .collect::>() }) .into_iter() } pub fn solution_1() { let bag = Bag { red: 12, green: 13, blue: 14, }; let sum: usize = process_lines() .enumerate() .map(|(i, line)| { let is_possible = line.iter().all(|cube| match cube { Cube::Red(c) => *c <= bag.red, Cube::Green(c) => *c <= bag.green, Cube::Blue(c) => *c <= bag.blue, }); if is_possible { i + 1 } else { 0 } }) .sum(); println!("{sum}"); } pub fn solution_2() { let powersum: usize = process_lines() .map(|line| { let bag = line.iter().fold( Bag { red: 0, blue: 0, green: 0, }, |mut bag, cube| { match *cube { Cube::Red(n) => { if n > bag.red { bag.red = n; } } Cube::Green(n) => { if n > bag.green { bag.green = n; } } Cube::Blue(n) => { if n > bag.blue { bag.blue = n; } } } bag }, ); bag.red * bag.blue * bag.green }) .sum(); println!("{powersum}"); }
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 . ;