Day 8.1, 9 and 10, plus formatting and optimization
This commit is contained in:
parent
54700e121b
commit
21fcc07f3c
10 changed files with 788 additions and 471 deletions
230
src/day02.rs
230
src/day02.rs
|
@ -1,115 +1,115 @@
|
|||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
use std::{error::Error, str::FromStr};
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
enum Direction {
|
||||
Forward,
|
||||
Down,
|
||||
Up,
|
||||
}
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct Instruction {
|
||||
direction: Direction,
|
||||
amount: usize,
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, Default)]
|
||||
pub struct Submarine{
|
||||
depth: i64,
|
||||
pos: i64,
|
||||
aim: i64
|
||||
}
|
||||
|
||||
impl Submarine {
|
||||
fn new() -> Self {
|
||||
Default::default()
|
||||
}
|
||||
fn run_p1(&mut self, inst: &Instruction) {
|
||||
let d = inst.direction;
|
||||
let a = inst.amount as i64;
|
||||
match d {
|
||||
Direction::Forward => {
|
||||
self.pos += a;
|
||||
}
|
||||
Direction::Down => {
|
||||
self.depth += a;
|
||||
}
|
||||
Direction::Up => {
|
||||
self.depth -= a;
|
||||
}
|
||||
};
|
||||
}
|
||||
fn run_p2(&mut self, inst: &Instruction) {
|
||||
let d = inst.direction;
|
||||
let a = inst.amount as i64;
|
||||
match d {
|
||||
Direction::Forward => {
|
||||
self.pos += a;
|
||||
self.depth += self.aim*a;
|
||||
}
|
||||
Direction::Down => {
|
||||
self.aim += a;
|
||||
}
|
||||
Direction::Up => {
|
||||
self.aim -= a;
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for Instruction {
|
||||
type Err = Box<dyn Error>;
|
||||
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
let mut s = s.split_ascii_whitespace();
|
||||
let inst = s.next().unwrap();
|
||||
let amount: usize = s.next().unwrap().parse().unwrap();
|
||||
let ret = match inst {
|
||||
"forward" => Self {
|
||||
direction: Direction::Forward,
|
||||
amount,
|
||||
},
|
||||
"up" => Self {
|
||||
direction: Direction::Up,
|
||||
amount,
|
||||
},
|
||||
"down" => Self {
|
||||
direction: Direction::Down,
|
||||
amount,
|
||||
},
|
||||
other => {
|
||||
panic!("Invalid instruction: {}", other)
|
||||
}
|
||||
};
|
||||
Ok(ret)
|
||||
}
|
||||
}
|
||||
|
||||
pub type Data = Vec<Instruction>;
|
||||
|
||||
#[aoc_generator(day02)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
input
|
||||
.lines()
|
||||
.map(Instruction::from_str)
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[aoc(day02, part1)]
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
let mut sm = Submarine::new();
|
||||
for inst in input {
|
||||
sm.run_p1(inst);
|
||||
}
|
||||
(sm.pos * sm.depth) as usize
|
||||
}
|
||||
|
||||
#[aoc(day02, part2)]
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
let mut sm = Submarine::new();
|
||||
for inst in input {
|
||||
sm.run_p2(inst);
|
||||
}
|
||||
(sm.pos * sm.depth) as usize
|
||||
}
|
||||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
use std::{error::Error, str::FromStr};
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
enum Direction {
|
||||
Forward,
|
||||
Down,
|
||||
Up,
|
||||
}
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct Instruction {
|
||||
direction: Direction,
|
||||
amount: usize,
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, Default)]
|
||||
pub struct Submarine {
|
||||
depth: i64,
|
||||
pos: i64,
|
||||
aim: i64,
|
||||
}
|
||||
|
||||
impl Submarine {
|
||||
fn new() -> Self {
|
||||
Default::default()
|
||||
}
|
||||
fn run_p1(&mut self, inst: &Instruction) {
|
||||
let d = inst.direction;
|
||||
let a = inst.amount as i64;
|
||||
match d {
|
||||
Direction::Forward => {
|
||||
self.pos += a;
|
||||
}
|
||||
Direction::Down => {
|
||||
self.depth += a;
|
||||
}
|
||||
Direction::Up => {
|
||||
self.depth -= a;
|
||||
}
|
||||
};
|
||||
}
|
||||
fn run_p2(&mut self, inst: &Instruction) {
|
||||
let d = inst.direction;
|
||||
let a = inst.amount as i64;
|
||||
match d {
|
||||
Direction::Forward => {
|
||||
self.pos += a;
|
||||
self.depth += self.aim * a;
|
||||
}
|
||||
Direction::Down => {
|
||||
self.aim += a;
|
||||
}
|
||||
Direction::Up => {
|
||||
self.aim -= a;
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for Instruction {
|
||||
type Err = Box<dyn Error>;
|
||||
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
let mut s = s.split_ascii_whitespace();
|
||||
let inst = s.next().unwrap();
|
||||
let amount: usize = s.next().unwrap().parse().unwrap();
|
||||
let ret = match inst {
|
||||
"forward" => Self {
|
||||
direction: Direction::Forward,
|
||||
amount,
|
||||
},
|
||||
"up" => Self {
|
||||
direction: Direction::Up,
|
||||
amount,
|
||||
},
|
||||
"down" => Self {
|
||||
direction: Direction::Down,
|
||||
amount,
|
||||
},
|
||||
other => {
|
||||
panic!("Invalid instruction: {}", other)
|
||||
}
|
||||
};
|
||||
Ok(ret)
|
||||
}
|
||||
}
|
||||
|
||||
pub type Data = Vec<Instruction>;
|
||||
|
||||
#[aoc_generator(day02)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
input
|
||||
.lines()
|
||||
.map(Instruction::from_str)
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[aoc(day02, part1)]
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
let mut sm = Submarine::new();
|
||||
for inst in input {
|
||||
sm.run_p1(inst);
|
||||
}
|
||||
(sm.pos * sm.depth) as usize
|
||||
}
|
||||
|
||||
#[aoc(day02, part2)]
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
let mut sm = Submarine::new();
|
||||
for inst in input {
|
||||
sm.run_p2(inst);
|
||||
}
|
||||
(sm.pos * sm.depth) as usize
|
||||
}
|
||||
|
|
173
src/day03.rs
173
src/day03.rs
|
@ -1,91 +1,82 @@
|
|||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
type Data = Vec<u16>;
|
||||
|
||||
fn make_histogram(input: &[u16]) -> Vec<(usize, i64)> {
|
||||
let counts: &mut [Option<i64>] = &mut [None; 64];
|
||||
input.iter().for_each(|val| {
|
||||
for (n, count) in counts.iter_mut().enumerate().take(12) {
|
||||
let v = count.get_or_insert(0);
|
||||
if ((val >> n) & 1) == 1 {
|
||||
*v += 1;
|
||||
} else {
|
||||
*v -= 1;
|
||||
}
|
||||
}
|
||||
});
|
||||
counts.reverse();
|
||||
counts
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(a, b)| b.map(|b| (a, b)))
|
||||
.collect::<Vec<_>>()
|
||||
}
|
||||
|
||||
#[aoc_generator(day03)]
|
||||
pub fn input_generator(input: &str) -> Vec<u16> {
|
||||
input
|
||||
.lines()
|
||||
.map(|l| u16::from_str_radix(l, 2).unwrap())
|
||||
.collect()
|
||||
}
|
||||
|
||||
|
||||
#[derive(Debug)]
|
||||
enum Mode {
|
||||
MostCommon,
|
||||
LeastCommon,
|
||||
}
|
||||
|
||||
fn tree_filter(data: &[u16], pos: usize, mode: Mode) -> u16 {
|
||||
let (zero, one) = data
|
||||
.iter()
|
||||
.partition::<Vec<u16>, _>(|&v| ((v >> pos) & 1) == 0);
|
||||
if data.is_empty() {
|
||||
panic!("Uh Oh!");
|
||||
}
|
||||
if data.len() == 1 {
|
||||
return data[0];
|
||||
}
|
||||
if zero.len() == one.len() {
|
||||
match mode {
|
||||
Mode::MostCommon => tree_filter(&one, pos - 1, mode),
|
||||
Mode::LeastCommon => tree_filter(&zero, pos - 1, mode),
|
||||
}
|
||||
} else {
|
||||
let mut srt = vec![zero, one];
|
||||
srt.sort_by_key(|v| v.len());
|
||||
match mode {
|
||||
Mode::MostCommon => tree_filter(&srt[1], pos - 1, mode),
|
||||
Mode::LeastCommon => tree_filter(&srt[0], pos - 1, mode),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
const ASCII_ZERO: u8 = 0x30;
|
||||
|
||||
#[aoc(day03, part1)] // 1997414
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
let counts = make_histogram(input);
|
||||
let (gamma, epsilon): (String, String) = counts
|
||||
.iter()
|
||||
.map(|(_, v)| {
|
||||
(
|
||||
(ASCII_ZERO + (*v >= 0) as u8) as char,
|
||||
(ASCII_ZERO + (*v < 0) as u8) as char,
|
||||
)
|
||||
})
|
||||
.unzip();
|
||||
let gamma = usize::from_str_radix(&gamma, 2).unwrap();
|
||||
let epsilon = usize::from_str_radix(&epsilon, 2).unwrap();
|
||||
gamma * epsilon
|
||||
}
|
||||
|
||||
#[aoc(day03, part2)]
|
||||
pub fn solve_part2(input: &[u16]) -> usize {
|
||||
// let input: Vec<bool> = input.iter().for_each(|v| v[0]).collect();
|
||||
let a = tree_filter(input, 11, Mode::MostCommon) as usize;
|
||||
let b = tree_filter(input, 11, Mode::LeastCommon) as usize;
|
||||
a * b
|
||||
}
|
||||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
type Data = Vec<u16>;
|
||||
fn make_histogram(input: &[u16]) -> Vec<(usize, i64)> {
|
||||
let counts: &mut [Option<i64>] = &mut [None; 64];
|
||||
input.iter().for_each(|val| {
|
||||
for (n, count) in counts.iter_mut().enumerate().take(12) {
|
||||
let v = count.get_or_insert(0);
|
||||
if ((val >> n) & 1) == 1 {
|
||||
*v += 1;
|
||||
} else {
|
||||
*v -= 1;
|
||||
}
|
||||
}
|
||||
});
|
||||
counts.reverse();
|
||||
counts
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(a, b)| b.map(|b| (a, b)))
|
||||
.collect::<Vec<_>>()
|
||||
}
|
||||
#[aoc_generator(day03)]
|
||||
pub fn input_generator(input: &str) -> Vec<u16> {
|
||||
input
|
||||
.lines()
|
||||
.map(|l| u16::from_str_radix(l, 2).unwrap())
|
||||
.collect()
|
||||
}
|
||||
#[derive(Debug)]
|
||||
enum Mode {
|
||||
MostCommon,
|
||||
LeastCommon,
|
||||
}
|
||||
fn tree_filter(data: &[u16], mut pos: usize, mode: Mode) -> u16 {
|
||||
let (zero, one) = data
|
||||
.iter()
|
||||
.partition::<Vec<u16>, _>(|&v| ((v >> pos) & 1) == 0);
|
||||
if data.is_empty() {
|
||||
panic!("Uh Oh!");
|
||||
}
|
||||
if data.len() == 1 {
|
||||
return data[0];
|
||||
}
|
||||
pos=pos.wrapping_sub(1);
|
||||
if zero.len() == one.len() {
|
||||
match mode {
|
||||
Mode::MostCommon => tree_filter(&one, pos, mode),
|
||||
Mode::LeastCommon => tree_filter(&zero, pos, mode),
|
||||
}
|
||||
} else {
|
||||
let mut srt = vec![zero, one];
|
||||
srt.sort_by_key(|v| v.len());
|
||||
match mode {
|
||||
Mode::MostCommon => tree_filter(&srt[1], pos, mode),
|
||||
Mode::LeastCommon => tree_filter(&srt[0], pos, mode),
|
||||
}
|
||||
}
|
||||
}
|
||||
const ASCII_ZERO: u8 = 0x30;
|
||||
#[aoc(day03, part1)] // 1997414
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
let counts = make_histogram(input);
|
||||
let (gamma, epsilon): (String, String) = counts
|
||||
.iter()
|
||||
.map(|(_, v)| {
|
||||
(
|
||||
(ASCII_ZERO + (*v >= 0) as u8) as char,
|
||||
(ASCII_ZERO + (*v < 0) as u8) as char,
|
||||
)
|
||||
})
|
||||
.unzip();
|
||||
let gamma = usize::from_str_radix(&gamma, 2).unwrap();
|
||||
let epsilon = usize::from_str_radix(&epsilon, 2).unwrap();
|
||||
gamma * epsilon
|
||||
}
|
||||
#[aoc(day03, part2)] // 1032597
|
||||
pub fn solve_part2(input: &[u16]) -> usize {
|
||||
// let input: Vec<bool> = input.iter().for_each(|v| v[0]).collect();
|
||||
let a = tree_filter(input, 11, Mode::MostCommon) as usize;
|
||||
let b = tree_filter(input, 11, Mode::LeastCommon) as usize;
|
||||
a * b
|
||||
}
|
239
src/day04.rs
239
src/day04.rs
|
@ -1,92 +1,147 @@
|
|||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
#[derive(Debug,Clone)]
|
||||
pub struct Data {
|
||||
pub numbers: Vec<u8>,
|
||||
pub boards: Vec<[[(u8,bool); 5]; 5]>,
|
||||
}
|
||||
|
||||
#[aoc_generator(day04)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
let mut lines = input.lines();
|
||||
let mut boards = vec![];
|
||||
let numbers = lines
|
||||
.next()
|
||||
.unwrap()
|
||||
.split(',')
|
||||
.map(|s| s.parse())
|
||||
.collect::<Result<Vec<u8>, _>>()
|
||||
.unwrap();
|
||||
let mut row = 0;
|
||||
let mut board = [[(0u8,false); 5]; 5];
|
||||
for line in lines {
|
||||
if line.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let line = line
|
||||
.split_ascii_whitespace()
|
||||
.map(|s| s.parse())
|
||||
.collect::<Result<Vec<u8>, _>>()
|
||||
.unwrap();
|
||||
line.iter().enumerate().for_each(|(i, v)| {
|
||||
board[row][i] = (*v,false);
|
||||
});
|
||||
row = (row + 1) % 5;
|
||||
if row == 0 {
|
||||
boards.push(board);
|
||||
board = [[(0u8,false); 5]; 5];
|
||||
}
|
||||
}
|
||||
Data { numbers, boards }
|
||||
}
|
||||
|
||||
#[aoc(day04, part1)]
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
let Data {numbers,mut boards} =input.clone();
|
||||
for number in numbers.iter() {
|
||||
for board in &mut boards {
|
||||
for row in board.iter_mut() {
|
||||
for (n,b) in row {
|
||||
if n==number {
|
||||
*b=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
let win=(0..5).map(|v| {
|
||||
[board[v][0],board[v][1],board[v][2],board[v][3],board[v][4]].iter().all(|v| v.1)|
|
||||
[board[0][v],board[1][v],board[2][v],board[3][v],board[4][v]].iter().all(|v| v.1)
|
||||
}).any(|v| v);
|
||||
if win {
|
||||
return board.iter().flatten().filter_map(|(v,b)| (!*b).then(|| *v as usize)).sum::<usize>()*(*number as usize)
|
||||
}
|
||||
}
|
||||
}
|
||||
unreachable!()
|
||||
}
|
||||
|
||||
#[aoc(day04, part2)]
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
let mut ret=None;
|
||||
let Data {numbers,mut boards} =input.clone();
|
||||
let mut board_wins: Vec<bool> = vec![false;boards.len()];
|
||||
for number in numbers.iter() {
|
||||
for (board_n,board) in boards.iter_mut().enumerate() {
|
||||
for row in board.iter_mut() {
|
||||
for (n,b) in row {
|
||||
if n==number {
|
||||
*b=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
let win=(0..5).map(|v| {
|
||||
[board[v][0],board[v][1],board[v][2],board[v][3],board[v][4]].iter().all(|v| v.1)|
|
||||
[board[0][v],board[1][v],board[2][v],board[3][v],board[4][v]].iter().all(|v| v.1)
|
||||
}).any(|v| v);
|
||||
if win && !board_wins[board_n] {
|
||||
ret=Some(board.iter().flatten().filter(|(_,b)| !*b).map(|(v,_)| *v as usize).sum::<usize>()*(*number as usize));
|
||||
board_wins[board_n]=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret.unwrap();
|
||||
}
|
||||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Data {
|
||||
pub numbers: Vec<u8>,
|
||||
pub boards: Vec<[[(u8, bool); 5]; 5]>,
|
||||
}
|
||||
|
||||
#[aoc_generator(day04)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
let mut lines = input.lines();
|
||||
let mut boards = vec![];
|
||||
let numbers = lines
|
||||
.next()
|
||||
.unwrap()
|
||||
.split(',')
|
||||
.map(|s| s.parse())
|
||||
.collect::<Result<Vec<u8>, _>>()
|
||||
.unwrap();
|
||||
let mut row = 0;
|
||||
let mut board = [[(0u8, false); 5]; 5];
|
||||
for line in lines {
|
||||
if line.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let line = line
|
||||
.split_ascii_whitespace()
|
||||
.map(|s| s.parse())
|
||||
.collect::<Result<Vec<u8>, _>>()
|
||||
.unwrap();
|
||||
line.iter().enumerate().for_each(|(i, v)| {
|
||||
board[row][i] = (*v, false);
|
||||
});
|
||||
row = (row + 1) % 5;
|
||||
if row == 0 {
|
||||
boards.push(board);
|
||||
board = [[(0u8, false); 5]; 5];
|
||||
}
|
||||
}
|
||||
Data { numbers, boards }
|
||||
}
|
||||
|
||||
#[aoc(day04, part1)]
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
let Data {
|
||||
numbers,
|
||||
mut boards,
|
||||
} = input.clone();
|
||||
for number in numbers.iter() {
|
||||
for board in &mut boards {
|
||||
for row in board.iter_mut() {
|
||||
for (n, b) in row {
|
||||
if n == number {
|
||||
*b = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
let win = (0..5)
|
||||
.map(|v| {
|
||||
[
|
||||
board[v][0],
|
||||
board[v][1],
|
||||
board[v][2],
|
||||
board[v][3],
|
||||
board[v][4],
|
||||
]
|
||||
.iter()
|
||||
.all(|v| v.1)
|
||||
| [
|
||||
board[0][v],
|
||||
board[1][v],
|
||||
board[2][v],
|
||||
board[3][v],
|
||||
board[4][v],
|
||||
]
|
||||
.iter()
|
||||
.all(|v| v.1)
|
||||
})
|
||||
.any(|v| v);
|
||||
if win {
|
||||
return board
|
||||
.iter()
|
||||
.flatten()
|
||||
.filter_map(|(v, b)| (!*b).then(|| *v as usize))
|
||||
.sum::<usize>()
|
||||
* (*number as usize);
|
||||
}
|
||||
}
|
||||
}
|
||||
unreachable!()
|
||||
}
|
||||
|
||||
#[aoc(day04, part2)]
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
let mut ret = None;
|
||||
let Data {
|
||||
numbers,
|
||||
mut boards,
|
||||
} = input.clone();
|
||||
let mut board_wins: Vec<bool> = vec![false; boards.len()];
|
||||
for number in numbers.iter() {
|
||||
for (board_n, board) in boards.iter_mut().enumerate() {
|
||||
for row in board.iter_mut() {
|
||||
for (n, b) in row {
|
||||
if n == number {
|
||||
*b = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
let win = (0..5)
|
||||
.map(|v| {
|
||||
[
|
||||
board[v][0],
|
||||
board[v][1],
|
||||
board[v][2],
|
||||
board[v][3],
|
||||
board[v][4],
|
||||
]
|
||||
.iter()
|
||||
.all(|v| v.1)
|
||||
| [
|
||||
board[0][v],
|
||||
board[1][v],
|
||||
board[2][v],
|
||||
board[3][v],
|
||||
board[4][v],
|
||||
]
|
||||
.iter()
|
||||
.all(|v| v.1)
|
||||
})
|
||||
.any(|v| v);
|
||||
if win && !board_wins[board_n] {
|
||||
ret = Some(
|
||||
board
|
||||
.iter()
|
||||
.flatten()
|
||||
.filter(|(_, b)| !*b)
|
||||
.map(|(v, _)| *v as usize)
|
||||
.sum::<usize>()
|
||||
* (*number as usize),
|
||||
);
|
||||
board_wins[board_n] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret.unwrap();
|
||||
}
|
||||
|
|
216
src/day05.rs
216
src/day05.rs
|
@ -1,106 +1,110 @@
|
|||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Line {
|
||||
x: (i64, i64),
|
||||
y: (i64, i64),
|
||||
}
|
||||
|
||||
impl Line {
|
||||
fn iter(&self) -> LineIterator {
|
||||
let ret= LineIterator {
|
||||
line: self,
|
||||
px: self.x.0,
|
||||
py: self.y.0,
|
||||
sx: match self.x.0.cmp(&self.x.1) {
|
||||
std::cmp::Ordering::Less => 1,
|
||||
std::cmp::Ordering::Equal => 0,
|
||||
std::cmp::Ordering::Greater => -1,
|
||||
},
|
||||
sy: match self.y.0.cmp(&self.y.1) {
|
||||
std::cmp::Ordering::Less => 1,
|
||||
std::cmp::Ordering::Equal => 0,
|
||||
std::cmp::Ordering::Greater => -1,
|
||||
},
|
||||
};
|
||||
assert!(ret.sx!=0||ret.sy!=0);
|
||||
ret
|
||||
}
|
||||
}
|
||||
#[derive(Debug)]
|
||||
struct LineIterator<'a> {
|
||||
line: &'a Line,
|
||||
px: i64,
|
||||
py: i64,
|
||||
sx: i64,
|
||||
sy: i64,
|
||||
}
|
||||
|
||||
impl<'a> Iterator for LineIterator<'a> {
|
||||
type Item = (i64, i64);
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
let ret = (self.px,self.py);
|
||||
if self.sx>0 && self.px>self.line.x.1 {
|
||||
return None;
|
||||
}
|
||||
if self.sx<0 && self.px<self.line.x.1 {
|
||||
return None;
|
||||
}
|
||||
if self.sy>0 && self.py>self.line.y.1 {
|
||||
return None;
|
||||
}
|
||||
if self.sy<0 && self.py<self.line.y.1 {
|
||||
return None;
|
||||
}
|
||||
self.px+=self.sx;
|
||||
self.py+=self.sy;
|
||||
Some(ret)
|
||||
}
|
||||
}
|
||||
|
||||
type Data = Vec<Line>;
|
||||
|
||||
#[aoc_generator(day05)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
input
|
||||
.lines()
|
||||
.map(|line| {
|
||||
let parts= line.split(" -> ").collect::<Vec<_>>();
|
||||
let start = parts[0]
|
||||
.split(',')
|
||||
.map(|v| v.parse().unwrap())
|
||||
.collect::<Vec<i64>>();
|
||||
let end = parts[1]
|
||||
.split(',')
|
||||
.map(|v| v.parse().unwrap())
|
||||
.collect::<Vec<i64>>();
|
||||
Line {
|
||||
x: (start[0], end[0]),
|
||||
y: (start[1], end[1]),
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[aoc(day05, part1)]
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
let mut grid = vec![vec![0u8; 1000]; 1000];
|
||||
for (x,y) in input.iter().filter(|l| l.x.0==l.x.1||l.y.0==l.y.1).flat_map(|v| v.iter()) {
|
||||
let x: usize=x.try_into().unwrap();
|
||||
let y: usize=y.try_into().unwrap();
|
||||
grid[x][y] += 1;
|
||||
}
|
||||
return grid.iter().flatten().filter(|&v| *v > 1).count();
|
||||
}
|
||||
|
||||
#[aoc(day05, part2)]
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
let mut grid = vec![vec![0u8; 1000]; 1000];
|
||||
for (x,y) in input.iter().flat_map(|v| v.iter()) {
|
||||
let x: usize=x.try_into().unwrap();
|
||||
let y: usize=y.try_into().unwrap();
|
||||
grid[x][y] += 1;
|
||||
}
|
||||
return grid.iter().flatten().filter(|&v| *v > 1).count();
|
||||
}
|
||||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Line {
|
||||
x: (i64, i64),
|
||||
y: (i64, i64),
|
||||
}
|
||||
|
||||
impl Line {
|
||||
fn iter(&self) -> LineIterator {
|
||||
let ret = LineIterator {
|
||||
line: self,
|
||||
px: self.x.0,
|
||||
py: self.y.0,
|
||||
sx: match self.x.0.cmp(&self.x.1) {
|
||||
std::cmp::Ordering::Less => 1,
|
||||
std::cmp::Ordering::Equal => 0,
|
||||
std::cmp::Ordering::Greater => -1,
|
||||
},
|
||||
sy: match self.y.0.cmp(&self.y.1) {
|
||||
std::cmp::Ordering::Less => 1,
|
||||
std::cmp::Ordering::Equal => 0,
|
||||
std::cmp::Ordering::Greater => -1,
|
||||
},
|
||||
};
|
||||
assert!(ret.sx != 0 || ret.sy != 0);
|
||||
ret
|
||||
}
|
||||
}
|
||||
#[derive(Debug)]
|
||||
struct LineIterator<'a> {
|
||||
line: &'a Line,
|
||||
px: i64,
|
||||
py: i64,
|
||||
sx: i64,
|
||||
sy: i64,
|
||||
}
|
||||
|
||||
impl<'a> Iterator for LineIterator<'a> {
|
||||
type Item = (i64, i64);
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
let ret = (self.px, self.py);
|
||||
if self.sx > 0 && self.px > self.line.x.1 {
|
||||
return None;
|
||||
}
|
||||
if self.sx < 0 && self.px < self.line.x.1 {
|
||||
return None;
|
||||
}
|
||||
if self.sy > 0 && self.py > self.line.y.1 {
|
||||
return None;
|
||||
}
|
||||
if self.sy < 0 && self.py < self.line.y.1 {
|
||||
return None;
|
||||
}
|
||||
self.px += self.sx;
|
||||
self.py += self.sy;
|
||||
Some(ret)
|
||||
}
|
||||
}
|
||||
|
||||
type Data = Vec<Line>;
|
||||
|
||||
#[aoc_generator(day05)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
input
|
||||
.lines()
|
||||
.map(|line| {
|
||||
let parts = line.split(" -> ").collect::<Vec<_>>();
|
||||
let start = parts[0]
|
||||
.split(',')
|
||||
.map(|v| v.parse().unwrap())
|
||||
.collect::<Vec<i64>>();
|
||||
let end = parts[1]
|
||||
.split(',')
|
||||
.map(|v| v.parse().unwrap())
|
||||
.collect::<Vec<i64>>();
|
||||
Line {
|
||||
x: (start[0], end[0]),
|
||||
y: (start[1], end[1]),
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[aoc(day05, part1)]
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
let mut grid = vec![vec![0u8; 1000]; 1000];
|
||||
for (x, y) in input
|
||||
.iter()
|
||||
.filter(|l| l.x.0 == l.x.1 || l.y.0 == l.y.1)
|
||||
.flat_map(|v| v.iter())
|
||||
{
|
||||
let x: usize = x.try_into().unwrap();
|
||||
let y: usize = y.try_into().unwrap();
|
||||
grid[x][y] += 1;
|
||||
}
|
||||
return grid.iter().flatten().filter(|&v| *v > 1).count();
|
||||
}
|
||||
|
||||
#[aoc(day05, part2)]
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
let mut grid = vec![vec![0u8; 1000]; 1000];
|
||||
for (x, y) in input.iter().flat_map(|v| v.iter()) {
|
||||
let x: usize = x.try_into().unwrap();
|
||||
let y: usize = y.try_into().unwrap();
|
||||
grid[x][y] += 1;
|
||||
}
|
||||
return grid.iter().flatten().filter(|&v| *v > 1).count();
|
||||
}
|
||||
|
|
64
src/day06.rs
64
src/day06.rs
|
@ -1,33 +1,31 @@
|
|||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
type Data = [usize;9];
|
||||
|
||||
#[aoc_generator(day06)]
|
||||
pub fn input_generator(input: &str) -> [usize;9] {
|
||||
let mut state: [usize;9] = [0;9];
|
||||
let input = input.trim().split(',').map(|v| v.parse::<usize>().unwrap());
|
||||
for v in input {
|
||||
state[v]+=1;
|
||||
}
|
||||
state
|
||||
}
|
||||
|
||||
|
||||
fn simulate(input: &Data,n: usize) -> usize {
|
||||
let mut state=*input;
|
||||
for i in 0..n {
|
||||
state[(7+i)%9]+=state[i%9];
|
||||
}
|
||||
state.iter().sum()
|
||||
|
||||
}
|
||||
|
||||
#[aoc(day06, part1)] // 353274
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
simulate(input,80)
|
||||
}
|
||||
|
||||
#[aoc(day06, part2)] // 1609314870967
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
simulate(input,256)
|
||||
}
|
||||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
type Data = [usize; 9];
|
||||
|
||||
#[aoc_generator(day06)]
|
||||
pub fn input_generator(input: &str) -> [usize; 9] {
|
||||
let mut state: [usize; 9] = [0; 9];
|
||||
let input = input.trim().split(',').map(|v| v.parse::<usize>().unwrap());
|
||||
for v in input {
|
||||
state[v] += 1;
|
||||
}
|
||||
state
|
||||
}
|
||||
|
||||
fn simulate(input: &Data, n: usize) -> usize {
|
||||
let mut state = *input;
|
||||
for i in 0..n {
|
||||
state[(7 + i) % 9] += state[i % 9];
|
||||
}
|
||||
state.iter().sum()
|
||||
}
|
||||
|
||||
#[aoc(day06, part1)] // 353274
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
simulate(input, 80)
|
||||
}
|
||||
|
||||
#[aoc(day06, part2)] // 1609314870967
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
simulate(input, 256)
|
||||
}
|
||||
|
|
71
src/day07.rs
71
src/day07.rs
|
@ -1,33 +1,38 @@
|
|||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
type Data = Vec<i64>;
|
||||
|
||||
#[aoc_generator(day07)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
let mut input: Vec<_> = input.split(',').map(|v| v.parse().unwrap()).collect();
|
||||
input.sort_unstable();
|
||||
input
|
||||
}
|
||||
|
||||
#[aoc(day07, part1)] // 336040
|
||||
pub fn solve_part1(input: &Data) -> i64 {
|
||||
let start = *input.first().unwrap();
|
||||
let end = *input.last().unwrap();
|
||||
(start..=end).map(|n| {
|
||||
input.iter().map(|v| {
|
||||
(v-n).abs()
|
||||
}).sum()
|
||||
}).min().unwrap()
|
||||
}
|
||||
|
||||
#[aoc(day07, part2)] // 94813675
|
||||
pub fn solve_part2(input: &Data) -> i64 {
|
||||
let start = *input.first().unwrap();
|
||||
let end = *input.last().unwrap();
|
||||
(start..=end).map(|n| {
|
||||
input.iter().map(|v| {
|
||||
let diff=(v-n).abs();
|
||||
(diff*(diff+1))>>1 // Gauss
|
||||
}).sum()
|
||||
}).min().unwrap()
|
||||
}
|
||||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
type Data = Vec<i64>;
|
||||
|
||||
#[aoc_generator(day07)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
let mut input: Vec<_> = input.split(',').map(|v| v.parse().unwrap()).collect();
|
||||
input.sort_unstable();
|
||||
input
|
||||
}
|
||||
|
||||
#[aoc(day07, part1)] // 336040
|
||||
pub fn solve_part1(input: &Data) -> i64 {
|
||||
let start = *input.first().unwrap();
|
||||
let end = *input.last().unwrap();
|
||||
(start..=end)
|
||||
.map(|n| input.iter().map(|v| (v - n).abs()).sum())
|
||||
.min()
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[aoc(day07, part2)] // 94813675
|
||||
pub fn solve_part2(input: &Data) -> i64 {
|
||||
let start = *input.first().unwrap();
|
||||
let end = *input.last().unwrap();
|
||||
(start..=end)
|
||||
.map(|n| {
|
||||
input
|
||||
.iter()
|
||||
.map(|v| {
|
||||
let diff = (v - n).abs();
|
||||
(diff * (diff + 1)) >> 1 // Gauss
|
||||
})
|
||||
.sum()
|
||||
})
|
||||
.min()
|
||||
.unwrap()
|
||||
}
|
||||
|
|
93
src/day08.rs
Normal file
93
src/day08.rs
Normal file
|
@ -0,0 +1,93 @@
|
|||
use std::collections::{BTreeSet, HashMap, HashSet};
|
||||
|
||||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
use itertools::Itertools;
|
||||
|
||||
type Data = HashMap<Vec<String>, Vec<String>>;
|
||||
|
||||
#[aoc_generator(day08)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
// let input =
|
||||
// "acedgfb cdfbe gcdfa fbcad dab cefabd cdfgeb eafb cagedb ab | cdfeb fcadb cdfeb cdbaf";
|
||||
let mut ret = HashMap::new();
|
||||
for line in input.lines() {
|
||||
let mut line = line.split(" | ").map(|v| {
|
||||
v.split(' ')
|
||||
.map(|v| v.chars().sorted().collect::<String>())
|
||||
.collect::<Vec<_>>()
|
||||
});
|
||||
ret.insert(line.next().unwrap(), line.next().unwrap());
|
||||
}
|
||||
ret
|
||||
}
|
||||
|
||||
fn resolve_overlaps(digits: &HashMap<BTreeSet<char>, HashSet<u8>>) -> HashMap<BTreeSet<char>, u8> {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn unshuffle(input: &[String], output: &[String]) -> usize {
|
||||
let mut results: HashMap<BTreeSet<char>, u8> = HashMap::new();
|
||||
// segments -> candidate digits
|
||||
let mut digits: HashMap<BTreeSet<char>, HashSet<u8>> = HashMap::new();
|
||||
// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 digits
|
||||
// 6, 2, 5, 5, 4, 5, 6, 3, 7, 6 segments
|
||||
// println!("Unshuffling: {:?} -> {:?}", input, output);
|
||||
// LHS is sub-pattern of RHS
|
||||
let overlap: HashMap<u8,Vec<u8>> = HashMap::from([
|
||||
(0,vec![8]),
|
||||
(1,vec![3,4,7,8,9]),
|
||||
(2,vec![8]),
|
||||
]);
|
||||
for val in input {
|
||||
let candidates: Vec<u8> = match val.len() {
|
||||
2 => vec![1],
|
||||
3 => vec![7],
|
||||
4 => vec![4],
|
||||
5 => vec![2, 5, 3],
|
||||
6 => vec![6, 9],
|
||||
7 => vec![8],
|
||||
_ => unreachable!(),
|
||||
};
|
||||
digits
|
||||
.entry(val.chars().collect())
|
||||
.or_default()
|
||||
.extend(&candidates);
|
||||
}
|
||||
for _ in 0..10 {
|
||||
// println!("===================");
|
||||
// println!("D: {:?}", digits);
|
||||
// println!("R: {:?}", results);
|
||||
if results.len() == 10 {
|
||||
break;
|
||||
}
|
||||
for (k, v) in &digits {
|
||||
if v.len() == 1 {
|
||||
let c = v.iter().copied().next().unwrap();
|
||||
results.insert(k.clone(), c);
|
||||
}
|
||||
}
|
||||
digits.values_mut().for_each(|v| {
|
||||
for c in results.values() {
|
||||
v.remove(c);
|
||||
}
|
||||
});
|
||||
digits = digits.drain().filter(|(_, v)| !v.is_empty()).collect();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#[aoc(day08, part1)] // 310
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
input
|
||||
.values()
|
||||
.flatten()
|
||||
.filter(|v| {
|
||||
[2, 4, 3, 7].contains(&v.len())
|
||||
})
|
||||
.count()
|
||||
}
|
||||
|
||||
#[aoc(day08, part2)]
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
input.iter().map(|(k, v)| unshuffle(k, v)).sum()
|
||||
}
|
103
src/day09.rs
Normal file
103
src/day09.rs
Normal file
|
@ -0,0 +1,103 @@
|
|||
use std::collections::{BTreeSet, VecDeque};
|
||||
|
||||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
|
||||
pub struct Data(Vec<Vec<u8>>);
|
||||
|
||||
impl Data {
|
||||
fn shape(&self) -> (usize, usize) {
|
||||
if !self.0.iter().all(|v| v.len() == self.0[0].len()) {
|
||||
panic!("Not rectangular!");
|
||||
}
|
||||
(self.0.len(), self.0[0].len())
|
||||
}
|
||||
fn get(&self, x: i64, y: i64) -> Option<u8> {
|
||||
if x < 0 || y < 0 {
|
||||
return None;
|
||||
}
|
||||
self.0
|
||||
.get(x as usize)
|
||||
.map(|v| v.get(y as usize).copied())
|
||||
.flatten()
|
||||
}
|
||||
}
|
||||
|
||||
#[aoc_generator(day09)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
Data(
|
||||
input
|
||||
.lines()
|
||||
.map(|l| {
|
||||
l.chars()
|
||||
.map(|c| c.to_digit(10).unwrap().try_into().unwrap())
|
||||
.collect()
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
|
||||
fn get_low_points(input: &Data) -> Vec<(i64, i64, u8)> {
|
||||
let mut ret = vec![];
|
||||
let (sx, sy) = input.shape();
|
||||
let sx = sx as i64;
|
||||
let sy = sy as i64;
|
||||
for x in 0..sx {
|
||||
for y in 0..sy {
|
||||
let c = input.get(x, y);
|
||||
if c.is_none() {
|
||||
continue;
|
||||
}
|
||||
let c = c.unwrap();
|
||||
let low_point = input
|
||||
.get(x + 1, y)
|
||||
.iter()
|
||||
.chain(input.get(x - 1, y).iter())
|
||||
.chain(input.get(x, y + 1).iter())
|
||||
.chain(input.get(x, y - 1).iter())
|
||||
.all(|v| v > &c);
|
||||
if low_point {
|
||||
ret.push((x, y, c))
|
||||
}
|
||||
}
|
||||
}
|
||||
ret
|
||||
}
|
||||
|
||||
#[aoc(day09, part1)] // 468
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
get_low_points(input)
|
||||
.iter()
|
||||
.map(|(_, _, v)| (*v as usize) + 1)
|
||||
.sum()
|
||||
}
|
||||
|
||||
#[aoc(day09, part2)]
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
let mut basins: BTreeSet<usize> = BTreeSet::new();
|
||||
let mut q = VecDeque::new();
|
||||
let mut visited = BTreeSet::<(i64, i64)>::new();
|
||||
for (x, y, c) in &get_low_points(input) {
|
||||
visited.clear();
|
||||
q.clear();
|
||||
q.push_back((*x, *y, *c));
|
||||
while let Some((x, y, c)) = q.pop_front() {
|
||||
if c == 9 || !visited.insert((x, y)) {
|
||||
continue;
|
||||
}
|
||||
for d in [-1, 1] {
|
||||
if let Some(v) = input.get(x + d, y) {
|
||||
if v > c {
|
||||
q.push_back((x + d, y, v));
|
||||
}
|
||||
}
|
||||
if let Some(v) = input.get(x, y + d) {
|
||||
if v > c {
|
||||
q.push_back((x, y + d, v));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
basins.insert(visited.len());
|
||||
}
|
||||
return basins.iter().rev().take(3).product();
|
||||
}
|
66
src/day10.rs
Normal file
66
src/day10.rs
Normal file
|
@ -0,0 +1,66 @@
|
|||
use aoc_runner_derive::{aoc, aoc_generator};
|
||||
type Data = Vec<Vec<char>>;
|
||||
|
||||
#[aoc_generator(day10)]
|
||||
pub fn input_generator(input: &str) -> Data {
|
||||
input.lines().map(|l| l.chars().collect()).collect()
|
||||
}
|
||||
|
||||
pub fn error_score(line: &Vec<char>) -> (usize,Vec<char>) {
|
||||
let mut score=0;
|
||||
let mut stack=vec![];
|
||||
for c in line {
|
||||
match c {
|
||||
'(' => {stack.push(')')},
|
||||
'[' => {stack.push(']')},
|
||||
'{' => {stack.push('}')},
|
||||
'<' => {stack.push('>')},
|
||||
')'|']'|'}'|'>' => {
|
||||
if let Some(ex) = stack.pop() {
|
||||
if ex!=*c {
|
||||
score+=match c {
|
||||
')' => 3,
|
||||
']' => 57,
|
||||
'}' => 1197,
|
||||
'>' => 25137,
|
||||
c => unreachable!("Unexpected character {:?}!",c)
|
||||
};
|
||||
break;
|
||||
}
|
||||
}
|
||||
},
|
||||
c => unreachable!("Unexpected character {:?}!",c)
|
||||
}
|
||||
}
|
||||
(score,stack)
|
||||
}
|
||||
|
||||
#[aoc(day10, part1)]
|
||||
pub fn solve_part1(input: &Data) -> usize {
|
||||
input.iter().map(|v| error_score(v).0).sum()
|
||||
}
|
||||
|
||||
#[aoc(day10, part2)]
|
||||
pub fn solve_part2(input: &Data) -> usize {
|
||||
let mut scores=vec![];
|
||||
for line in input {
|
||||
let mut line_score=0;
|
||||
let (error_score,mut stack) = error_score(line);
|
||||
stack.reverse();
|
||||
if error_score==0 && !stack.is_empty() {
|
||||
for c in stack {
|
||||
line_score*=5;
|
||||
line_score+=match c {
|
||||
')' => 1,
|
||||
']' => 2,
|
||||
'}' => 3,
|
||||
'>' => 4,
|
||||
c => unreachable!("Unexpected character {:?}!",c)
|
||||
}
|
||||
}
|
||||
scores.push(line_score);
|
||||
}
|
||||
}
|
||||
scores.sort_unstable();
|
||||
scores[scores.len()/2]
|
||||
}
|
|
@ -1,6 +1,5 @@
|
|||
#![allow(clippy::clippy::needless_return)]
|
||||
#![feature(int_abs_diff)]
|
||||
|
||||
use aoc_runner_derive::aoc_lib;
|
||||
pub mod day01;
|
||||
pub mod day02;
|
||||
|
@ -9,4 +8,7 @@ pub mod day04;
|
|||
pub mod day05;
|
||||
pub mod day06;
|
||||
pub mod day07;
|
||||
pub mod day08;
|
||||
pub mod day09;
|
||||
pub mod day10;
|
||||
aoc_lib! { year = 2021 }
|
||||
|
|
Loading…
Reference in a new issue