Stefan Bühler
1 year ago
11 changed files with 651 additions and 0 deletions
Split View
Diff Options
-
+43 -0Cargo.lock
-
+3 -0Cargo.toml
-
+10 -0day12/Cargo.toml
-
+4 -0day12/src/input.txt
-
+166 -0day12/src/main.rs
-
+10 -0day13/Cargo.toml
-
+1 -0day13/src/input.txt
-
+147 -0day13/src/main.rs
-
+9 -0day14/Cargo.toml
-
+63 -0day14/src/input.txt
-
+195 -0day14/src/main.rs
+ 43
- 0
Cargo.lock
View File
+ 3
- 0
Cargo.toml
View File
+ 10
- 0
day12/Cargo.toml
View File
| @ -0,0 +1,10 @@ | |||
| [package] | |||
| name = "day12" | |||
| version = "0.1.0" | |||
| authors = ["Stefan Bühler <stbuehler@web.de>"] | |||
| edition = "2018" | |||
| # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html | |||
| [dependencies] | |||
| num-integer = "0.1.41" | |||
+ 4
- 0
day12/src/input.txt
View File
| @ -0,0 +1,4 @@ | |||
| <x=-2, y=9, z=-5> | |||
| <x=16, y=19, z=9> | |||
| <x=0, y=3, z=6> | |||
| <x=11, y=0, z=11> | |||
+ 166
- 0
day12/src/main.rs
View File
| @ -0,0 +1,166 @@ | |||
| fn strip_prefix<'a>(prefix: &str, input: &'a str) -> &'a str { | |||
| assert!(input.starts_with(prefix)); | |||
| &input[prefix.len()..] | |||
| } | |||
| fn strip_suffix<'a>(suffix: &str, input: &'a str) -> &'a str { | |||
| assert!(input.ends_with(suffix)); | |||
| &input[..input.len() - suffix.len()] | |||
| } | |||
| #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)] | |||
| pub struct Position { | |||
| pub x: i32, | |||
| pub y: i32, | |||
| pub z: i32, | |||
| } | |||
| impl Position { | |||
| pub fn parse(input: &str) -> Self { | |||
| let input = strip_suffix(">", strip_prefix("<", input.trim())); | |||
| let mut parts = input.split(","); | |||
| let x = strip_prefix("x=", parts.next().expect("need x component").trim()).parse().unwrap(); | |||
| let y = strip_prefix("y=", parts.next().expect("need y component").trim()).parse().unwrap(); | |||
| let z = strip_prefix("z=", parts.next().expect("need z component").trim()).parse().unwrap(); | |||
| assert!(parts.next().is_none(), "unexpected data"); | |||
| Position { x, y, z } | |||
| } | |||
| pub fn potential_energy(self) -> u32 { | |||
| self.x.abs() as u32 + self.y.abs() as u32 + self.z.abs() as u32 | |||
| } | |||
| } | |||
| #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)] | |||
| pub struct Velocity { | |||
| pub dx: i32, | |||
| pub dy: i32, | |||
| pub dz: i32, | |||
| } | |||
| impl Velocity { | |||
| pub fn kinetic_energy(self) -> u32 { | |||
| self.dx.abs() as u32 + self.dy.abs() as u32 + self.dz.abs() as u32 | |||
| } | |||
| } | |||
| impl std::ops::AddAssign<Velocity> for Position { | |||
| fn add_assign(&mut self, rhs: Velocity) { | |||
| self.x += rhs.dx; | |||
| self.y += rhs.dy; | |||
| self.z += rhs.dz; | |||
| } | |||
| } | |||
| fn parse_moons(input: &str) -> Vec<(Position, Velocity)> { | |||
| input.lines().map(Position::parse).map(|p| (p, Velocity::default())).collect() | |||
| } | |||
| fn step(moons: &mut [(Position, Velocity)]) { | |||
| for i in 0..moons.len() - 1 { | |||
| // change velocity based on "gravity" | |||
| for j in i + 1..moons.len() { | |||
| let dx = (moons[j].0.x - moons[i].0.x).signum(); | |||
| moons[i].1.dx += dx; moons[j].1.dx -= dx; | |||
| let dy = (moons[j].0.y - moons[i].0.y).signum(); | |||
| moons[i].1.dy += dy; moons[j].1.dy -= dy; | |||
| let dz = (moons[j].0.z - moons[i].0.z).signum(); | |||
| moons[i].1.dz += dz; moons[j].1.dz -= dz; | |||
| } | |||
| } | |||
| for moon in moons { | |||
| moon.0 += moon.1; | |||
| } | |||
| } | |||
| fn energy(moons: &[(Position, Velocity)]) -> u32 { | |||
| moons.iter().map(|(p, v)| p.potential_energy() * v.kinetic_energy()).sum() | |||
| } | |||
| fn energy_after_steps(mut moons: Vec<(Position, Velocity)>, steps: u32) -> u32 { | |||
| for _ in 0..steps { | |||
| step(&mut moons); | |||
| } | |||
| energy(&moons) | |||
| } | |||
| type ExtractedAxis = Vec<(i32, i32)>; | |||
| fn extract_x(moons: &[(Position, Velocity)]) -> ExtractedAxis { | |||
| moons.iter().map(|(p, v)| (p.x, v.dx)).collect() | |||
| } | |||
| fn extract_y(moons: &[(Position, Velocity)]) -> ExtractedAxis { | |||
| moons.iter().map(|(p, v)| (p.y, v.dy)).collect() | |||
| } | |||
| fn extract_z(moons: &[(Position, Velocity)]) -> ExtractedAxis { | |||
| moons.iter().map(|(p, v)| (p.z, v.dz)).collect() | |||
| } | |||
| fn repeats_after_steps(mut moons: Vec<(Position, Velocity)>) -> u64 { | |||
| // as `step` is reversible the first repeated state will always be the initial state | |||
| // find cycle per axis | |||
| let mut result_x = None; | |||
| let initial_x = extract_x(&moons); | |||
| let mut result_y = None; | |||
| let initial_y = extract_y(&moons); | |||
| let mut result_z = None; | |||
| let initial_z = extract_z(&moons); | |||
| for current in 1u64.. { | |||
| step(&mut moons); | |||
| if result_x.is_none() && initial_x == extract_x(&moons) { | |||
| result_x = Some(current); | |||
| } | |||
| if result_y.is_none() && initial_y == extract_y(&moons) { | |||
| result_y = Some(current); | |||
| } | |||
| if result_z.is_none() && initial_z == extract_z(&moons) { | |||
| result_z = Some(current); | |||
| } | |||
| if let (Some(x), Some(y), Some(z)) = (result_x, result_y, result_z) { | |||
| return num_integer::lcm(num_integer::lcm(x, y), z); | |||
| } | |||
| } | |||
| unreachable!() | |||
| } | |||
| fn main() { | |||
| let moons = parse_moons(include_str!("input.txt")); | |||
| let energy = energy_after_steps(moons.clone(), 1000); | |||
| println!("Energy after 1000 steps: {}", energy); | |||
| println!("Repeats initial state after {} steps", repeats_after_steps(moons)); | |||
| } | |||
| #[cfg(test)] | |||
| mod day12test { | |||
| use super::*; | |||
| #[test] | |||
| fn examples1() { | |||
| assert_eq!(179, energy_after_steps(parse_moons( | |||
| "<x=-1, y=0, z=2> | |||
| <x=2, y=-10, z=-7> | |||
| <x=4, y=-8, z=8> | |||
| <x=3, y=5, z=-1>"), 10)); | |||
| assert_eq!(1940, energy_after_steps(parse_moons( | |||
| "<x=-8, y=-10, z=0> | |||
| <x=5, y=5, z=10> | |||
| <x=2, y=-7, z=3> | |||
| <x=9, y=-8, z=-3> | |||
| "), 100)); | |||
| } | |||
| #[test] | |||
| fn examples2() { | |||
| assert_eq!(2772, repeats_after_steps(parse_moons( | |||
| "<x=-1, y=0, z=2> | |||
| <x=2, y=-10, z=-7> | |||
| <x=4, y=-8, z=8> | |||
| <x=3, y=5, z=-1>"))); | |||
| assert_eq!(4686774924, repeats_after_steps(parse_moons( | |||
| "<x=-8, y=-10, z=0> | |||
| <x=5, y=5, z=10> | |||
| <x=2, y=-7, z=3> | |||
| <x=9, y=-8, z=-3>"))); | |||
| } | |||
| } | |||
+ 10
- 0
day13/Cargo.toml
View File
| @ -0,0 +1,10 @@ | |||
| [package] | |||
| name = "day13" | |||
| version = "0.1.0" | |||
| authors = ["Stefan Bühler <stbuehler@web.de>"] | |||
| edition = "2018" | |||
| # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html | |||
| [dependencies] | |||
| shared = { path = "../shared" } | |||
+ 1
- 0
day13/src/input.txt
File diff suppressed because it is too large
View File
+ 147
- 0
day13/src/main.rs
View File
| @ -0,0 +1,147 @@ | |||
| use shared::intcode::{IntCode, SimulateStep, CELL}; | |||
| use std::collections::HashSet; | |||
| #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] | |||
| pub enum Tile { | |||
| Empty, | |||
| Wall, | |||
| Block, | |||
| HorizontalPaddle, | |||
| Ball, | |||
| } | |||
| impl Tile { | |||
| pub fn new(t: CELL) -> Self { | |||
| match t { | |||
| 0 => Self::Empty, | |||
| 1 => Self::Wall, | |||
| 2 => Self::Block, | |||
| 3 => Self::HorizontalPaddle, | |||
| 4 => Self::Ball, | |||
| _ => panic!("Unknown tile {}", t), | |||
| } | |||
| } | |||
| } | |||
| #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] | |||
| pub struct Position { | |||
| pub x: CELL, | |||
| pub y: CELL, | |||
| } | |||
| #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] | |||
| pub enum Update { | |||
| Tile { | |||
| position: Position, | |||
| tile: Tile, | |||
| }, | |||
| Score { | |||
| score: CELL, | |||
| }, | |||
| } | |||
| #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] | |||
| #[repr(i8)] | |||
| pub enum Joystick { | |||
| Left = -1, | |||
| Neutral = 0, | |||
| Right = 1, | |||
| } | |||
| fn view_game(mut ic: IntCode) -> impl Iterator<Item=(Position, Tile)> { | |||
| std::iter::from_fn(move || { | |||
| let x = match ic.simulate_step() { | |||
| SimulateStep::Finished => return None, | |||
| SimulateStep::WaitForInput => panic!("no input for game"), | |||
| SimulateStep::Output(n) => n, | |||
| }; | |||
| let y = ic.simulate_step().expect_output(); | |||
| let p = Position { x, y }; | |||
| let tile = Tile::new(ic.simulate_step().expect_output()); | |||
| Some((p, tile)) | |||
| }) | |||
| } | |||
| fn find_blocks<I>(tiles: I) -> HashSet<Position> | |||
| where | |||
| I: Iterator<Item=(Position, Tile)>, | |||
| { | |||
| let mut blocks = HashSet::new(); | |||
| for (pos, tile) in tiles { | |||
| match tile { | |||
| Tile::Block => { blocks.insert(pos); } | |||
| _ => { blocks.remove(&pos); } | |||
| } | |||
| } | |||
| blocks | |||
| } | |||
| fn get_update(ic: &mut IntCode, joystick: Joystick) -> Option<Update> { | |||
| let joystick = joystick as i8 as CELL; | |||
| ic.next_input = Some(joystick); | |||
| let x = match ic.simulate_step() { | |||
| SimulateStep::Finished => { | |||
| ic.next_input = None; | |||
| return None; | |||
| }, | |||
| SimulateStep::WaitForInput => panic!("no input for game"), | |||
| SimulateStep::Output(n) => n, | |||
| }; | |||
| let y = ic.simulate_step().expect_output(); | |||
| if x == -1 && y == 0 { | |||
| Some(Update::Score { score: ic.simulate_step().expect_output() }) | |||
| } else { | |||
| let position = Position { x, y }; | |||
| let tile = Tile::new(ic.simulate_step().expect_output()); | |||
| Some(Update::Tile { position, tile }) | |||
| } | |||
| } | |||
| fn break_all_blocks(mut ic: IntCode) -> CELL { | |||
| ic.data[0] = 2; // "play for free" | |||
| let mut last_score = None; | |||
| let mut last_paddle = None; | |||
| let mut last_ball = None; | |||
| let mut blocks = HashSet::new(); | |||
| let mut had_blocks = false; | |||
| let mut joystick = Joystick::Neutral; | |||
| while let Some(update) = get_update(&mut ic, joystick) { | |||
| match update { | |||
| Update::Score { score } => last_score = Some(score), | |||
| Update::Tile { position, tile } => { | |||
| blocks.remove(&position); | |||
| match tile { | |||
| Tile::Empty => (), | |||
| Tile::Wall => (), | |||
| Tile::Block => { blocks.insert(position); had_blocks = true; }, | |||
| Tile::HorizontalPaddle => last_paddle = Some(position), | |||
| Tile::Ball => last_ball = Some(position), | |||
| } | |||
| } | |||
| } | |||
| if let (Some(paddle), Some(ball)) = (&last_paddle, &last_ball) { | |||
| let diff_x = ball.x - paddle.x; | |||
| joystick = if diff_x > 0 { | |||
| Joystick::Right | |||
| } else if diff_x < 0 { | |||
| Joystick::Left | |||
| } else { | |||
| Joystick::Neutral | |||
| }; | |||
| } | |||
| } | |||
| if had_blocks && blocks.is_empty() { | |||
| println!("Won game, all blocks destroyed"); | |||
| } else { | |||
| println!("Lost game"); | |||
| } | |||
| last_score.expect("no score written") | |||
| } | |||
| fn main() { | |||
| let ic = include_str!("input.txt").parse::<IntCode>().unwrap(); | |||
| let blocks = find_blocks(view_game(ic.clone())); | |||
| println!("Number of blocks: {}", blocks.len()); | |||
| let score = break_all_blocks(ic); | |||
| println!("Score: {}", score); | |||
| } | |||
+ 9
- 0
day14/Cargo.toml
View File
| @ -0,0 +1,9 @@ | |||
| [package] | |||
| name = "day14" | |||
| version = "0.1.0" | |||
| authors = ["Stefan Bühler <stbuehler@web.de>"] | |||
| edition = "2018" | |||
| # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html | |||
| [dependencies] | |||
+ 63
- 0
day14/src/input.txt
View File
| @ -0,0 +1,63 @@ | |||
| 12 VJWQR, 1 QTBC => 6 BGXJV | |||
| 12 BGTMN, 2 DRKQR => 2 TVSF | |||
| 2 FTFK => 2 THNDN | |||
| 13 LKRTN, 7 MDPN, 12 NZKQZ => 5 LPWPD | |||
| 1 HDKX, 3 DWZS, 1 RCBQS => 1 DCRK | |||
| 14 ZCMF => 6 ZKHLC | |||
| 3 ZFVH, 2 ZCMF, 1 SCJG, 1 LQWJ, 4 BGBJ, 1 NHPR, 3 VKZFJ, 7 FWFXZ => 4 QVJMP | |||
| 11 TNMLB => 7 NVDCR | |||
| 1 LPWPD, 1 BGBJ => 2 SCJG | |||
| 3 DFCVF, 1 QGSN => 6 PQXG | |||
| 1 BGXJV, 1 THNDN => 4 BCQN | |||
| 3 LKRTN => 9 MDPN | |||
| 2 THNDN, 13 RCKZ, 10 FQSLN => 8 VKZFJ | |||
| 4 LBCZ, 9 LWHS => 1 FQSLN | |||
| 6 WSRVZ => 9 TNMLB | |||
| 8 FQSLN, 14 JQRF, 4 BGTMN => 5 QGSN | |||
| 4 ZCMF, 4 PLSM, 2 ZHTX => 8 TDHPM | |||
| 2 RSKC, 10 SHBC, 8 MDPN => 6 FMSZ | |||
| 2 VJWQR => 2 FPTV | |||
| 12 DRKQR => 6 NHPR | |||
| 35 QJLF, 22 BGTMN, 11 VJWTR, 1 QVJMP, 8 LQWJ, 1 TWLC, 16 NXZCH, 18 THKF, 42 JBLM => 1 FUEL | |||
| 2 BGTMN, 4 XJKN => 8 ZCMF | |||
| 4 TVSF => 3 RSKC | |||
| 7 HRWS, 1 TVSF => 3 ZHTX | |||
| 134 ORE => 4 WSRVZ | |||
| 1 VKZFJ, 1 TWLC, 4 ZHTX, 5 THNDN, 12 PLVN, 1 ZFXNP, 1 PQXG, 6 CWHV => 7 VJWTR | |||
| 20 XJKN, 1 LCKW, 3 NZKQZ => 7 HDKX | |||
| 1 LPWPD => 8 RCKZ | |||
| 4 RCBQS, 1 NVDCR => 5 BGBJ | |||
| 8 BGXJV => 4 BGTMN | |||
| 13 QBDX, 16 BGXJV => 6 NZKQZ | |||
| 2 LPWPD => 3 DRKQR | |||
| 4 QBDX => 7 XJKN | |||
| 12 LCKW, 9 NVDCR => 3 RCBQS | |||
| 142 ORE => 3 QBDX | |||
| 1 WXHJF => 1 XKDJ | |||
| 2 RSKC => 2 CWHV | |||
| 2 ZHTX, 1 ZFXNP => 6 JQRF | |||
| 1 FTFK, 1 TVSF, 1 QBDX => 2 JBLM | |||
| 1 TDHPM, 14 NHPR, 3 QPSF => 5 ZFVH | |||
| 3 GDTPC, 1 ZKHLC => 8 ZFXNP | |||
| 5 DWZS => 3 LQWJ | |||
| 1 FTFK, 4 LBCZ, 13 NHPR => 1 FWFXZ | |||
| 1 RCBQS, 12 SHBC => 9 FTFK | |||
| 1 WSRVZ, 1 XKDJ => 5 LKRTN | |||
| 2 BGTMN, 1 MDPN => 5 PLSM | |||
| 2 BGXJV, 17 XKDJ, 4 FPTV => 9 LCKW | |||
| 148 ORE => 2 QTBC | |||
| 110 ORE => 2 VJWQR | |||
| 42 ZFXNP, 15 RCKZ, 8 GDTPC => 3 QJLF | |||
| 13 HRWS => 4 GDTPC | |||
| 34 HRWS => 4 DFCVF | |||
| 2 VKZFJ, 2 NHPR, 16 PLVN, 1 QPSF, 13 LBCZ, 4 DCRK, 10 LWHS => 7 NXZCH | |||
| 3 CWHV, 1 THNDN => 7 LWHS | |||
| 1 BGXJV, 2 QBDX => 5 DWZS | |||
| 9 LQWJ => 8 QPSF | |||
| 21 BCQN, 3 FMSZ, 1 RSKC => 5 THKF | |||
| 118 ORE => 6 WXHJF | |||
| 11 FMSZ => 9 TWLC | |||
| 28 PLSM => 5 SHBC | |||
| 1 ZKHLC, 23 SCJG => 7 LBCZ | |||
| 17 DWZS, 16 THNDN => 9 PLVN | |||
| 7 HDKX => 9 HRWS | |||
+ 195
- 0
day14/src/main.rs
View File
| @ -0,0 +1,195 @@ | |||
| use std::collections::HashMap; | |||
| #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] | |||
| pub struct ChemicalAmount<'a> { | |||
| pub amount: u64, | |||
| pub name: &'a str, | |||
| } | |||
| impl<'a> ChemicalAmount<'a> { | |||
| pub fn parse(input: &'a str) -> Self { | |||
| let input = input.trim(); | |||
| let mut elems = input.split_whitespace(); | |||
| let amount = elems.next().expect("need amount").trim().parse::<u64>().expect("number for amount"); | |||
| let name = elems.next().expect("need amount").trim(); | |||
| assert!(elems.next().is_none(), "unexpected data"); | |||
| ChemicalAmount { | |||
| amount, | |||
| name, | |||
| } | |||
| } | |||
| } | |||
| pub type Inputs<'a> = Vec<ChemicalAmount<'a>>; | |||
| #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] | |||
| pub struct Reaction<'a> { | |||
| pub inputs: Inputs<'a>, | |||
| pub output: ChemicalAmount<'a>, | |||
| } | |||
| impl<'a> Reaction<'a> { | |||
| pub fn parse(input: &'a str) -> Self { | |||
| let mut parts = input.split("=>"); | |||
| let inputs = parts.next().expect("need inputs").trim().split(",").map(ChemicalAmount::parse).collect(); | |||
| let output = ChemicalAmount::parse(parts.next().expect("need output").trim()); | |||
| assert!(parts.next().is_none(), "unexpected data"); | |||
| Reaction { | |||
| inputs, | |||
| output, | |||
| } | |||
| } | |||
| pub fn runs_for(&self, required_output: u64) -> u64 { | |||
| (required_output + self.output.amount - 1) / self.output.amount | |||
| } | |||
| } | |||
| #[derive(Clone, Debug)] | |||
| pub struct Reactions<'a>(pub HashMap<&'a str, Reaction<'a>>); | |||
| impl<'a> Reactions<'a> { | |||
| pub fn parse(input: &'a str) -> Self { | |||
| Self(input.lines().map(Reaction::parse).map(|reaction| (reaction.output.name.into(), reaction)).collect()) | |||
| } | |||
| fn gather_ore(&self, needs: &mut HashMap<&'a str, u64>, name: &'a str, additional: u64) -> u64 { | |||
| if name == "ORE" { return additional; } | |||
| let previous_need; | |||
| let updated_need; | |||
| { | |||
| let need = needs.entry(&name).or_default(); | |||
| previous_need = *need; | |||
| updated_need = previous_need + additional; | |||
| *need = updated_need; | |||
| } | |||
| let reaction = &self.0[name]; | |||
| let previous_runs = reaction.runs_for(previous_need); | |||
| let updated_runs = reaction.runs_for(updated_need); | |||
| let mut ore = 0; | |||
| if updated_runs > previous_runs { | |||
| let new_runs = updated_runs - previous_runs; | |||
| for input in &reaction.inputs { | |||
| ore += self.gather_ore(needs, input.name, input.amount * new_runs); | |||
| } | |||
| } | |||
| ore | |||
| } | |||
| fn ore_for_fuel(&self, fuel: u64) -> u64 { | |||
| let mut needs = HashMap::new(); | |||
| self.gather_ore(&mut needs, "FUEL", fuel) | |||
| } | |||
| } | |||
| // check must be monotone, there must be a `n` such that for all `i`: `i <= n <=> check(i)` | |||
| // returns `None` if this `n` is less than 0 (i.e. check is never true) | |||
| fn binary_search_max<F>(check: F, start: u64, max_step: u64) -> Option<u64> | |||
| where | |||
| F: Fn(u64) -> bool, | |||
| { | |||
| let mut upper; | |||
| let mut lower; | |||
| // find boundaries | |||
| if !check(start) { | |||
| // find lower limit | |||
| if start == 0 { return None; } | |||
| upper = start - 1; | |||
| loop { | |||
| lower = start / 2; | |||
| if check(lower) { break; } | |||
| if lower == 0 { return None; } | |||
| upper = lower - 1; | |||
| } | |||
| } else { | |||
| lower = start; | |||
| // find upper limit | |||
| upper = start; | |||
| loop { | |||
| upper += max_step; | |||
| if !check(upper) { | |||
| upper -= 1; | |||
| break; | |||
| } | |||
| } | |||
| } | |||
| // invariant: check(lower) && !check(upper + 1) | |||
| while lower != upper { | |||
| debug_assert!(lower < upper); | |||
| let mid = (lower + upper + 1) / 2; | |||
| debug_assert!(mid > lower); | |||
| if check(mid) { | |||
| lower = mid; | |||
| } else { | |||
| upper = mid - 1; | |||
| } | |||
| } | |||
| Some(lower) | |||
| } | |||
| fn main() { | |||
| let reactions = Reactions::parse(include_str!("input.txt")); | |||
| let ore_one_fuel; | |||
| { | |||
| ore_one_fuel = reactions.ore_for_fuel(1); | |||
| println!("Need {} ORE for one FUEL", ore_one_fuel); | |||
| } | |||
| let have_ore = 1000000000000u64; | |||
| let max_fuel = binary_search_max(|fuel| { | |||
| reactions.ore_for_fuel(fuel) <= have_ore | |||
| }, have_ore / ore_one_fuel, have_ore / ore_one_fuel).unwrap(); | |||
| println!("Can get {} fuel for {} ore", max_fuel, have_ore); | |||
| } | |||
| #[cfg(test)] | |||
| mod day14test { | |||
| use super::*; | |||
| fn calculate_needed_ore(input: &str) -> u64 { | |||
| let reactions = Reactions::parse(input); | |||
| reactions.ore_for_fuel(1) | |||
| } | |||
| #[test] | |||
| fn examples1() { | |||
| assert_eq!(165, calculate_needed_ore( | |||
| "9 ORE => 2 A | |||
| 8 ORE => 3 B | |||
| 7 ORE => 5 C | |||
| 3 A, 4 B => 1 AB | |||
| 5 B, 7 C => 1 BC | |||
| 4 C, 1 A => 1 CA | |||
| 2 AB, 3 BC, 4 CA => 1 FUEL")); | |||
| assert_eq!(13312, calculate_needed_ore( | |||
| "157 ORE => 5 NZVS | |||
| 165 ORE => 6 DCFZ | |||
| 44 XJWVT, 5 KHKGT, 1 QDVJ, 29 NZVS, 9 GPVTF, 48 HKGWZ => 1 FUEL | |||
| 12 HKGWZ, 1 GPVTF, 8 PSHF => 9 QDVJ | |||
| 179 ORE => 7 PSHF | |||
| 177 ORE => 5 HKGWZ | |||
| 7 DCFZ, 7 PSHF => 2 XJWVT | |||
| 165 ORE => 2 GPVTF | |||
| 3 DCFZ, 7 NZVS, 5 HKGWZ, 10 PSHF => 8 KHKGT")); | |||
| assert_eq!(2210736, calculate_needed_ore( | |||
| "171 ORE => 8 CNZTR | |||
| 7 ZLQW, 3 BMBT, 9 XCVML, 26 XMNCP, 1 WPTQ, 2 MZWV, 1 RJRHP => 4 PLWSL | |||
| 114 ORE => 4 BHXH | |||
| 14 VRPVC => 6 BMBT | |||
| 6 BHXH, 18 KTJDG, 12 WPTQ, 7 PLWSL, 31 FHTLT, 37 ZDVW => 1 FUEL | |||
| 6 WPTQ, 2 BMBT, 8 ZLQW, 18 KTJDG, 1 XMNCP, 6 MZWV, 1 RJRHP => 6 FHTLT | |||
| 15 XDBXC, 2 LTCX, 1 VRPVC => 6 ZLQW | |||
| 13 WPTQ, 10 LTCX, 3 RJRHP, 14 XMNCP, 2 MZWV, 1 ZLQW => 1 ZDVW | |||
| 5 BMBT => 4 WPTQ | |||
| 189 ORE => 9 KTJDG | |||
| 1 MZWV, 17 XDBXC, 3 XCVML => 2 XMNCP | |||
| 12 VRPVC, 27 CNZTR => 2 XDBXC | |||
| 15 KTJDG, 12 BHXH => 5 XCVML | |||
| 3 BHXH, 2 VRPVC => 7 MZWV | |||
| 121 ORE => 7 VRPVC | |||
| 7 XCVML => 6 RJRHP | |||
| 5 BHXH, 4 VRPVC => 5 LTCX")); | |||
| } | |||
| } | |||