heh
Diffstat (limited to 'src/main.rs')
| -rw-r--r-- | src/main.rs | 151 |
1 files changed, 115 insertions, 36 deletions
diff --git a/src/main.rs b/src/main.rs index 34442a7..bfa424a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -17,11 +17,15 @@ step_trait, cmp_minmax, custom_inner_attributes, + pattern_types, + pattern_type_macro, extend_one, slice_as_array, impl_trait_in_bindings, coroutines, stmt_expr_attributes, + pattern_type_range_trait, + const_trait_impl, coroutine_trait, iter_partition_in_place, slice_swap_unchecked, @@ -54,8 +58,9 @@ use regex::bytes::Regex; use rustc_hash::FxBuildHasher; use std::{ cmp::{Reverse, minmax}, + hash::Hash, mem::take, - ops::Coroutine, + ops::{Coroutine, Deref}, pin::Pin, simd::prelude::*, }; @@ -65,51 +70,125 @@ pub use util::prelude::*; #[allow(warnings)] type u32x3 = Simd<u32, 3>; -fn run(code: &[Vec<&[u8]>], a: i32) -> impl Coroutine<Yield = i32, Return = ()> { - let mut ptr = 0i32; - #[coroutine] - move || { - let mut regis = - HashMap::<&[u8], i32>::from_iter([(&b"a"[..], a), (b"b", 0), (b"c", 0), (b"d", 0)]); - while let Some(i) = code.get(ptr as usize).cloned() { - let p = |j: usize| i[j].str().parse::<i32>().unwrap_or_else(|_| regis[i[j]]); - - match i[0] { - b"out" => drop(yield regis[i[1]]), - b"cpy" => *regis.get_mut(i[2]).unwrap() = p(1), - b"inc" => *regis.get_mut(i[1]).unwrap() += 1, - b"dec" => *regis.get_mut(i[1]).unwrap() -= 1, - b"jnz" if p(1) != 0 => { - ptr += p(2); - - continue; - } +impl Debug for Item { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{} {:?}", self.name.get(), self.kind) + } +} - _ => {} - } +#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] - ptr += 1; - } +struct Item { + name: identifier, + kind: ItemK, +} +#[derive(Clone, Copy, Debug)] +#[repr(u8)] +enum identifier { + u1, + u2, + u3, + u4, + u5, + u6, + u7, + u8, + u9, +} +impl identifier { + fn get(self) -> u8 { + self as u8 } } - +impl PartialEq for identifier { + fn eq(&self, other: &Self) -> bool { + self.get() == other.get() + } +} +impl Eq for identifier {} +impl PartialOrd for identifier { + fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> { + self.get().partial_cmp(&other.get()) + } +} +impl Ord for identifier { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.get().cmp(&other.get()) + } +} +impl Hash for identifier { + fn hash<H: std::hash::Hasher>(&self, state: &mut H) { + self.get().hash(state) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] +enum ItemK { + Chip, + Gen, +} +use ItemK::*; #[unsafe(no_mangle)] #[implicit_fn::implicit_fn] -pub unsafe fn p1(x: &[u8; ISIZE]) -> impl Display { - let x = x - .行() - .map(|x| x.μₙ(b' ').collect::<Vec<_>>()) - .collect::<Vec<_>>(); - for n in 0.. { - dbg!(n); - std::iter::from_coroutine(run(&x, n)).eq([0, 1].iter().copied().cycle()); - } +pub unsafe fn p1(x: &'static [u8; ISIZE]) -> impl Debug { + let re = Regex::new(r"([0-9a-z]+) generator").unwrap(); + let rechip = Regex::new(r"([0-9a-z]+)-compatible microchip").unwrap(); + let mut floors = vec![vec![]; 4]; + x.行().zip(&mut floors).for_each(|(x, to)| { + to.extend(re.captures_iter(x).map(|x| Item { + name: transmute(x.get(1).unwrap().as_bytes()[0] - b'0'), + kind: Gen, + })); + to.extend(rechip.captures_iter(x).map(|x| Item { + name: transmute(x.get(1).unwrap().as_bytes()[0] - b'0'), + kind: Chip, + })); + }); + // if a chip is ever left in the same area as another RTG, and it's not connected to its own RTG, the chip will be fried. + fn not_fried(floor: impl Iterator<Item = Item> + Clone) -> bool { + floor.clone().all(_.kind == Chip) + || floor + .clone() + .filter(_.kind == Chip) // every chip + .all(|x| floor.clone().filter(_.kind == Gen).any(_.name == x.name)) // is connected + }; - 0 + util::steps_astar( + (0, floors), + |(e, floor)| { + [(e < 3).then(|| e + 1), (e > 0).then(|| e - 1)] + .into_iter() + .flatten() + .flat_map(move |v| { + floor[e] + .clone() + .into_iter() + .ι() + .tuple_combinations() + .map(|(a, b)| vec![a, b]) + .chain(floor[e].clone().into_iter().ι().map(|a| vec![a])) + .map({ + let floor = floor.clone(); + move |mut x| { + let mut floor = floor.clone(); + floor[v].extend(x.iter().map(|x| x.0)); + x.sort_by_key(|x| x.1); + x.iter().rev().map(|(_, i)| floor[e].swap_remove(*i)).θ(); + floor[v].sort(); + floor[e].sort(); + (v, floor) + } + }) + }) + .filter(|(e, floor)| not_fried(floor[*e].iter().copied())) + .map(|n| (n, 1)) + }, + |x| -(x.1[3].len() as i16), + |(_, f)| f[0..3].iter().all(_.is_empty()), + ) } const ISIZE: usize = include_bytes!("inp.txt").len(); fn main() { - unsafe { println!("{}", p1(include_bytes!("inp.txt"))) }; + unsafe { println!("{:?}", p1(include_bytes!("inp.txt"))) }; } #[bench] |