Get rid of Position2D, 3D, 4D
This commit is contained in:
parent
c726998c0c
commit
123d9bd1fb
GPG Key ID:
8282A2BEA4ADA3D2
|
|
@ -66,7 +66,7 @@ fn parse_input(raw: &str) -> Parsed {
|
|||
fn occupied_neighbors(pos: &PositionND<2>, grid: &Parsed) -> usize {
|
||||
pos.neighbors()
|
||||
.iter()
|
||||
.filter(|p| grid.get(&p).unwrap_or(&Tile::Floor) == &Tile::Occupied)
|
||||
.filter(|p| grid.get(p).unwrap_or(&Tile::Floor) == &Tile::Occupied)
|
||||
.count()
|
||||
}
|
||||
|
||||
|
|
@ -96,13 +96,13 @@ fn make_step<F: Fn(&PositionND<2>, &Parsed) -> usize>(previous: &mut Parsed, cou
|
|||
match tile {
|
||||
Tile::Floor => (),
|
||||
Tile::Empty => {
|
||||
if count_neighbors(&pos, &readonly) == 0 {
|
||||
if count_neighbors(pos, &readonly) == 0 {
|
||||
*tile = Tile::Occupied;
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
Tile::Occupied => {
|
||||
if count_neighbors(&pos, &readonly) >= limit {
|
||||
if count_neighbors(pos, &readonly) >= limit {
|
||||
*tile = Tile::Empty;
|
||||
changed = true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -45,12 +45,11 @@ where [(); grid::num_neighbors(D)]: Sized {
|
|||
fn next_state<const D: usize>(pos: &PositionND<D>, grid: &Grid<D, Cell>) -> Cell
|
||||
where [(); grid::num_neighbors(D)]: Sized {
|
||||
let cell = grid.get(pos);
|
||||
let new = match (&cell, count_live_neighbors::<D>(pos, &grid)) {
|
||||
match (&cell, count_live_neighbors::<D>(pos, grid)) {
|
||||
(Cell::Alive, 2..=3) => Cell::Alive,
|
||||
(Cell::Dead, 3) => Cell::Alive,
|
||||
_ => Cell::Dead,
|
||||
};
|
||||
new
|
||||
}
|
||||
}
|
||||
|
||||
fn solve<const D: usize>(parsed: &Grid<D, Cell>, steps: usize) -> usize
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ pub struct Grid<const D: usize, T: Display + Default> {
|
|||
|
||||
impl<const D: usize, T: Display + Default + Copy> Grid<D, T> {
|
||||
pub fn get(&self, pos: &PositionND<D>) -> T {
|
||||
self.fields.get(pos).copied().unwrap_or_else(|| T::default())
|
||||
self.fields.get(pos).copied().unwrap_or_else(T::default)
|
||||
}
|
||||
|
||||
pub fn insert<Pos: Into<PositionND<D>>>(&mut self, pos: Pos, t: T) {
|
||||
|
|
@ -63,7 +63,7 @@ mod tests {
|
|||
use super::*;
|
||||
#[test]
|
||||
fn test_add() {
|
||||
assert_eq!(Position2D { x: 0, y: 2 } + Position2D { x: -1, y: 0 }, (-1, 2).into());
|
||||
assert_eq!(Position2D { x: 0, y: -1 } + Direction::Up, (0, 0).into());
|
||||
assert_eq!(PositionND::from([0, 2]) + PositionND::from([-1, 0]), [-1, 2].into());
|
||||
assert_eq!(PositionND::from([0, -1]) + PositionND::from(Direction::Up), [0, 0].into());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,8 @@
|
|||
extern crate test;
|
||||
use super::direction::*;
|
||||
use impl_ops::*;
|
||||
use itertools::iproduct;
|
||||
use std::{
|
||||
convert::TryInto, hash::Hash, ops::{self, Add, AddAssign, Mul, Sub}
|
||||
convert::TryInto, hash::Hash, ops::{Add, Mul, Sub}
|
||||
};
|
||||
|
||||
pub trait Position
|
||||
|
|
@ -12,27 +11,6 @@ where Self: Sized + Hash + PartialEq + Eq + Clone + Copy
|
|||
fn neighbors(&self) -> Vec<Self>;
|
||||
}
|
||||
|
||||
#[derive(Hash, PartialEq, Eq, Debug, Clone, Copy)]
|
||||
pub struct Position2D {
|
||||
pub x: i64,
|
||||
pub y: i64,
|
||||
}
|
||||
|
||||
#[derive(Hash, PartialEq, Eq, Debug, Clone, Copy)]
|
||||
pub struct Position3D {
|
||||
pub x: i64,
|
||||
pub y: i64,
|
||||
pub z: i64,
|
||||
}
|
||||
|
||||
#[derive(Hash, PartialEq, Eq, Debug, Clone, Copy)]
|
||||
pub struct Position4D {
|
||||
pub x: i64,
|
||||
pub y: i64,
|
||||
pub z: i64,
|
||||
pub w: i64,
|
||||
}
|
||||
|
||||
#[derive(Hash, PartialEq, Eq, Debug, Clone, Copy)]
|
||||
pub struct PositionND<const DIMS: usize> {
|
||||
pub points: [i64; DIMS],
|
||||
|
|
@ -50,6 +28,15 @@ where I: TryInto<i64> + Copy
|
|||
}
|
||||
}
|
||||
|
||||
// because calling .unwrap() on a TryInto result isn’t possible without trait bounds on the
|
||||
// associated Error type.
|
||||
fn unwrap_number_result<I: TryInto<i64>>(i: I) -> i64 {
|
||||
match i.try_into() {
|
||||
Ok(i) => i,
|
||||
_ => panic!("Bad coordinate"),
|
||||
}
|
||||
}
|
||||
|
||||
pub const fn num_neighbors(d: usize) -> usize {
|
||||
3usize.pow(d as u32) - 1
|
||||
}
|
||||
|
|
@ -174,168 +161,6 @@ impl From<Direction> for PositionND<2> {
|
|||
}
|
||||
}
|
||||
|
||||
mod p2d {
|
||||
use super::*;
|
||||
|
||||
impl From<Direction> for Position2D {
|
||||
fn from(d: Direction) -> Self {
|
||||
match d {
|
||||
Direction::Up => Position2D::from((0, 1)),
|
||||
Direction::Right => Position2D::from((1, 0)),
|
||||
Direction::Left => Position2D::from((-1, 0)),
|
||||
Direction::Down => Position2D::from((0, -1)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Position for Position2D {
|
||||
fn neighbors(&self) -> Vec<Position2D> {
|
||||
vec![
|
||||
*self + Direction::Up + Direction::Left,
|
||||
*self + Direction::Up,
|
||||
*self + Direction::Up + Direction::Right,
|
||||
*self + Direction::Left,
|
||||
*self + Direction::Right,
|
||||
*self + Direction::Down + Direction::Left,
|
||||
*self + Direction::Down,
|
||||
*self + Direction::Down + Direction::Right,
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Into<i64>> From<(I, I)> for Position2D {
|
||||
fn from((x, y): (I, I)) -> Position2D {
|
||||
Position2D { x: x.into(), y: y.into() }
|
||||
}
|
||||
}
|
||||
|
||||
impl_op!(+|a: Position2D, b: Direction| -> Position2D { a + Position2D::from(b) });
|
||||
|
||||
impl_op!(-|a: Position2D, b: Direction| -> Position2D { a - Position2D::from(b) });
|
||||
|
||||
impl_op!(*|a: Position2D, b: i64| -> Position2D { Position2D { x: a.x * b, y: a.y * b } });
|
||||
|
||||
impl_op!(+|a: Position2D, b: Position2D| -> Position2D {
|
||||
Position2D {
|
||||
x: a.x + b.x,
|
||||
y: a.y + b.y
|
||||
}
|
||||
});
|
||||
|
||||
impl_op!(-|a: Position2D, b: Position2D| -> Position2D {
|
||||
Position2D {
|
||||
x: a.x - b.x,
|
||||
y: a.y - b.y,
|
||||
}
|
||||
});
|
||||
|
||||
impl AddAssign<Direction> for Position2D {
|
||||
fn add_assign(&mut self, rhs: Direction) {
|
||||
*self = *self + rhs;
|
||||
}
|
||||
}
|
||||
|
||||
impl AddAssign for Position2D {
|
||||
fn add_assign(&mut self, rhs: Position2D) {
|
||||
*self = *self + rhs;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mod p3d {
|
||||
use super::*;
|
||||
|
||||
impl Position for Position3D {
|
||||
fn neighbors(&self) -> Vec<Position3D> {
|
||||
iproduct!((-1..=1), (-1..=1), (-1..=1))
|
||||
.filter(|t| t != &(0, 0, 0))
|
||||
.map(|(x, y, z)| *self + Position3D::from((x, y, z)))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> From<(I, I, I)> for Position3D
|
||||
where I: TryInto<i64>
|
||||
{
|
||||
fn from((x, y, z): (I, I, I)) -> Position3D {
|
||||
Position3D {
|
||||
x: unwrap_number_result(x),
|
||||
y: unwrap_number_result(y),
|
||||
z: unwrap_number_result(z),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl_op!(-|a: Position3D, b: Position3D| -> Position3D {
|
||||
Position3D {
|
||||
x: a.x - b.x,
|
||||
y: a.y - b.y,
|
||||
z: a.z - b.z,
|
||||
}
|
||||
});
|
||||
|
||||
impl_op!(+|a: Position3D, b: Position3D| -> Position3D {
|
||||
Position3D {
|
||||
x: a.x + b.x,
|
||||
y: a.y + b.y,
|
||||
z: a.z + b.z,
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
mod p4d {
|
||||
use super::*;
|
||||
|
||||
impl Position for Position4D {
|
||||
fn neighbors(&self) -> Vec<Position4D> {
|
||||
iproduct!((-1..=1), (-1..=1), (-1..=1), (-1..=1))
|
||||
.filter(|t| t != &(0, 0, 0, 0))
|
||||
.map(|(x, y, z, w)| *self + Position4D::from((x, y, z, w)))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> From<(I, I, I, I)> for Position4D
|
||||
where I: TryInto<i64>
|
||||
{
|
||||
fn from((x, y, z, w): (I, I, I, I)) -> Position4D {
|
||||
Position4D {
|
||||
x: unwrap_number_result(x),
|
||||
y: unwrap_number_result(y),
|
||||
z: unwrap_number_result(z),
|
||||
w: unwrap_number_result(w),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl_op!(-|a: Position4D, b: Position4D| -> Position4D {
|
||||
Position4D {
|
||||
x: a.x - b.x,
|
||||
y: a.y - b.y,
|
||||
z: a.z - b.z,
|
||||
w: a.w - b.w,
|
||||
}
|
||||
});
|
||||
|
||||
impl_op!(+|a: Position4D, b: Position4D| -> Position4D {
|
||||
Position4D {
|
||||
x: a.x + b.x,
|
||||
y: a.y + b.y,
|
||||
z: a.z + b.z,
|
||||
w: a.w + b.w,
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// because calling .unwrap() on a TryInto result isn’t possible without trait bounds on the
|
||||
// associated Error type.
|
||||
fn unwrap_number_result<I: TryInto<i64>>(i: I) -> i64 {
|
||||
match i.try_into() {
|
||||
Ok(i) => i,
|
||||
_ => panic!("Bad coordinate"),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user