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
    arrow-up
    10
    ·
    7 months 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
    arrow-up
    5
    ·
    7 months 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()
        }
    }
    
  • mykl@lemmy.world
    link
    fedilink
    arrow-up
    4
    ·
    7 months 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
    arrow-up
    4
    ·
    edit-2
    7 months 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

    • sjmulder@lemmy.sdf.org
      link
      fedilink
      arrow-up
      1
      ·
      7 months 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@programming.dev
        link
        fedilink
        arrow-up
        1
        ·
        7 months 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 🤔

  • Andy@programming.dev
    link
    fedilink
    arrow-up
    4
    ·
    edit-2
    6 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 .
    ;
    
  • Nighed@sffa.community
    link
    fedilink
    English
    arrow-up
    3
    ·
    edit-2
    7 months ago

    Done in C# Input parsing done with a mixture of splits and Regex (no idea why everyone hates it?) capture groups.

    I have overbuilt for both days, but not tripped on any of the ‘traps’ in the input data - generally expecting the input to be worse than it is… too used to actual data from users

    Input Parsing (common)

    public class Day2RoundInput { private Regex gameNumRegex = new Regex(“[a-z]* ([0-9]*)”, RegexOptions.IgnoreCase);

        public Day2RoundInput(string gameString)
        {
            var colonSplit = gameString.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries);
            var match = gameNumRegex.Match(colonSplit[0].Trim());
            var gameNumberString = match.Groups[1].Value;
            GameNumber = int.Parse(gameNumberString.Trim());
    
            HandfulsOfCubes = new List();
            var roundsSplit = colonSplit[1].Trim().Split(';', StringSplitOptions.RemoveEmptyEntries);
            foreach (var round in roundsSplit)
            {
                HandfulsOfCubes.Add(new HandfulCubes(round));
            }
        }
        public int GameNumber { get; set; }
    
        public List HandfulsOfCubes { get; set; }
    
        public class HandfulCubes
        {
            private Regex colourRegex = new Regex("([0-9]*) (red|green|blue)");
    
            public HandfulCubes(string roundString)
            {
                var colourCounts = roundString.Split(',', StringSplitOptions.RemoveEmptyEntries);
                foreach (var colour in colourCounts)
                {
                    var matches = colourRegex.Matches(colour.Trim());
    
                    foreach (Match match in matches)
                    {
                        var captureOne = match.Groups[1];
    
                        var count = int.Parse(captureOne.Value.Trim());
    
                        var captureTwo = match.Groups[2];
    
                        switch (captureTwo.Value.Trim().ToLower())
                        {
                            case "red":
                                RedCount = count;
                                break;
                            case "green":
                                GreenCount = count;
                                break;
                            case "blue":
                                BlueCount = count;
                                break;
                            default: throw new Exception("uh oh");
                        }
                    }
                }
            }
    
            public int RedCount { get; set; }
            public int GreenCount { get; set; }
            public int BlueCount { get; set; }
        }
    
    }
    
    Task1

    internal class Day2Task1:IRunnable { public void Run() { var inputs = GetInputs();

            var maxAllowedRed = 12;
            var maxAllowedGreen = 13;
            var maxAllowedBlue = 14;
    
            var allowedGameIdSum = 0;
    
            foreach ( var game in inputs ) { 
                var maxRed = game.HandfulsOfCubes.Select(h => h.RedCount).Max();
                var maxGreen = game.HandfulsOfCubes.Select(h => h.GreenCount).Max();
                var maxBlue = game.HandfulsOfCubes.Select(h => h.BlueCount).Max();
    
                if ( maxRed <= maxAllowedRed && maxGreen <= maxAllowedGreen && maxBlue <= maxAllowedBlue) 
                {
                    allowedGameIdSum += game.GameNumber;
                    Console.WriteLine("Game:" + game.GameNumber + " allowed");
                }
                else
                {
                    Console.WriteLine("Game:" + game.GameNumber + "not allowed");
                }
            }
    
            Console.WriteLine("Sum:" + allowedGameIdSum.ToString());
    
        }
    
        private List GetInputs()
        {
            List inputs = new List();
    
            var textLines = File.ReadAllLines("Days/Two/Day2Input.txt");
    
            foreach (var line in textLines)
            {
                inputs.Add(new Day2RoundInput(line));
            }
    
            return inputs;
        }
    
        
    }
    
    Task2

    internal class Day2Task2:IRunnable { public void Run() { var inputs = GetInputs();

            var result = 0;
    
            foreach ( var game in inputs ) {
                var maxRed = game.HandfulsOfCubes.Select(h => h.RedCount).Max();
                var maxGreen = game.HandfulsOfCubes.Select(h => h.GreenCount).Max();
                var maxBlue = game.HandfulsOfCubes.Select(h => h.BlueCount).Max();
    
                var power = maxRed*maxGreen*maxBlue;
                Console.WriteLine("Game:" + game.GameNumber + " Result:" + power.ToString());
    
                result += power;
            }
    
            Console.WriteLine("Day2 Task2 Result:" + result.ToString());
    
        }
    
        private List GetInputs()
        {
            List inputs = new List();
    
            var textLines = File.ReadAllLines("Days/Two/Day2Input.txt");
            //var textLines = File.ReadAllLines("Days/Two/Day2ExampleInput.txt");
    
            foreach (var line in textLines)
            {
                inputs.Add(new Day2RoundInput(line));
            }
    
            return inputs;
        }
    
        
    }
    
  • bugsmith@programming.dev
    link
    fedilink
    arrow-up
    3
    ·
    edit-2
    7 months ago

    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(())
    }
    
  • janAkali@lemmy.one
    link
    fedilink
    English
    arrow-up
    3
    ·
    edit-2
    7 months ago

    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}."
    
      • janAkali@lemmy.one
        link
        fedilink
        English
        arrow-up
        1
        ·
        7 months ago

        Have you joined the community?

        Yep, but it is a bit quiet in there.

        Good solution. I like your parsing with scanf. The only reason I didn’t use it myself - is that I found out about std/strscans literally yesterday.

        • cacheson@kbin.social
          link
          fedilink
          arrow-up
          2
          ·
          7 months ago

          I actually just learned about scanf while writing this. Only ended up using it in the one spot, since split worked well enough for the other bits. I really wanted to be able to use python-style unpacking, but in nim it only works for tuples. At least without writing macros, which I still haven’t been able to wrap my head around.

  • Ategon@programming.devOPM
    link
    fedilink
    arrow-up
    3
    ·
    edit-2
    7 months 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