Stefan Bühler
2 years ago
11 changed files with 651 additions and 0 deletions
@ -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" |
||||
@ -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> |
||||
@ -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>"))); |
||||
} |
||||
} |
||||
@ -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" } |
||||
File diff suppressed because one or more lines are too long
@ -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); |
||||
} |
||||
@ -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] |
||||
@ -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 |
||||
@ -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")); |
||||
} |
||||
} |
||||
Loading…
Reference in new issue