axllind / adventofcode2022

Solutions to all 25 Advent of Code 2022 in Rust 🦀 Less than 100 lines per day, total runtime of less than 1 second.

Hi, I'm Axel! ✌️ I am

• MSc graduate of Computer Science from KTH, with a masters in Computer Security
• a software engineer focusing on security
• a big fan of Rust 🦀

Advent of Code 🎄

AdventOfCode is the world's largest programming competition, taking place every year during December. 🎄 Last year over 200k people participated. I am one of less than 400 people who have completed every single year, earning 350/350 ⭐

• 2023, in Rust. Here we go!
• 2022, in Rust. 25th place in the world on day 19!
• 2021, in Rust with competitive global leaderboard placings, with efficient and clean solutions.
• 2020, in Rust with high global leaderboard placings.
• 2019, fast solutions to all 25 problems in Rust.
• 2018, solutions to all 25 problems in type-annotated Python 3.10.
• 2017, solutions to all 25 problems in Haskell.
• 2016, solutions to all 25 problems in OCaml.
• 2015, solutions to all 25 problems in Clojure.

Some things I've done

• libwebb, a http webserver framework written from scratch in C! 🕸️
• tauri-pw-manager, a desktop password manager written in Rust/Typescript with Tauri! 🖥️
• cryptopals-rs, solutions to the famous cryptography challenges in Rust! 🔓
• AxOS, a work-in-progress operating system written in Rust 🦀
• wasm-sandbox-demo, an exploration into the security aspects of WebAssembly through tic-tac-toe 🕵️‍♀️
• mdtable-cli, a cli tool which makes creating markdown tables much easier 📊
• easy_io, a Rust library which makes IO in competetive programming a breeze 🏃‍♀️
• synacor_challenge, a solution to the Synacor challenge with a detailed write-up of the process 🍻
• Number-Recognition, a three-layer artificial neural network written from scratch in C++ 🤖
• Sense, a React app Chrome-extension which displays useful information on your new-tab page ⏱
• simple-slack-verification, a npm package for Slack signed secret authentication 🔐
• lc3-rs, a Little Computer 3 virtual machine 💻
• Strive, a Doodle-jump style mobile game made in Unity and C# 📱

adventofcode2022's Issues

How Does Day 16 Work?

I've been struggling to complete day 16, my part 1 runs but part 2 is just too slow, and I came across this repo while looking for ways to optimize my solution (thanks for making this repository public, BTW)! I've been looking over your solutions trying to understand them. It's mostly clear and concise, very well written, but I don't quite understand how your solution to Day 16 works. Link to Day 16 in case you need a refresher.

I'll copy and paste your solution below with comments that I've added which explain my thoughts

use hashbrown::HashMap;
use itertools::Itertools;

#[aoc::main(16)]
fn main(input: &str) -> (u16, u16) {
  // vec of valve tuples in descending order of flow
  let valves = input.lines()
    .map(|l| {
      let mut words = l.split(|c: char| !c.is_uppercase() && !c.is_ascii_digit()).filter(|w| !w.is_empty()).skip(1);
      let valve = words.next().unwrap();
      let flow = words.next().unwrap().parse::<u16>().unwrap();
      let tunnels = words.collect::<Vec<_>>();
      (valve, flow, tunnels)
    })
    .sorted_by_key(|(_, flow, _)| -(*flow as i32))
    .collect::<Vec<_>>();
  // map of labels to their index in the valves, flow, and adj vectors
  let labels = valves.iter().enumerate().map(|(i, v)| (v.0, i)).collect::<HashMap<_, _>>();
  let flow = valves.iter().map(|(_,flow,_)| *flow).collect::<Vec<_>>();
  // vec of available valves from each valve
  let adj = valves.iter().map(|(_, _, tunnels)| tunnels.iter().map(|t| labels[t]).collect::<Vec<_>>()).collect::<Vec<_>>();
  // index marking ending of all "interesting" valves
  let m = valves.iter().position(|(_, flow, _)| *flow == 0).unwrap();
  // 2^(interesting_valves.len()), number of possible configurations of "interesting" valves ??
  let mm = 1 << m;

  // opt[time][node][available valves]
  let mut opt = vec![vec![vec![0; mm]; valves.len()]; 30];
  for t in 1..30 { // iterate over time...
    for i in 0..valves.len() { // iterate over all valves
      let ii = 1 << i; // 2^i
      for x in 0..mm { // iterate over all possible valve configurations
        let mut tmp = opt[t][i][x]; // should always be 0
        if ii & x != 0 && t >= 2 { // if this valve should be "on" for this particular configuration
          // I don't understand what x - ii is, or why it's flow[i] * t... isn't that backwards if we are progressing forwards in time?
          // how does this take into account the "cost" to get to a new location?
          tmp = tmp.max(opt[t-1][i][x - ii] + flow[i] * t as u16);
        }
        // optimal for this iteration is max(this location, adjacent locations...)
        opt[t][i][x] = tmp.max(adj[i].iter().map(|&j| opt[t-1][j][x]).max().unwrap());
      }
    }
  }

  let start = labels["AA"];
  let p1 = opt[29][start][mm - 1]; // opt[t of interest][starting position][??]
  // ??
  let p2 = (0..mm/2).map(|x| opt[25][start][x] + opt[25][start][mm-1-x]).max().unwrap();
  (p1, p2)
}

I would really appreciate it if you'd take the time to explain this to me. Thank you.