kamov/advent-of-code
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

2022 rust refactor

Browse source
This commit is contained in:
Maciej Jur 2022-12-07 20:05:33 +01:00
parent 34ab9c60dc
commit 674d5b9992
7 changed files with 71 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
2022/rust/src/solutions/day01.rs
View file

@ -3,7 +3,7 @@ use crate::utils;
pub fn run() -> () { pub fn run() -> () {
let data = parse_data(utils::read_lines(utils::Source::Day(1))); let data = parse_data(&utils::read_lines(utils::Source::Day(1)));
println!("Day 1"); println!("Day 1");
println!("Part 1: {}", solve1(&data)); println!("Part 1: {}", solve1(&data));
@ -41,14 +41,15 @@ fn solve2(data: &Vec<Vec<i32>>) -> i32 {
three.iter().sum() three.iter().sum()
} }
fn parse_data(data: Vec<String>) -> Vec<Vec<i32>> { fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<Vec<i32>> {
data.iter() data.iter()
.fold(vec![vec![]], | mut acc, next| { .fold(vec![vec![]], | mut acc, next| {
if next.len() == 0 { let s = next.as_ref();
if s.len() == 0 {
acc.push(Vec::new()) acc.push(Vec::new())
} }
else { else {
let number: i32 = next.parse().expect("Parse error"); let number: i32 = s.parse().expect("Parse error");
acc.last_mut().and_then(|last| Some(last.push(number))); acc.last_mut().and_then(|last| Some(last.push(number)));
} }
acc acc
@ -60,26 +61,23 @@ fn parse_data(data: Vec<String>) -> Vec<Vec<i32>> {
mod tests { mod tests {
use super::*; use super::*;
fn data() -> Vec<String> { static DATA: &[&str; 14] = &[
vec![ "1000", "2000", "3000", "",
"1000", "2000", "3000", "", "4000", "",
"4000", "", "5000", "6000", "",
"5000", "6000", "", "7000", "8000", "9000", "",
"7000", "8000", "9000", "", "10000",
"10000", ];
]
.into_iter().map(String::from).collect()
}
#[test] #[test]
fn part1() { fn part1() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(24000, solve1(&data)); assert_eq!(24000, solve1(&data));
} }
#[test] #[test]
fn part2() { fn part2() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(45000, solve2(&data)); assert_eq!(45000, solve2(&data));
} }
} }

14
2022/rust/src/solutions/day02.rs
View file

@ -3,7 +3,7 @@ use crate::utils;
pub fn run() -> () { pub fn run() -> () {
let data = parse_data(utils::read_lines(utils::Source::Day(2))); let data = parse_data(&utils::read_lines(utils::Source::Day(2)));
println!("Day 2"); println!("Day 2");
println!("Part 1: {}", solve1(&data)); println!("Part 1: {}", solve1(&data));
@ -113,9 +113,10 @@ fn solve2(data: &[(char, char)]) -> i32 {
}) })
} }
fn parse_data(data: Vec<String>) -> Vec<(char, char)> { fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<(char, char)> {
data.into_iter() data.into_iter()
.map(|line| { .map(|line| {
let line = line.as_ref();
let mut chars = line.chars(); let mut chars = line.chars();
(chars.next().unwrap(), chars.last().unwrap()) (chars.next().unwrap(), chars.last().unwrap())
}) })
@ -127,20 +128,17 @@ fn parse_data(data: Vec<String>) -> Vec<(char, char)> {
mod tests { mod tests {
use super::*; use super::*;
fn data() -> Vec<String> { static DATA: &[&str; 3] = &["A Y", "B X", "C Z"];
vec!["A Y", "B X", "C Z"]
.into_iter().map(String::from).collect()
}
#[test] #[test]
fn part1() { fn part1() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(15, solve1(&data)); assert_eq!(15, solve1(&data));
} }
#[test] #[test]
fn part2() { fn part2() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(12, solve2(&data)); assert_eq!(12, solve2(&data));
} }
} }

28
2022/rust/src/solutions/day03.rs
View file

@ -4,7 +4,7 @@ use crate::utils;
pub fn run() -> () { pub fn run() -> () {
let data = parse_data(utils::read_lines(utils::Source::Day(3))); let data = parse_data(&utils::read_lines(utils::Source::Day(3)));
println!("Day 3"); println!("Day 3");
println!("Part 1: {}", solve1(&data)); println!("Part 1: {}", solve1(&data));
@ -48,9 +48,10 @@ fn find_intersection(sets: &[HashSet<char>]) -> char {
.unwrap() .unwrap()
} }
fn parse_data(data: Vec<String>) -> Vec<(HashSet<char>, HashSet<char>)> { fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<(HashSet<char>, HashSet<char>)> {
data.iter() data.iter()
.map(|str| { .map(|str| {
let str = str.as_ref();
let length = str.len(); let length = str.len();
let left = &str[..length / 2]; let left = &str[..length / 2];
let right = &str[length / 2..]; let right = &str[length / 2..];
@ -64,27 +65,24 @@ fn parse_data(data: Vec<String>) -> Vec<(HashSet<char>, HashSet<char>)> {
mod tests { mod tests {
use super::*; use super::*;
fn data() -> Vec<String> { static DATA: &[&str; 6] = &[
vec![ "vJrwpWtwJgWrhcsFMMfFFhFp",
"vJrwpWtwJgWrhcsFMMfFFhFp", "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL",
"jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL", "PmmdzqPrVvPwwTWBwg",
"PmmdzqPrVvPwwTWBwg", "wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn",
"wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn", "ttgJtRGJQctTZtZT",
"ttgJtRGJQctTZtZT", "CrZsJsPPZsGzwwsLwLmpwMDw"
"CrZsJsPPZsGzwwsLwLmpwMDw" ];
]
.into_iter().map(String::from).collect()
}
#[test] #[test]
fn part1() { fn part1() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(157, solve1(&data)); assert_eq!(157, solve1(&data));
} }
#[test] #[test]
fn part2() { fn part2() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(70, solve2(&data)); assert_eq!(70, solve2(&data));
} }
} }

14
2022/rust/src/solutions/day04.rs
View file

@ -4,7 +4,7 @@ use crate::utils;
pub fn run() -> () { pub fn run() -> () {
let data = parse_data(utils::read_lines(utils::Source::Day(4))); let data = parse_data(&utils::read_lines(utils::Source::Day(4)));
println!("Day 4"); println!("Day 4");
println!("Part 1: {}", solve1(&data)); println!("Part 1: {}", solve1(&data));
@ -29,10 +29,11 @@ fn solve2(data: &[((i32, i32), (i32, i32))]) -> usize {
} }
fn parse_data(data: Vec<String>) -> Vec<((i32, i32), (i32, i32))> { fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<((i32, i32), (i32, i32))> {
let re = Regex::new(r#"^(\d+)-(\d+),(\d+)-(\d+)$"#).unwrap(); let re = Regex::new(r#"^(\d+)-(\d+),(\d+)-(\d+)$"#).unwrap();
data.iter() data.iter()
.map(|s| { .map(|s| {
let s = s.as_ref();
let c = re.captures(s).unwrap(); let c = re.captures(s).unwrap();
( (
( (
@ -53,20 +54,17 @@ fn parse_data(data: Vec<String>) -> Vec<((i32, i32), (i32, i32))> {
mod tests { mod tests {
use super::*; use super::*;
fn data() -> Vec<String> { static DATA: &[&str; 6] = &["2-4,6-8", "2-3,4-5", "5-7,7-9", "2-8,3-7", "6-6,4-6", "2-6,4-8"];
vec!["2-4,6-8", "2-3,4-5", "5-7,7-9", "2-8,3-7", "6-6,4-6", "2-6,4-8"]
.into_iter().map(String::from).collect()
}
#[test] #[test]
fn part1() { fn part1() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(2, solve1(&data)); assert_eq!(2, solve1(&data));
} }
#[test] #[test]
fn part2() { fn part2() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(4, solve2(&data)); assert_eq!(4, solve2(&data));
} }
} }

36
2022/rust/src/solutions/day05.rs
View file

@ -4,7 +4,7 @@ use crate::utils;
pub fn run() -> () { pub fn run() -> () {
let data = parse_data(utils::read_lines(utils::Source::Day(5))); let data = parse_data(&utils::read_lines(utils::Source::Day(5)));
println!("Day 5"); println!("Day 5");
println!("Part 1: {}", solve1(&data)); println!("Part 1: {}", solve1(&data));
@ -42,11 +42,12 @@ fn solve2((stacks, actions): &Data) -> String {
} }
fn parse_data(data: Vec<String>) -> Data { fn parse_data<T: AsRef<str>>(data: &[T]) -> Data {
let stacks = { let stacks = {
let re = Regex::new(r#"( {3}|[\[\w\]]{3}) ?"#).unwrap(); let re = Regex::new(r#"( {3}|[\[\w\]]{3}) ?"#).unwrap();
let mut boxes = data.iter() let mut boxes = data.iter()
.map_while(|s| { .map_while(|s| {
let s = s.as_ref();
let cap = re.find_iter(s) let cap = re.find_iter(s)
.map(|x| x.as_str().trim()) .map(|x| x.as_str().trim())
.enumerate() .enumerate()
@ -77,7 +78,7 @@ fn parse_data(data: Vec<String>) -> Data {
let actions = { let actions = {
let re = Regex::new(r#"^move (\d+) from (\d+) to (\d+)$"#).unwrap(); let re = Regex::new(r#"^move (\d+) from (\d+) to (\d+)$"#).unwrap();
data.iter() data.iter()
.filter_map(|str| re.captures(str)) .filter_map(|str| re.captures(str.as_ref()))
.map(|cap| ( .map(|cap| (
cap.get(1).unwrap().as_str().parse().unwrap(), cap.get(1).unwrap().as_str().parse().unwrap(),
cap.get(2).unwrap().as_str().parse::<usize>().unwrap() - 1, cap.get(2).unwrap().as_str().parse::<usize>().unwrap() - 1,
@ -93,30 +94,27 @@ fn parse_data(data: Vec<String>) -> Data {
mod tests { mod tests {
use super::*; use super::*;
fn data() -> Vec<String> { static DATA: &[&str; 9] = &[
vec![ " [D] ",
" [D] ", "[N] [C] ",
"[N] [C] ", "[Z] [M] [P]",
"[Z] [M] [P]", " 1 2 3 ",
" 1 2 3 ", "",
"", "move 1 from 2 to 1",
"move 1 from 2 to 1", "move 3 from 1 to 3",
"move 3 from 1 to 3", "move 2 from 2 to 1",
"move 2 from 2 to 1", "move 1 from 1 to 2",
"move 1 from 1 to 2", ];
]
.into_iter().map(String::from).collect()
}
#[test] #[test]
fn part1() { fn part1() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!("CMZ", solve1(&data)); assert_eq!("CMZ", solve1(&data));
} }
#[test] #[test]
fn part2() { fn part2() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!("MCD", solve2(&data)); assert_eq!("MCD", solve2(&data));
} }
} }

22
2022/rust/src/solutions/day06.rs
View file

@ -4,7 +4,7 @@ use crate::utils;
pub fn run() -> () { pub fn run() -> () {
let data = parse_data(utils::read_lines(utils::Source::Day(6))); let data = parse_data(&utils::read_lines(utils::Source::Day(6)));
println!("Day 6"); println!("Day 6");
println!("Part 1: {}", solve1(&data)); println!("Part 1: {}", solve1(&data));
@ -49,10 +49,10 @@ fn marker_bitwise(data: &[char], window_len: usize) -> usize {
} }
fn parse_data(data: Vec<String>) -> Vec<char> { fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<char> {
data.into_iter() data.iter()
.next() .next()
.map(|char| char.chars().collect()) .map(|char| char.as_ref().chars().collect())
.unwrap() .unwrap()
} }
@ -61,22 +61,20 @@ fn parse_data(data: Vec<String>) -> Vec<char> {
mod tests { mod tests {
use super::*; use super::*;
fn data() -> Vec<String> { static DATA: &[&str; 1] = &[
vec![ "mjqjpqmgbljsphdztnvjfqwrcgsmlb"
"mjqjpqmgbljsphdztnvjfqwrcgsmlb" ];
]
.into_iter().map(String::from).collect()
}
#[test] #[test]
fn part1() { fn part1() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(7, solve1(&data)); assert_eq!(7, solve1(&data));
} }
#[test] #[test]
fn part2() { fn part2() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(19, solve2(&data)); assert_eq!(19, solve2(&data));
} }
} }

15
2022/rust/template.rs
View file

@ -2,7 +2,7 @@ use crate::utils;
pub fn run() -> () { pub fn run() -> () {
let data = parse_data(utils::read_lines(utils::Source::Day(-1))); let data = parse_data(&utils::read_lines(utils::Source::Day(-1)));
println!("Day X"); println!("Day X");
println!("Part 1: {}", solve1(&data)); println!("Part 1: {}", solve1(&data));
@ -19,7 +19,7 @@ fn solve2(data: &()) -> i32 {
} }
fn parse_data(data: Vec<String>) -> () { fn parse_data<T: AsRef<str>>(data: &[T]) -> () {
() ()
} }
@ -28,22 +28,17 @@ fn parse_data(data: Vec<String>) -> () {
mod tests { mod tests {
use super::*; use super::*;
fn data() -> Vec<String> { static DATA: &[&str; 1] = [""];
vec![
""
]
.into_iter().map(String::from).collect()
}
#[test] #[test]
fn part1() { fn part1() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(1, solve1(&data)); assert_eq!(1, solve1(&data));
} }
#[test] #[test]
fn part2() { fn part2() {
let data = parse_data(data()); let data = parse_data(DATA);
assert_eq!(2, solve2(&data)); assert_eq!(2, solve2(&data));
} }
} }