Stefan Bühler
1 year ago
11 changed files with 651 additions and 0 deletions
-
43Cargo.lock
-
3Cargo.toml
-
10day12/Cargo.toml
-
4day12/src/input.txt
-
166day12/src/main.rs
-
10day13/Cargo.toml
-
1day13/src/input.txt
-
147day13/src/main.rs
-
9day14/Cargo.toml
-
63day14/src/input.txt
-
195day14/src/main.rs
@ -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" } |
|||
1
day13/src/input.txt
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
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);
|
|||
}
|
|||
@ -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"));
|
|||
}
|
|||
}
|
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue