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

applied clippy

Browse source
This commit is contained in:
Ruediger Ludwig 2023-01-29 19:12:22 +01:00
parent 33eb92e9d1
commit 4e08117ed0
16 changed files with 205 additions and 504 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -16,13 +16,13 @@ impl DayTrait for Day {
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let vector = Day::parse(lines)?;
let max = vector.iter().max().ok_or(CalorieError::Empty)?;
Ok(ResultType::IntResult(*max))
Ok(ResultType::Integer(*max))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let vector = Day::parse(lines)?;
let sum = vector.iter().sorted_by(|a, b| Ord::cmp(b, a)).take(3).sum();
Ok(ResultType::IntResult(sum))
Ok(ResultType::Integer(sum))
}
}
@ -32,7 +32,7 @@ impl Day {
.iter()
.batching(|it| {
let result = it
.take_while(|line| line.len() != 0)
.take_while(|line| !line.is_empty())
.map(|line| line.parse::<i64>())
.collect::<Result<Vec<_>, _>>()
.map(|lst: _| lst.iter().sum::<i64>());
@ -64,7 +64,7 @@ mod test {
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let expected = ResultType::IntResult(24_000);
let expected = ResultType::Integer(24_000);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -75,7 +75,7 @@ mod test {
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let expected = ResultType::IntResult(45_000);
let expected = ResultType::Integer(45_000);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

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

@ -15,25 +15,25 @@ impl DayTrait for Day {
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
.map(|line| RPS::parse_line(&line))
.map(|line| Rps::parse_line(line))
.collect::<Result<Vec<_>, _>>()?
.into_iter()
.map(|(first, second)| second.asses_pair(&first))
.sum();
Ok(ResultType::IntResult(sum))
Ok(ResultType::Integer(sum))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
.map(|line| Strategy::parse_line(&line))
.map(|line| Strategy::parse_line(line))
.collect::<Result<Vec<_>, _>>()?
.into_iter()
.map(|(first, second)| second.fullfill(&first).asses_pair(&first))
.sum();
Ok(ResultType::IntResult(sum))
Ok(ResultType::Integer(sum))
}
}
@ -47,29 +47,29 @@ enum RPSError {
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
enum RPS {
enum Rps {
Rock,
Paper,
Scissors,
}
impl RPS {
impl Rps {
pub fn parse_line(line: &str) -> Result<(Self, Self), RPSError> {
let mut parts = line.split(" ");
let mut parts = line.split(' ');
let (Some(first), Some(second)) = (parts.next(), parts.next()) else {
Err(RPSError::IllegalLine(line.to_owned()))?
};
let first = RPS::try_from(first)?;
let second = RPS::try_from(second)?;
let first = Rps::try_from(first)?;
let second = Rps::try_from(second)?;
Ok((first, second))
}
pub fn value(&self) -> i64 {
match self {
RPS::Rock => 1,
RPS::Paper => 2,
RPS::Scissors => 3,
Rps::Rock => 1,
Rps::Paper => 2,
Rps::Scissors => 3,
}
}
@ -84,13 +84,13 @@ impl RPS {
}
}
impl PartialOrd for RPS {
impl PartialOrd for Rps {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
match (self, other) {
(RPS::Rock, RPS::Paper) | (RPS::Paper, RPS::Scissors) | (RPS::Scissors, RPS::Rock) => {
(Rps::Rock, Rps::Paper) | (Rps::Paper, Rps::Scissors) | (Rps::Scissors, Rps::Rock) => {
Some(Ordering::Less)
}
(RPS::Rock, RPS::Scissors) | (RPS::Paper, RPS::Rock) | (RPS::Scissors, RPS::Paper) => {
(Rps::Rock, Rps::Scissors) | (Rps::Paper, Rps::Rock) | (Rps::Scissors, Rps::Paper) => {
Some(Ordering::Greater)
}
_ => Some(Ordering::Equal),
@ -98,14 +98,14 @@ impl PartialOrd for RPS {
}
}
impl TryFrom<&str> for RPS {
impl TryFrom<&str> for Rps {
type Error = RPSError;
fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {
match value {
"A" | "X" => Ok(RPS::Rock),
"B" | "Y" => Ok(RPS::Paper),
"C" | "Z" => Ok(RPS::Scissors),
"A" | "X" => Ok(Rps::Rock),
"B" | "Y" => Ok(Rps::Paper),
"C" | "Z" => Ok(Rps::Scissors),
_ => Err(RPSError::ParseError(value.to_owned())),
}
}
@ -118,23 +118,23 @@ enum Strategy {
}
impl Strategy {
pub fn parse_line(line: &str) -> Result<(RPS, Self), RPSError> {
let mut parts = line.split(" ");
pub fn parse_line(line: &str) -> Result<(Rps, Self), RPSError> {
let mut parts = line.split(' ');
let (Some(first), Some(second)) = (parts.next(), parts.next()) else {
Err(RPSError::IllegalLine(line.to_owned()))?
};
let first = RPS::try_from(first)?;
let first = Rps::try_from(first)?;
let second = Strategy::try_from(second)?;
Ok((first, second))
}
pub fn fullfill(&self, other: &RPS) -> RPS {
pub fn fullfill(&self, other: &Rps) -> Rps {
match (other, self) {
(_, Strategy::Draw) => *other,
(RPS::Rock, Strategy::Win) | (RPS::Scissors, Strategy::Loose) => RPS::Paper,
(RPS::Paper, Strategy::Win) | (RPS::Rock, Strategy::Loose) => RPS::Scissors,
(RPS::Scissors, Strategy::Win) | (RPS::Paper, Strategy::Loose) => RPS::Rock,
(Rps::Rock, Strategy::Win) | (Rps::Scissors, Strategy::Loose) => Rps::Paper,
(Rps::Paper, Strategy::Win) | (Rps::Rock, Strategy::Loose) => Rps::Scissors,
(Rps::Scissors, Strategy::Win) | (Rps::Paper, Strategy::Loose) => Rps::Rock,
}
}
}
@ -161,8 +161,8 @@ mod test {
#[test]
fn test_parse() -> Result<()> {
let input = "A Y";
let expected = (RPS::Rock, RPS::Paper);
let result = RPS::parse_line(input)?;
let expected = (Rps::Rock, Rps::Paper);
let result = Rps::parse_line(input)?;
assert_eq!(result, expected);
Ok(())
@ -170,8 +170,8 @@ mod test {
#[test]
fn test_assess() -> Result<()> {
let first = RPS::Scissors;
let second = RPS::Paper;
let first = Rps::Scissors;
let second = Rps::Paper;
let expected = 9;
let result = first.asses_pair(&second);
assert_eq!(result, expected);
@ -183,7 +183,7 @@ mod test {
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let expected = ResultType::IntResult(15);
let expected = ResultType::Integer(15);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -193,7 +193,7 @@ mod test {
#[test]
fn test_parse_strategy() -> Result<()> {
let input = "A Y";
let expected = (RPS::Rock, Strategy::Draw);
let expected = (Rps::Rock, Strategy::Draw);
let result = Strategy::parse_line(input)?;
assert_eq!(result, expected);
@ -202,9 +202,9 @@ mod test {
#[test]
fn test_assess_stragety() -> Result<()> {
let first = RPS::Scissors;
let first = Rps::Scissors;
let second = Strategy::Win;
let expected = RPS::Rock;
let expected = Rps::Rock;
let result = second.fullfill(&first);
assert_eq!(result, expected);
@ -215,7 +215,7 @@ mod test {
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let expected = ResultType::NoResult;
let expected = ResultType::Nothing;
let result = day.part2(&lines)?;
assert_eq!(result, expected);

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

@ -14,11 +14,11 @@ impl DayTrait for Day {
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
.map(|line| find_double(&line))
.map(|line| find_double(line))
.map_ok(priority)
.flatten_ok()
.fold_ok(0, |a, b| a + b)?;
Ok(ResultType::IntResult(sum))
Ok(ResultType::Integer(sum))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
@ -30,7 +30,7 @@ impl DayTrait for Day {
.map_ok(priority)
.flatten_ok()
.fold_ok(0, |a, b| a + b)?;
Ok(ResultType::IntResult(sum))
Ok(ResultType::Integer(sum))
}
}
@ -71,7 +71,7 @@ fn find_double(content: &str) -> Result<char, RucksackError> {
Err(RucksackError::NoDoubleFound)?
}
fn find_badge<'a>(elves: &[&String]) -> Result<char, RucksackError> {
fn find_badge(elves: &[&String]) -> Result<char, RucksackError> {
if elves.len() < 2 {
return Err(RucksackError::NeedAtLeastTwo);
};
@ -109,7 +109,7 @@ mod test {
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let expected = ResultType::IntResult(157);
let expected = ResultType::Integer(157);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -120,7 +120,7 @@ mod test {
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let expected = ResultType::IntResult(70);
let expected = ResultType::Integer(70);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

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

@ -15,19 +15,19 @@ impl DayTrait for Day {
fn part1(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
.map(|line| parse(&line))
.map(|line| parse(line))
.filter_ok(fully_contained)
.fold_ok(0i64, |a, _| a + 1)?;
Ok(ResultType::IntResult(sum))
Ok(ResultType::Integer(sum))
}
fn part2(&self, lines: &[String]) -> anyhow::Result<ResultType> {
let sum = lines
.iter()
.map(|line| parse(&line))
.map(|line| parse(line))
.filter_ok(overlaps)
.fold_ok(0i64, |a, _| a + 1)?;
Ok(ResultType::IntResult(sum))
Ok(ResultType::Integer(sum))
}
}
@ -94,7 +94,7 @@ mod test {
fn test_part1() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let expected = ResultType::IntResult(2);
let expected = ResultType::Integer(2);
let result = day.part1(&lines)?;
assert_eq!(result, expected);
@ -105,7 +105,7 @@ mod test {
fn test_part2() -> Result<()> {
let day = Day {};
let lines = read_lines(day.get_day_number(), "example01.txt")?;
let expected = ResultType::IntResult(4);
let expected = ResultType::Integer(4);
let result = day.part2(&lines)?;
assert_eq!(result, expected);

8
src/days/template.rs
View file

@ -3,10 +3,10 @@ use anyhow::Result;
#[allow(dead_code)]
#[derive(Debug, PartialEq, Eq)]
pub enum ResultType {
IntResult(i64),
StringResult(String),
LinesResult(Vec<String>),
NoResult,
Integer(i64),
String(String),
Lines(Vec<String>),
Nothing,
}
pub trait DayTrait {