ruediger/advent-2022-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Made everything a bit more rustic

Browse source
This commit is contained in:
Rüdiger Ludwig 2023-07-29 17:02:25 +02:00
parent 7f5b6e03f9
commit a5f19ecae1
22 changed files with 376 additions and 274 deletions
Download patch file Download diff file Expand all files Collapse all files

11
src/common/file.rs
View file

@ -5,13 +5,16 @@ fn format_path(day_num: usize, file: &str) -> String {
format!("data/day{day_num:02}/{file}")
}
pub fn read_lines(day_num: usize, file: &str) -> io::Result<Vec<String>> {
Ok(fs::read_to_string(format_path(day_num, file))?
pub fn read_string(day_num: usize, file: &str) -> io::Result<String> {
Ok(fs::read_to_string(format_path(day_num, file))?)
}
pub fn split_lines<'a>(lines: &'a str) -> impl Iterator<Item = &'a str> + 'a {
lines
.split('\n')
.with_position()
.filter_map(|(pos, line)| match pos {
itertools::Position::Last if line.is_empty() => None,
_ => Some(line.to_owned()),
_ => Some(line),
})
.collect())
}

22
src/days/day01/mod.rs
View file

@ -3,6 +3,8 @@ use std::num::ParseIntError;
use thiserror::Error;
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
pub struct Day;
@ -13,13 +15,15 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let lines = split_lines(lines);
let vector = Day::parse(lines)?;
let max = vector.iter().max().ok_or(CalorieError::Empty)?;
Ok(ResultType::Integer(*max))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let lines = split_lines(lines);
let vector = Day::parse(lines)?;
let sum = vector.iter().sorted_by(|a, b| Ord::cmp(b, a)).take(3).sum();
Ok(ResultType::Integer(sum))
@ -27,9 +31,8 @@ impl DayTrait for Day {
}
impl Day {
fn parse(lines: &[String]) -> Result<Vec<i64>, CalorieError> {
fn parse<'a>(lines: impl Iterator<Item = &'a str>) -> Result<Vec<i64>, CalorieError> {
Ok(lines
.iter()
.batching(|it| {
let result = it
.take_while(|line| !line.is_empty())
@ -57,13 +60,13 @@ pub enum CalorieError {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(24_000);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -74,7 +77,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(45_000);
let result = day.part2(&lines)?;
assert_eq!(result, expected);
@ -84,9 +87,10 @@ mod test {
#[test]
fn test_parse() -> Result<()> {
let lines = read_lines(DAY_NUMBER, "example01.txt")?;
let lines = read_string(DAY_NUMBER, "example01.txt")?;
let lines = split_lines(&lines);
let expected = vec![6000, 4000, 11000, 24000, 10000];
let result = Day::parse(&lines)?;
let result = Day::parse(lines)?;
assert_eq!(result, expected);
Ok(())

18
src/days/day02/mod.rs
View file

@ -1,5 +1,7 @@
use std::cmp::Ordering;
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use thiserror::Error;
@ -12,9 +14,8 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let sum = split_lines(lines)
.map(|line| Rps::parse_line(line))
.collect::<Result<Vec<_>, _>>()?
.into_iter()
@ -24,9 +25,8 @@ impl DayTrait for Day {
Ok(ResultType::Integer(sum))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let sum = split_lines(lines)
.map(|line| Strategy::parse_line(line))
.collect::<Result<Vec<_>, _>>()?
.into_iter()
@ -155,7 +155,7 @@ impl TryFrom<&str> for Strategy {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
@ -182,7 +182,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(15);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -214,7 +214,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(12);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

22
src/days/day03/mod.rs
View file

@ -1,3 +1,5 @@
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use itertools::Itertools;
use thiserror::Error;
@ -11,9 +13,8 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let sum = split_lines(lines)
.map(|line| find_double(line))
.map_ok(priority)
.flatten_ok()
@ -21,12 +22,11 @@ impl DayTrait for Day {
Ok(ResultType::Integer(sum))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let sum = split_lines(lines)
.chunks(3)
.into_iter()
.map(|chunk| find_badge(&chunk.collect::<Vec<_>>()))
.map(|chunk| find_badge(&chunk.collect_vec()))
.map_ok(priority)
.flatten_ok()
.fold_ok(0, |a, b| a + b)?;
@ -71,7 +71,7 @@ fn find_double(content: &str) -> Result<char, RucksackError> {
Err(RucksackError::NoDoubleFound)?
}
fn find_badge(elves: &[&String]) -> Result<char, RucksackError> {
fn find_badge(elves: &[&str]) -> Result<char, RucksackError> {
if elves.len() < 2 {
return Err(RucksackError::NeedAtLeastTwo);
};
@ -92,7 +92,7 @@ fn find_badge(elves: &[&String]) -> Result<char, RucksackError> {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
@ -108,7 +108,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(157);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -119,7 +119,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(70);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

18
src/days/day04/mod.rs
View file

@ -1,3 +1,5 @@
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use itertools::Itertools;
use std::num::ParseIntError;
@ -12,18 +14,16 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let sum = split_lines(lines)
.map(|line| parse(line))
.filter_ok(fully_contained)
.fold_ok(0i64, |a, _| a + 1)?;
Ok(ResultType::Integer(sum))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let sum = split_lines(lines)
.map(|line| parse(line))
.filter_ok(overlaps)
.fold_ok(0i64, |a, _| a + 1)?;
@ -77,7 +77,7 @@ fn overlaps((first, second): &(Range, Range)) -> bool {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
@ -93,7 +93,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(2);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -104,7 +104,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(4);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

44
src/days/day05/mod.rs
View file

@ -1,4 +1,7 @@
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use itertools::Itertools;
use std::num::ParseIntError;
use thiserror::Error;
@ -11,7 +14,7 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let (mut stacks, commands) = parse(lines)?;
for command in commands {
command.with_turn(&mut stacks)?;
@ -19,7 +22,7 @@ impl DayTrait for Day {
Ok(ResultType::String(get_word(&stacks)))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let (mut stacks, commands) = parse(lines)?;
for command in commands {
command.without_turn(&mut stacks)?;
@ -57,11 +60,13 @@ fn parse_crate(line: &str) -> Vec<Option<char>> {
.collect()
}
fn parse_all_crates(line_it: &mut dyn Iterator<Item = &String>) -> Result<Vec<String>, CrateError> {
let rows: Vec<_> = line_it
fn parse_all_crates<'a>(
line_it: &mut dyn Iterator<Item = &'a str>,
) -> Result<Vec<String>, CrateError> {
let rows = line_it
.take_while(|line| !line.is_empty())
.map(|row| parse_crate(row))
.collect();
.collect_vec();
let Some(stacks_count) = rows.iter().map(|row| row.len()).max() else {
return Err(CrateError::NoCargoStacksGiven);
};
@ -79,11 +84,11 @@ fn parse_all_crates(line_it: &mut dyn Iterator<Item = &String>) -> Result<Vec<St
Ok(stacks)
}
fn parse(line: &[String]) -> Result<(Vec<String>, Vec<Move>), CrateError> {
let mut iter = line.iter();
fn parse<'a>(lines: &'a str) -> Result<(Vec<String>, Vec<Move>), CrateError> {
let mut iter = split_lines(lines);
let stacks = parse_all_crates(&mut iter)?;
let moves: Vec<_> = iter
.map(|command| Move::try_from(command.as_str()))
.map(|command| Move::try_from(command))
.collect::<Result<_, _>>()?;
Ok((stacks, moves))
}
@ -167,7 +172,7 @@ impl TryFrom<&str> for Move {
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
@ -191,14 +196,15 @@ mod test {
#[test]
fn test_parse_all_crates() -> Result<()> {
let lines = vec![
" [D] ".to_owned(),
"[N] [C] ".to_owned(),
"[Z] [M] [P]".to_owned(),
" 1 2 3 ".to_owned(),
"".to_owned(),
"move 1 from to 2 1".to_owned(),
];
let mut input = lines.iter();
" [D] ",
"[N] [C] ",
"[Z] [M] [P]",
" 1 2 3 ",
"",
"move 1 from to 2 1",
]
.join("\n");
let mut input = split_lines(&lines);
let expected = vec!["NZ1".to_owned(), "DCM2".to_owned(), "P3".to_owned()];
let result = parse_all_crates(&mut input)?;
@ -221,7 +227,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::String("CMZ".to_owned());
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -243,7 +249,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::String("MCD".to_owned());
let result = day.part2(&lines)?;
assert_eq!(result, expected);

14
src/days/day06/mod.rs
View file

@ -10,13 +10,13 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let count = find_marker(&lines[0], 4)?;
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let count = find_marker(lines.trim_end(), 4)?;
Ok(ResultType::Integer(count as i64))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let count = find_marker(&lines[0], 14)?;
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let count = find_marker(lines.trim_end(), 14)?;
Ok(ResultType::Integer(count as i64))
}
}
@ -82,7 +82,7 @@ fn find_marker(word: &str, marker_length: usize) -> Result<usize, MarkerError> {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
@ -98,7 +98,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(10);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -109,7 +109,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(29);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

26
src/days/day07/mod.rs
View file

@ -4,6 +4,8 @@ use std::{
rc::{Rc, Weak},
};
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use thiserror::Error;
@ -16,7 +18,8 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let lines = split_lines(lines);
let root = Directory::parse(lines)?;
let result = root
.iter()
@ -32,9 +35,10 @@ impl DayTrait for Day {
Ok(ResultType::Integer(result))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
const AVAIL: i64 = 70_000_000;
const REQUIRED: i64 = 30_000_000;
let lines = split_lines(lines);
let root = Directory::parse(lines)?;
let to_free = REQUIRED - (AVAIL - root.size());
let result = root
@ -167,7 +171,7 @@ impl Directory {
sub_node.map(|node| Directory::create(node.clone()))
}
pub fn parse(lines: &[String]) -> Result<Directory, DirectoryError> {
pub fn parse<'a>(lines: impl Iterator<Item = &'a str>) -> Result<Directory, DirectoryError> {
let root = Directory::root();
let mut current = root.clone();
for line in lines {
@ -269,7 +273,7 @@ impl Iterator for DirectoryIterator {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
@ -298,8 +302,9 @@ mod test {
#[test]
fn test_total_size() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let dir = Directory::parse(&lines)?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let lines = split_lines(&lines);
let dir = Directory::parse(lines)?;
assert_eq!(dir.size(), 48381165);
Ok(())
@ -308,9 +313,10 @@ mod test {
#[test]
fn test_iterator() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let lines = split_lines(&lines);
let expected = vec!["/", "a", "e", "d"];
let dir = Directory::parse(&lines)?;
let dir = Directory::parse(lines)?;
let result: Vec<_> = dir.iter().map(|dir| dir.name()).collect();
assert_eq!(result, expected);
@ -320,7 +326,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(95437);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -331,7 +337,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(24933642);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

47
src/days/day08/mod.rs
View file

@ -1,3 +1,5 @@
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use itertools::{iproduct, FoldWhile, Itertools};
use thiserror::Error;
@ -11,14 +13,14 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let forest = Forest::parse(lines)?;
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let forest = Forest::try_from(lines)?;
let result = forest.count_visible();
Ok(ResultType::Integer(result))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let forest = Forest::parse(lines)?;
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let forest = Forest::try_from(lines)?;
let result = forest.best_score();
Ok(ResultType::Integer(result))
}
@ -67,18 +69,6 @@ impl Forest {
})
}
pub fn parse(lines: &[String]) -> Result<Forest, ForestError> {
lines
.iter()
.map(|line| {
line.chars()
.map(|height| height.to_digit(10).ok_or(ForestError::NoLegalDigit(height)))
.collect::<Result<Vec<_>, _>>()
})
.collect::<Result<Vec<_>, _>>()
.and_then(Forest::create)
}
pub fn count_visible(&self) -> i64 {
let mut vis_count = 2 * (self.width + self.height - 2) as i64;
let mut visible = vec![vec![false; self.width - 2]; self.height - 2];
@ -191,17 +181,32 @@ impl Forest {
}
}
impl TryFrom<&str> for Forest {
type Error = ForestError;
fn try_from(lines: &str) -> Result<Self, Self::Error> {
split_lines(lines)
.map(|line| {
line.chars()
.map(|height| height.to_digit(10).ok_or(ForestError::NoLegalDigit(height)))
.collect::<Result<Vec<_>, _>>()
})
.collect::<Result<Vec<_>, _>>()
.and_then(Forest::create)
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_parse() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let forest = Forest::parse(&lines)?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let forest = Forest::try_from(lines.as_str())?;
assert_eq!(forest.width, 5);
assert_eq!(forest.height, 5);
@ -211,7 +216,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(21);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -222,7 +227,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(8);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

21
src/days/day09/mod.rs
View file

@ -1,5 +1,6 @@
use super::template::{DayTrait, ResultType};
use crate::common::{direction::Direction, pos::Pos};
use crate::common::{direction::Direction, file::split_lines, pos::Pos};
use itertools::Itertools;
use std::{collections::HashSet, num::ParseIntError};
use thiserror::Error;
@ -12,14 +13,14 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let commands = parse_commands(lines)?;
let mut rope = Rope::create(2);
let result = rope.run(&commands);
Ok(ResultType::Integer(result))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let commands = parse_commands(lines)?;
let mut rope = Rope::create(10);
let result = rope.run(&commands);
@ -39,12 +40,12 @@ enum RopeError {
StepParseError(#[from] ParseIntError),
}
fn parse_commands(lines: &[String]) -> Result<Vec<(Direction, usize)>, RopeError> {
lines.iter().map(parse_line).collect::<Result<_, _>>()
fn parse_commands(lines: &str) -> Result<Vec<(Direction, usize)>, RopeError> {
split_lines(lines).map(parse_line).try_collect()
}
fn parse_line(line: &String) -> Result<(Direction, usize), RopeError> {
match line.split_whitespace().collect::<Vec<_>>()[..] {
fn parse_line(line: &str) -> Result<(Direction, usize), RopeError> {
match line.split_whitespace().collect_vec()[..] {
[direction, steps] => {
let direction = match direction {
"U" => Direction::North,
@ -125,13 +126,13 @@ impl Rope {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(13);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -142,7 +143,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example02.txt")?;
let lines = read_string(day.get_day_number(), "example02.txt")?;
let expected = ResultType::Integer(36);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

25
src/days/day10/mod.rs
View file

@ -1,3 +1,5 @@
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use std::{num::ParseIntError, slice::Iter};
use thiserror::Error;
@ -11,18 +13,16 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let instructions = lines
.iter()
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let instructions = split_lines(lines)
.map(|line| Instruction::parse(line))
.collect::<Result<Vec<_>, _>>()?;
let result = CpuCycles::signal_strength(&instructions, &[20, 60, 100, 140, 180, 220]);
Ok(ResultType::Integer(result as i64))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let instructions = lines
.iter()
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let instructions = split_lines(lines)
.map(|line| Instruction::parse(line))
.collect::<Result<Vec<_>, _>>()?;
let result = CpuCycles::draw(&instructions);
@ -128,8 +128,9 @@ impl<'a> Iterator for CpuCycles<'a> {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
use itertools::Itertools;
#[test]
fn test_simple() -> Result<()> {
@ -144,7 +145,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(13140);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -155,8 +156,12 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Lines(read_lines(day.get_day_number(), "expected01.txt")?);
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected_lines = read_string(day.get_day_number(), "expected01.txt")?;
let expected_lines = split_lines(&expected_lines)
.map(|s| s.to_owned())
.collect_vec();
let expected = ResultType::Lines(expected_lines);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

37
src/days/day11/mod.rs
View file

@ -1,3 +1,5 @@
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use once_cell::sync::Lazy;
use regex::Regex;
@ -13,13 +15,13 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let troop = Troop::parse(lines)?;
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let troop = Troop::try_from(lines)?;
Ok(ResultType::Integer(troop.play(20)))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let troop = Troop::parse(lines)?;
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let troop = Troop::try_from(lines)?;
Ok(ResultType::Integer(troop.play_again(10_000)))
}
}
@ -90,7 +92,7 @@ impl Monkey {
}
pub fn parse_one(
iterator: &mut dyn Iterator<Item = &String>,
iterator: &mut dyn Iterator<Item = &str>,
) -> Result<Option<Monkey>, MonkeyError> {
if let Some(line) = iterator.next() {
let number: usize = Monkey::parse_line(&MONKEY, line)?.parse()?;
@ -142,16 +144,20 @@ struct Troop {
monkeys: Vec<Monkey>,
}
impl Troop {
pub fn parse(lines: &[String]) -> Result<Troop, MonkeyError> {
let mut iter = lines.iter();
impl TryFrom<&str> for Troop {
type Error = MonkeyError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
let mut iter = split_lines(value);
let mut monkeys = Vec::new();
while let Some(monkey) = Monkey::parse_one(&mut iter)? {
monkeys.push(monkey);
}
Ok(Troop { monkeys })
}
}
impl Troop {
fn do_play<F>(&self, rounds: usize, alter: F) -> i64
where
F: Fn(i64) -> i64,
@ -191,13 +197,14 @@ impl Troop {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_parse() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let mut lines = split_lines(&lines);
let expected = Monkey {
number: 0,
items: vec![79, 98],
@ -206,7 +213,7 @@ mod test {
good_monkey: 2,
bad_monkey: 3,
};
let result = Monkey::parse_one(&mut lines.iter())?.unwrap();
let result = Monkey::parse_one(&mut lines)?.unwrap();
assert_eq!(result, expected);
Ok(())
@ -215,9 +222,9 @@ mod test {
#[test]
fn test_parse_all() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = 4;
let result = Troop::parse(&lines)?;
let result = Troop::try_from(lines.as_str())?;
assert_eq!(result.monkeys.len(), expected);
Ok(())
@ -226,7 +233,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(10605);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -237,7 +244,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(2713310158);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

31
src/days/day12/mod.rs
View file

@ -1,6 +1,6 @@
use std::collections::{BinaryHeap, HashSet};
use crate::common::pos::Pos;
use crate::common::{file::split_lines, pos::Pos};
use super::template::{DayTrait, ResultType};
use thiserror::Error;
@ -14,13 +14,13 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let valley = Valley::parse(lines)?;
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let valley = Valley::try_from(lines)?;
Ok(ResultType::Integer(valley.walk()? as i64))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let valley = Valley::parse(lines)?;
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let valley = Valley::try_from(lines)?;
Ok(ResultType::Integer(valley.walk_short()? as i64))
}
}
@ -158,13 +158,16 @@ struct Valley {
width: usize,
}
impl Valley {
pub fn parse(lines: &[String]) -> Result<Valley, ValleyError> {
impl TryFrom<&str> for Valley {
type Error = ValleyError;
fn try_from(lines: &str) -> Result<Self, Self::Error> {
let lines = split_lines(lines);
let mut map = Vec::new();
let mut start = None;
let mut exit = None;
let mut valley_width = None;
for (y, row) in lines.iter().enumerate() {
for (y, row) in lines.enumerate() {
let mut height_row = Vec::new();
for (x, height_char) in row.chars().enumerate() {
match height_char {
@ -205,7 +208,9 @@ impl Valley {
width,
})
}
}
impl Valley {
fn get_height(&self, pos: Pos<usize>) -> char {
self.map[pos.y()][pos.x()]
}
@ -255,14 +260,14 @@ impl Valley {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_parse() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let valley = Valley::parse(&lines)?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let valley = Valley::try_from(lines.as_str())?;
assert_eq!(valley.width, 8);
assert_eq!(valley.start, Pos::new(0, 0));
assert_eq!(valley.exit, Pos::new(5, 2));
@ -273,7 +278,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(31);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -284,7 +289,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(29);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

21
src/days/day13/mod.rs
View file

@ -1,5 +1,7 @@
use std::cmp::Ordering;
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use itertools::Itertools;
use thiserror::Error;
@ -13,7 +15,7 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let packets = Packets::parse_all(lines)?;
let result: i64 = packets
.iter()
@ -30,7 +32,7 @@ impl DayTrait for Day {
Ok(ResultType::Integer(result))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let small = Packets::parse("[[2]]")?;
let large = Packets::parse("[[6]]")?;
let mut pos_small = 1;
@ -144,9 +146,8 @@ impl Packets {
Err(PacketError::PrematureEndOfInput)
}
pub fn parse_all(lines: &[String]) -> Result<Vec<Packets>, PacketError> {
lines
.iter()
pub fn parse_all(lines: &str) -> Result<Vec<Packets>, PacketError> {
split_lines(lines)
.filter(|line| !line.is_empty())
.map(|line| Packets::parse(line))
.collect::<Result<Vec<_>, _>>()
@ -156,7 +157,7 @@ impl Packets {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
@ -174,7 +175,7 @@ mod test {
#[test]
fn test_parse_all() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let result = Packets::parse_all(&lines)?;
assert_eq!(result.len(), 16);
Ok(())
@ -183,7 +184,7 @@ mod test {
#[test]
fn test_compare_all() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = vec![true, true, false, true, false, true, false, false];
let result = Packets::parse_all(&lines)?;
let compare = result
@ -199,7 +200,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(13);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -210,7 +211,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(140);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

95
src/days/day14/mod.rs
View file

@ -2,7 +2,7 @@ use itertools::Itertools;
use std::{collections::HashSet, num::ParseIntError};
use thiserror::Error;
use crate::common::pos::Pos;
use crate::common::{file::split_lines, pos::Pos};
use super::template::{DayTrait, ResultType};
@ -15,13 +15,13 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let cave = Cave::parse(lines)?;
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let cave = Cave::try_from(lines)?;
Ok(ResultType::Integer(cave.drop_bottomless() as i64))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let cave = Cave::parse(lines)?;
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let cave = Cave::try_from(lines)?;
Ok(ResultType::Integer(cave.drop_floor()))
}
}
@ -51,6 +51,46 @@ struct Cave {
height: i32,
}
impl TryFrom<&str> for Cave {
type Error = CaveError;
fn try_from(lines: &str) -> Result<Self, Self::Error> {
let lines = split_lines(lines);
let mut cave: HashSet<Pos<i32>> = HashSet::new();
for line in lines {
cave.extend(Cave::parse_one(line)?.iter());
}
if cave.is_empty() {
Err(CaveError::EmptyCave)
} else {
let mut max_x = i32::MIN;
let mut min_x = i32::MAX;
let mut max_y = i32::MIN;
for block in &cave {
if block.x() < min_x {
min_x = block.x();
}
if block.x() > max_x {
max_x = block.x();
}
if block.y() > max_y {
max_y = block.y()
}
}
let mut map = vec![vec![false; (max_x - min_x + 1) as usize]; (max_y + 1) as usize];
for block in cave {
map[block.y() as usize][(block.x() - min_x) as usize] = true;
}
Ok(Cave {
map,
min_x,
max_x,
height: max_y + 1,
})
}
}
}
impl Cave {
fn get(&self, map: &[Vec<bool>], pos: Pos<i32>) -> bool {
if pos.y() >= self.height || pos.x() < self.min_x || pos.x() > self.max_x {
@ -118,41 +158,6 @@ impl Cave {
Ok(blocks)
}
pub fn parse(lines: &[String]) -> Result<Cave, CaveError> {
let mut cave: HashSet<Pos<i32>> = HashSet::new();
for line in lines {
cave.extend(Cave::parse_one(line)?.iter());
}
if cave.is_empty() {
Err(CaveError::EmptyCave)
} else {
let mut max_x = i32::MIN;
let mut min_x = i32::MAX;
let mut max_y = i32::MIN;
for block in &cave {
if block.x() < min_x {
min_x = block.x();
}
if block.x() > max_x {
max_x = block.x();
}
if block.y() > max_y {
max_y = block.y()
}
}
let mut map = vec![vec![false; (max_x - min_x + 1) as usize]; (max_y + 1) as usize];
for block in cave {
map[block.y() as usize][(block.x() - min_x) as usize] = true;
}
Ok(Cave {
map,
min_x,
max_x,
height: max_y + 1,
})
}
}
pub fn drop_bottomless(&self) -> u32 {
let mut drops = 0;
let mut filled_map = self.map.to_vec();
@ -243,7 +248,7 @@ impl Cave {
#[cfg(test)]
mod test {
use super::*;
use crate::{common::file::read_lines, hashset};
use crate::{common::file::read_string, hashset};
use anyhow::Result;
#[test]
@ -259,8 +264,8 @@ mod test {
#[test]
fn test_parse_all() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let result = Cave::parse(&lines)?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let result = Cave::try_from(lines.as_str())?;
assert_eq!(result.min_x, 494);
assert_eq!(result.max_x, 503);
assert_eq!(result.height, 10);
@ -271,7 +276,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(24);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -282,7 +287,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(93);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

25
src/days/day15/mod.rs
View file

@ -1,5 +1,5 @@
use super::template::{DayTrait, ResultType};
use crate::common::pos::Pos;
use crate::common::{file::split_lines, pos::Pos};
use itertools::Itertools;
use once_cell::sync::Lazy;
use regex::Regex;
@ -15,14 +15,22 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let lines = split_lines(lines).collect_vec();
if lines.len() < 2 {
Err(SensorError::ToFewLines)?;
}
let row = lines[0].parse()?;
let (sensors, beacons) = Day::parse_all(&lines[1..])?;
let result = Day::count_coverage_at(&sensors, &beacons, row);
Ok(ResultType::Integer(result))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let lines = split_lines(lines).collect_vec();
if lines.len() < 2 {
Err(SensorError::ToFewLines)?;
}
let (sensors, _) = Day::parse_all(&lines[1..])?;
let mid_lines = Day::dividing_lines(&sensors);
let points = mid_lines
@ -43,7 +51,7 @@ impl DayTrait for Day {
}
impl Day {
fn parse_all(lines: &[String]) -> Result<(HashSet<Sensor>, HashSet<Pos<i64>>), SensorError> {
fn parse_all(lines: &[&str]) -> Result<(HashSet<Sensor>, HashSet<Pos<i64>>), SensorError> {
let mut sensors = HashSet::new();
let mut beacons = HashSet::new();
for line in lines {
@ -91,6 +99,9 @@ enum SensorError {
#[error("Did not find exactly one point for the sensor: {0}")]
NotExactlyOneResult(usize),
#[error("Too few lines in input.txt")]
ToFewLines,
}
#[derive(Debug)]
@ -256,7 +267,7 @@ impl Sensor {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_parse() -> Result<()> {
@ -295,7 +306,7 @@ mod test {
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(26);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -306,7 +317,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(56000011);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

37
src/days/day16/mod.rs
View file

@ -5,6 +5,8 @@ use std::iter::Sum;
use std::ops::{Add, Deref, Mul, Sub};
use std::{collections::BinaryHeap, num::ParseIntError};
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
use const_format::concatcp;
use itertools::Itertools;
@ -21,13 +23,13 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let system = ValveSystem::build(lines, "AA")?;
let result = system.maximum_flow(system.single_actor(Time(30)))?;
Ok(ResultType::Integer(*result))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let system = ValveSystem::build(lines, "AA")?;
let result = system.maximum_flow(system.double_actor(Time(26)))?;
Ok(ResultType::Integer(*result))
@ -264,10 +266,9 @@ struct ValveSystem {
}
impl ValveSystem {
fn build(lines: &[String], start: &str) -> Result<ValveSystem, ValveError> {
let mut raw = lines
.iter()
.map(|line| RawValve::try_from(line.as_str()))
fn build(lines: &str, start: &str) -> Result<ValveSystem, ValveError> {
let mut raw = split_lines(lines)
.map(|line| RawValve::try_from(line))
.collect::<Result<Vec<_>, _>>()?;
raw.sort_unstable_by_key(|valve| valve.id);
@ -912,13 +913,13 @@ impl Hash for HashableState {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(1651);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -949,7 +950,7 @@ mod test {
#[test]
fn parse_system() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let system = ValveSystem::build(&lines, "AA")?;
assert_eq!(10, system.len());
@ -966,7 +967,7 @@ mod test {
#[test]
fn single_state_init() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let system = ValveSystem::build(&lines, "AA")?;
let actor = system.single_actor(Time(5));
@ -980,7 +981,7 @@ mod test {
#[test]
fn next_single_actor_states() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let system = ValveSystem::build(&lines, "AA")?;
let actor = system.single_actor(Time(5));
let state = ValveState::init(&system, actor);
@ -1002,7 +1003,7 @@ mod test {
#[test]
fn next_single_states() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let system = ValveSystem::build(&lines, "AA")?;
let actor = system.single_actor(Time(6));
let state = ValveState::init(&system, actor);
@ -1023,7 +1024,7 @@ mod test {
#[test]
fn double_state_init() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let system = ValveSystem::build(&lines, "AA")?;
let actor = system.double_actor(Time(5));
let state = ValveState::init(&system, actor);
@ -1037,7 +1038,7 @@ mod test {
#[test]
fn next_double_actor_states() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let system = ValveSystem::build(&lines, "AA")?;
let actor = system.double_actor(Time(5));
let state = ValveState::init(&system, actor);
@ -1068,7 +1069,7 @@ mod test {
#[test]
fn next_double_states() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let system = ValveSystem::build(&lines, "AA")?;
let actor = system.double_actor(Time(5));
let state = ValveState::init(&system, actor);
@ -1090,7 +1091,7 @@ mod test {
#[test]
fn special_double_stats() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let system = ValveSystem::build(&lines, "AA")?;
let actor = DoubleActor(DoubleWork::Simultaneous(Index(1), Index(7), Time(19)));
let state = ValveState {
@ -1132,7 +1133,7 @@ mod test {
#[test]
fn double_long_run() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let system = ValveSystem::build(&lines, "AA")?;
let actor = DoubleActor(DoubleWork::Sequential(Index(3), Time(5), Index(7), Time(2)));
let state = ValveState {
@ -1158,7 +1159,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(1707);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

80
src/days/day17/mod.rs
View file

@ -1,6 +1,6 @@
use std::{cell::Cell, marker::PhantomData, ops::Index};
use crate::common::file::read_lines;
use crate::common::file::{read_string, split_lines};
use super::template::{DayTrait, ResultType};
use itertools::Itertools;
@ -16,16 +16,28 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let pushes = Dispenser::new(lines[0].chars().map(|c| Push::parse(c)).try_collect()?);
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let pushes = Dispenser::new(
lines
.trim_end()
.chars()
.map(|c| Push::parse(c))
.try_collect()?,
)?;
let result = Day::run(pushes, 2022)?;
Ok(ResultType::Integer(result as i64))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let pushes = Dispenser::new(lines[0].chars().map(|c| Push::parse(c)).try_collect()?);
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let pushes = Dispenser::new(
lines
.trim_end()
.chars()
.map(|c| Push::parse(c))
.try_collect()?,
)?;
let result = Day::run(pushes, 1000000000000)?;
@ -35,8 +47,8 @@ impl DayTrait for Day {
impl Day {
fn run(push_cycle: Dispenser<Push>, max_cycles: i64) -> Result<i64, RockError> {
let raw = read_lines(DAY_NUMBER, "blocks.txt")?;
let rock_cycle = Dispenser::new(Rock::parse(&raw)?);
let raw = read_string(DAY_NUMBER, "blocks.txt")?;
let rock_cycle = Dispenser::new(Rock::parse(&raw)?)?;
let mut cycle = 0;
let mut stack = Stack::new();
@ -114,6 +126,9 @@ enum RockError {
#[error("Unknown direction: {0}")]
UnknownDirection(char),
#[error("A Dispenser must never be empty")]
EmptyDispenserNotAllowed,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
@ -158,9 +173,8 @@ impl Rock {
})
}
pub fn parse(lines: &[String]) -> Result<Vec<Rock>, RockError> {
lines
.iter()
pub fn parse(lines: &str) -> Result<Vec<Rock>, RockError> {
split_lines(lines)
.batching(|it| {
let blocks = it
.skip_while(|line| line.is_empty())
@ -330,11 +344,15 @@ where
}
impl<'a, T> Dispenser<'a, T> {
pub fn new(data: Vec<T>) -> Self {
Dispenser {
data,
current: Cell::new(0),
_marker: PhantomData,
pub fn new(data: Vec<T>) -> Result<Self, RockError> {
if data.is_empty() {
Err(RockError::EmptyDispenserNotAllowed)
} else {
Ok(Dispenser {
data,
current: Cell::new(0),
_marker: PhantomData,
})
}
}
@ -351,13 +369,13 @@ impl<'a, T> Dispenser<'a, T> {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(3068);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -368,7 +386,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(1514285714288);
let result = day.part2(&lines)?;
assert_eq!(result, expected);
@ -379,7 +397,7 @@ mod test {
#[test]
fn read_blocks() -> Result<()> {
let day = Day {};
let raw = read_lines(day.get_day_number(), "blocks.txt")?;
let raw = read_string(day.get_day_number(), "blocks.txt")?;
let rocks = Rock::parse(&raw)?;
let expected = Rock::new(vec![vec![true]; 4])?;
assert_eq!(rocks[3], expected);
@ -396,10 +414,16 @@ mod test {
#[test]
fn drop_one() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let pushes = Dispenser::new(lines[0].chars().map(|c| Push::parse(c)).try_collect()?);
let raw = read_lines(day.get_day_number(), "blocks.txt")?;
let rocks = Dispenser::new(Rock::parse(&raw)?);
let lines = read_string(day.get_day_number(), "example01.txt")?;
let pushes = Dispenser::new(
lines
.trim_end()
.chars()
.map(|c| Push::parse(c))
.try_collect()?,
)?;
let raw = read_string(day.get_day_number(), "blocks.txt")?;
let rocks = Dispenser::new(Rock::parse(&raw)?)?;
let mut stack = Stack::new();
stack.one_rock(rocks.next(), &pushes);
@ -412,8 +436,14 @@ mod test {
#[test]
fn drop_some() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let pushes = Dispenser::new(lines[0].chars().map(|c| Push::parse(c)).try_collect()?);
let lines = read_string(day.get_day_number(), "example01.txt")?;
let pushes = Dispenser::new(
lines
.trim_end()
.chars()
.map(|c| Push::parse(c))
.try_collect()?,
)?;
let result = Day::run(pushes, 10)?;

27
src/days/day18/mod.rs
View file

@ -2,6 +2,8 @@ use itertools::Itertools;
use std::{collections::HashSet, num::ParseIntError};
use thiserror::Error;
use crate::common::file::split_lines;
use super::template::{DayTrait, ResultType};
const DAY_NUMBER: usize = 18;
@ -13,13 +15,13 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let blob = Blob::parse(lines)?;
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
let blob = Blob::try_from(lines)?;
Ok(ResultType::Integer(blob.count_sides()))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let blob = Blob::parse(lines)?;
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
let blob = Blob::try_from(lines)?;
Ok(ResultType::Integer(blob.count_outside()))
}
}
@ -131,15 +133,18 @@ struct Blob {
droplets: HashSet<Droplet>,
}
impl Blob {
fn parse(lines: &[String]) -> Result<Self, DropletError> {
let droplets = lines
.iter()
impl TryFrom<&str> for Blob {
type Error = DropletError;
fn try_from(lines: &str) -> Result<Self, Self::Error> {
let droplets = split_lines(lines)
.map(|line| Droplet::parse(line))
.try_collect()?;
Ok(Blob { droplets })
}
}
impl Blob {
fn extent(&self) -> Option<Ranges> {
if self.droplets.is_empty() {
return None;
@ -198,13 +203,13 @@ impl Blob {
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(64);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -215,7 +220,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Integer(58);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

19
src/days/day__/mod.rs
View file

@ -1,6 +1,7 @@
use super::template::{DayTrait, ResultType};
use thiserror::Error;
const DAY_NUMBER: usize = 0;
const DAY_NUMBER: usize = todo!();
pub struct Day;
@ -9,25 +10,31 @@ impl DayTrait for Day {
DAY_NUMBER
}
fn part1(&self, _lines: &[String]) -> anyhow::Result<ResultType> {
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
Ok(ResultType::Nothing)
}
fn part2(&self, _lines: &[String]) -> anyhow::Result<ResultType> {
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
Ok(ResultType::Nothing)
}
}
#[derive(Debug, Error)]
enum DayError {
#[error("Dummy")]
Dummy,
}
#[cfg(test)]
mod test {
use super::*;
use crate::common::file::read_lines;
use crate::common::file::read_string;
use anyhow::Result;
#[test]
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Nothing;
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -38,7 +45,7 @@ mod test {
#[test]
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let lines = read_string(day.get_day_number(), "example01.txt")?;
let expected = ResultType::Nothing;
let result = day.part2(&lines)?;
assert_eq!(result, expected);

4
src/days/template.rs
View file

@ -11,6 +11,6 @@ pub enum ResultType {
pub trait DayTrait {
fn get_day_number(&self) -> usize;
fn part1(&self, lines: &[String]) -> Result<ResultType>;
fn part2(&self, lines: &[String]) -> Result<ResultType>;
fn part1(&self, lines: &str) -> Result<ResultType>;
fn part2(&self, lines: &str) -> Result<ResultType>;
}

6
src/main.rs
View file

@ -3,7 +3,7 @@ mod days;
mod macros;
use anyhow::Result;
use common::file::read_lines;
use common::file::read_string;
use days::{day_provider, DayTrait, ResultType};
use std::{
env,
@ -47,7 +47,7 @@ fn output(day: usize, part: usize, result: ResultType, time: Duration) {
}
}
fn run_part(day: &dyn DayTrait, is_part1: bool, lines: &[String]) -> Result<Duration> {
fn run_part(day: &dyn DayTrait, is_part1: bool, lines: &str) -> Result<Duration> {
let now = Instant::now();
let result = if is_part1 {
day.part1(lines)?
@ -70,7 +70,7 @@ fn run_part(day: &dyn DayTrait, is_part1: bool, lines: &[String]) -> Result<Dura
}
fn run(day: &dyn DayTrait, part1: bool, part2: bool) -> Result<Duration> {
let lines = read_lines(day.get_day_number(), "input.txt")?;
let lines = read_string(day.get_day_number(), "input.txt")?;
let elapsed1 = if part1 {
run_part(day, true, &lines)?
} else {