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


🔒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

  • @sjmulder@lemmy.sdf.org
    link
    fedilink
    101 year ago

    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);}
    
  • @capitalpb@programming.dev
    link
    fedilink
    English
    51 year ago

    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()
        }
    }
    
    • @sjmulder@lemmy.sdf.org
      link
      fedilink
      11 year ago

      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.

      • snowe
        link
        fedilink
        11 year ago

        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 🤔

  • @mykl@lemmy.world
    link
    fedilink
    41 year ago

    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.
    /+/×⍉:
    
  • @pnutzh4x0r@lemmy.ndlug.org
    link
    fedilink
    English
    4
    edit-2
    1 year ago

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

    Part 1
    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)
    
    Part 2

    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)
    

    GitHub Repo

  • @Andy@programming.dev
    link
    fedilink
    4
    edit-2
    11 months ago

    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 .
    ;
    
  • AtegonOPM
    link
    fedilink
    3
    edit-2
    1 year ago

    Rust (Rank 7421/6311) (Time after start 00:32:27/00:35:35)

    Extremely easy part 2 today, I would say easier than part 1 but they share the same sort of framework

    Code Block

    (Note lemmy removed some characters, code link shows them all)

    use std::fs;
    
    fn part1(input: String) -> i32 {
        const RED: i32 = 12;
        const GREEN: i32 = 13;
        const BLUE: i32 = 14;
    
        let mut sum = 0;
    
        for line in input.lines() {
            let [id, content] = line.split(": ").collect::>()[0..2] else { continue };
            let id = id.split(" ").collect::>()[1].parse::().unwrap();
    
            let marbles = content.split("; ").map(|x| { x.split(", ").collect::>() }).collect::>>();
            let mut valid = true;
    
            for selection in marbles {
                for marble in selection {
                    let marble_split = marble.split(" ").collect::>();
                    let marble_amount = marble_split[0].parse::().unwrap();
                    let marble_color = marble_split[1];
    
                    if marble_color == "red" && marble_amount > RED {
                        valid = false;
                        break;
                    }
    
                    if marble_color == "green" && marble_amount > GREEN {
                        valid = false;
                        break;
                    }
    
                    if marble_color == "blue" && marble_amount > BLUE {
                        valid = false;
                        break;
                    }
                }
            }
    
            if !valid {
                continue;
            }
    
            sum += id;
        }
    
        return sum;
    }
    
    fn part2(input: String) -> i32 {
        let mut sum = 0;
    
        for line in input.lines() {
            let [id, content] = line.split(": ").collect::>()[0..2] else { continue };
            let id = id.split(" ").collect::>()[1].parse::().unwrap();
    
            let marbles = content.split("; ").map(|x| { x.split(", ").collect::>() }).collect::>>();
            
            let mut red = 0;
            let mut green = 0;
            let mut blue = 0;
    
            for selection in marbles {
                for marble in selection {
                    let marble_split = marble.split(" ").collect::>();
                    let marble_amount = marble_split[0].parse::().unwrap();
                    let marble_color = marble_split[1];
    
                    if marble_color == "red" && marble_amount > red {
                        red = marble_amount;
                    }
    
                    if marble_color == "green" && marble_amount > green {
                        green = marble_amount;
                    }
    
                    if marble_color == "blue" && marble_amount > blue {
                        blue = marble_amount;
                    }
                }
            }
    
            sum += red * green * blue;
        }
    
        return sum;
    }
    
    fn main() {
        let input = fs::read_to_string("data/input.txt").unwrap();
    
        println!("{}", part1(input.clone()));
        println!("{}", part2(input.clone()));
    }
    

    Code Link

  • @sjmulder@lemmy.sdf.org
    link
    fedilink
    3
    edit-2
    1 year ago

    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;
    }
    
  • @mykl@lemmy.world
    link
    fedilink
    3
    edit-2
    1 year ago

    Dart solution

    Quite straightforward, though there’s a sneaky trap in the test data for those of us who don’t read the rules carefully enough.

    Read, run and edit this solution in your browser: https://dartpad.dev/?id=203b3f0a9a1ad7a51daf14a1aeb6cf67

    parseLine(String s) {
      var game = s.split(': ');
      var num = int.parse(game.first.split(' ').last);
      var rounds = game.last.split('; ');
      var cubes = [
        for (var (e) in rounds)
          {
            for (var ee in e.split(', '))
              ee.split(' ').last: int.parse(ee.split(' ').first)
          }
      ];
      return MapEntry(num, cubes);
    }
    
    /// collects the max of the counts from both maps.
    Map merge2(Map a, Map b) => {
          for (var k in {...a.keys, ...b.keys}) k: max(a[k] ?? 0, b[k] ?? 0)
        };
    
    var limit = {"red": 12, "green": 13, "blue": 14};
    
    bool isGood(Map test) =>
        limit.entries.every((e) => (test[e.key] ?? 0) <= e.value);
    
    part1(List lines) => lines
        .map(parseLine)
        .where((e) => e.value.every(isGood))
        .map((e) => e.key)
        .sum;
    
    part2(List lines) => lines
        .map(parseLine)
        .map((e) => e.value.reduce(merge2))
        .map((e) => e.values.reduce((s, t) => s * t))
        .sum;
    
    • @sjmulder@lemmy.sdf.org
      link
      fedilink
      31 year ago

      Quite straightforward, though there’s a sneaky trap in the test data for those of us who don’t read the rules carefully enough.

      What’s that? I didn’t notice anything, perhaps I was lucky.

      • @mykl@lemmy.world
        link
        fedilink
        3
        edit-2
        1 year ago

        Oh, I misread the rules as each game having rounds of draws without replacement and the test data gave the same result for that reading, so when I confidently submitted my answer I got a bit of a surprise.

  • @meant2live218@lemmy.world
    link
    fedilink
    3
    edit-2
    1 year ago

    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).

    Part 1
    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))
    
    Part 2
    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))
    
  • @Jummit@lemmy.one
    link
    fedilink
    31 year ago

    Mostly an input parsing problem this time, but it was fun to use Hares tokenizer functions:

    lua
    -- SPDX-FileCopyrightText: 2023 Jummit
    --
    -- SPDX-License-Identifier: GPL-3.0-or-later
    
    local colors = {"blue", "red", "green"}
    local available = {red = 12, blue = 14, green = 13}
    local possible = 0
    local id = 0
    local min = 0
    
    for game in io.open("2.input"):lines() do
      id = id + 1
      game = game:gsub("Game %d+: ", "").."; "
      local max = {red = 0, blue = 0, green = 0}
      for show in game:gmatch(".-; ") do
        for _, color in ipairs(colors) do
          local num = tonumber(show:match("(%d+) "..color))
          if num then
            max[color] = math.max(max[color], num)
          end
        end
      end
      min = min + max.red * max.blue * max.green
      local thisPossible = true
      for _, color in ipairs(colors) do
        if max[color] > available[color] then
          thisPossible = false
          break
        end
      end
      if thisPossible then
        possible = possible + id
      end
    end
    
    print(possible)
    print(min)
    
    hare
    // SPDX-FileCopyrightText: 2023 Jummit
    //
    // SPDX-License-Identifier: GPL-3.0-or-later
    
    use strconv;
    use types;
    use strings;
    use io;
    use bufio;
    use os;
    use fmt;
    
    const available: []uint = [12, 13, 14];
    
    fn color_id(color: str) const uint = {
    	switch (color) {
    	case "red" => return 0;
    	case "green" => return 1;
    	case "blue" => return 2;
    	case => abort();
    	};
    };
    
    export fn main() void = {
    	const file = os::open("2.input")!;
    	defer io::close(file)!;
    	const scan = bufio::newscanner(file, types::SIZE_MAX);
    	let possible: uint = 0;
    	let min: uint = 0;
    
    	for (let id = 1u; true; id += 1) {
    		const line = match(bufio::scan_line(&scan)!) {
    		case io::EOF =>
    			break;
    		case let line: const str =>
    			yield strings::sub(
    					line,
    					strings::index(line, ": ") as size + 2,
    					strings::end);
    		};
    		let max: []uint = [0, 0, 0];
    		let tok = strings::rtokenize(line, "; ");
    		for (true) {
    			const show = match(strings::next_token(&tok)) {
    			case void =>
    				break;
    			case let show: str =>
    				yield show;
    			};
    			const pairs = strings::tokenize(show, ", ");
    			for (true) {
    				const pair: (str, str) = match(strings::next_token(&pairs)) {
    				case void =>
    					break;
    				case let pair: str =>
    					let tok = strings::tokenize(pair, " ");
    					yield (
    						strings::next_token(&tok) as str,
    						strings::next_token(&tok) as str
    					);
    				};
    				let color = color_id(pair.1);
    				let amount = strconv::stou(pair.0)!;
    				if (amount > max[color]) max[color] = amount;
    			};
    		};
    		if (max[0] <= available[0] && max[1] <= available[1] && max[2] <= available[2]) {
    			fmt::printfln("{}", id)!;
    			possible += id;
    		};
    		min += max[0] * max[1] * max[2];
    	};
    	
    	fmt::printfln("{}", possible)!;
    	fmt::printfln("{}", min)!;
    };
    
  • @Cyno@programming.dev
    link
    fedilink
    31 year ago

    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)