You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
145 lines
2.8 KiB
145 lines
2.8 KiB
#![allow(dead_code)]
|
|
|
|
#[macro_use] extern crate ad_hoc_iter;
|
|
#[macro_use] extern crate cfg_if;
|
|
|
|
use std::{
|
|
io,
|
|
io::BufReader,
|
|
fs::OpenOptions,
|
|
num::NonZeroU8,
|
|
ops,
|
|
iter,
|
|
};
|
|
use smallmap::Map;
|
|
mod input;
|
|
|
|
const INPUT: &str = "input";
|
|
|
|
type Adaptors = Map<NonZeroU8, ()>;
|
|
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
|
|
struct Diffs([usize; 3]);
|
|
|
|
impl ops::Add for Diffs
|
|
{
|
|
type Output = Self;
|
|
fn add(self, other: Self) -> Self::Output{
|
|
Self([
|
|
self.0[0] + other.0[0],
|
|
self.0[1] + other.0[1],
|
|
self.0[2] + other.0[2],
|
|
])
|
|
}
|
|
}
|
|
|
|
impl ops::AddAssign for Diffs
|
|
{
|
|
fn add_assign(&mut self, rhs: Self) {
|
|
self.0[0] += rhs.0[0];
|
|
self.0[1] += rhs.0[1];
|
|
self.0[2] += rhs.0[2];
|
|
}
|
|
}
|
|
|
|
impl Diffs
|
|
{
|
|
pub fn jd1(&self) -> usize
|
|
{
|
|
self.0[0]
|
|
}
|
|
pub fn jd2(&self) -> usize
|
|
{
|
|
self.0[1]
|
|
}
|
|
pub fn jd3(&self) -> usize
|
|
{
|
|
self.0[2]
|
|
}
|
|
}
|
|
|
|
fn parse_input(file: &str) -> Result<impl Iterator<Item = input::Int>, io::Error>
|
|
{
|
|
let file = OpenOptions::new().read(true).open(file)?;
|
|
Ok(input::read_input(BufReader::new(file)))
|
|
}
|
|
|
|
fn find_smallest(map: &Adaptors, finding: impl Into<u8>) -> (Option<u8>, Diffs)
|
|
{
|
|
#![allow(unused_assignments)]
|
|
|
|
let finding = finding.into();
|
|
let mut diffs = Diffs::default();
|
|
let mut set=false;
|
|
macro_rules! find {
|
|
($l:literal) => {
|
|
{
|
|
let shim = finding + $l;
|
|
debug_assert!(shim > 0);
|
|
//eprintln!("Looking up {}", shim);
|
|
match map.get(&unsafe {
|
|
NonZeroU8::new_unchecked(shim)
|
|
}).map(|_| shim) {
|
|
Some(yes) if !set => {
|
|
set = true;
|
|
diffs.0[($l-1)] += 1;
|
|
Some(yes)
|
|
},
|
|
x => x
|
|
}
|
|
}
|
|
}
|
|
};
|
|
(iter![
|
|
find!(1),
|
|
find!(2),
|
|
find!(3)
|
|
].filter_map(std::convert::identity)
|
|
.min(), diffs)
|
|
}
|
|
|
|
#[inline(always)] fn conv_input(input: impl Iterator<Item=input::Int>) -> impl Iterator<Item = (NonZeroU8, ())>
|
|
{
|
|
input.filter_map(NonZeroU8::new).zip(iter::repeat(()))
|
|
}
|
|
|
|
#[inline(always)] fn get_input() -> impl Iterator<Item=input::Int>
|
|
{
|
|
cfg_if!{
|
|
if #[cfg(feature="test")] {
|
|
input::test_input()
|
|
} else {
|
|
parse_input(INPUT).unwrap()
|
|
}
|
|
}
|
|
}
|
|
fn main() -> Result<(), Box<dyn std::error::Error>>
|
|
{
|
|
let all_jolts = {
|
|
let mut map: Adaptors = conv_input(get_input()).collect();
|
|
unsafe {
|
|
map.insert(NonZeroU8::new_unchecked(map.iter().map(|&(x, _)| x).max().unwrap().get() + 3), ());
|
|
}
|
|
map
|
|
};
|
|
debug_assert_eq!(all_jolts.num_pages(), 1); // Assert we have space efficiency.
|
|
|
|
let mut current = 0;
|
|
#[allow(unused_variables)]
|
|
let mut sum=0;
|
|
let mut whole_diffs = Diffs::default();
|
|
loop {
|
|
if let (Some(next), diffs) = find_smallest(&all_jolts, current) {
|
|
current = next;
|
|
sum+=1;
|
|
whole_diffs += diffs;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
println!("{}", whole_diffs.jd1() * whole_diffs.jd3());
|
|
Ok(())
|
|
}
|