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() -> () {
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!("Part 1: {}", solve1(&data));
@ -41,14 +41,15 @@ fn solve2(data: &Vec<Vec<i32>>) -> i32 {
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()
.fold(vec![vec![]], | mut acc, next| {
if next.len() == 0 {
let s = next.as_ref();
if s.len() == 0 {
acc.push(Vec::new())
}
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
@ -60,26 +61,23 @@ fn parse_data(data: Vec<String>) -> Vec<Vec<i32>> {
mod tests {
use super::*;
fn data() -> Vec<String> {
vec![
"1000", "2000", "3000", "",
"4000", "",
"5000", "6000", "",
"7000", "8000", "9000", "",
"10000",
]
.into_iter().map(String::from).collect()
}
static DATA: &[&str; 14] = &[
"1000", "2000", "3000", "",
"4000", "",
"5000", "6000", "",
"7000", "8000", "9000", "",
"10000",
];
#[test]
fn part1() {
let data = parse_data(data());
let data = parse_data(DATA);
assert_eq!(24000, solve1(&data));
}
#[test]
fn part2() {
let data = parse_data(data());
let data = parse_data(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() -> () {
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!("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()
.map(|line| {
let line = line.as_ref();
let mut chars = line.chars();
(chars.next().unwrap(), chars.last().unwrap())
})
@ -127,20 +128,17 @@ fn parse_data(data: Vec<String>) -> Vec<(char, char)> {
mod tests {
use super::*;
fn data() -> Vec<String> {
vec!["A Y", "B X", "C Z"]
.into_iter().map(String::from).collect()
}
static DATA: &[&str; 3] = &["A Y", "B X", "C Z"];
#[test]
fn part1() {
let data = parse_data(data());
let data = parse_data(DATA);
assert_eq!(15, solve1(&data));
}
#[test]
fn part2() {
let data = parse_data(data());
let data = parse_data(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() -> () {
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!("Part 1: {}", solve1(&data));
@ -48,9 +48,10 @@ fn find_intersection(sets: &[HashSet<char>]) -> char {
.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()
.map(|str| {
let str = str.as_ref();
let length = str.len();
let left = &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 {
use super::*;
fn data() -> Vec<String> {
vec![
"vJrwpWtwJgWrhcsFMMfFFhFp",
"jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL",
"PmmdzqPrVvPwwTWBwg",
"wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn",
"ttgJtRGJQctTZtZT",
"CrZsJsPPZsGzwwsLwLmpwMDw"
]
.into_iter().map(String::from).collect()
}
static DATA: &[&str; 6] = &[
"vJrwpWtwJgWrhcsFMMfFFhFp",
"jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL",
"PmmdzqPrVvPwwTWBwg",
"wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn",
"ttgJtRGJQctTZtZT",
"CrZsJsPPZsGzwwsLwLmpwMDw"
];
#[test]
fn part1() {
let data = parse_data(data());
let data = parse_data(DATA);
assert_eq!(157, solve1(&data));
}
#[test]
fn part2() {
let data = parse_data(data());
let data = parse_data(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() -> () {
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!("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();
data.iter()
.map(|s| {
let s = s.as_ref();
let c = re.captures(s).unwrap();
(
(
@ -53,20 +54,17 @@ fn parse_data(data: Vec<String>) -> Vec<((i32, i32), (i32, i32))> {
mod tests {
use super::*;
fn data() -> Vec<String> {
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()
}
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"];
#[test]
fn part1() {
let data = parse_data(data());
let data = parse_data(DATA);
assert_eq!(2, solve1(&data));
}
#[test]
fn part2() {
let data = parse_data(data());
let data = parse_data(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() -> () {
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!("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 re = Regex::new(r#"( {3}|[\[\w\]]{3}) ?"#).unwrap();
let mut boxes = data.iter()
.map_while(|s| {
let s = s.as_ref();
let cap = re.find_iter(s)
.map(|x| x.as_str().trim())
.enumerate()
@ -77,7 +78,7 @@ fn parse_data(data: Vec<String>) -> Data {
let actions = {
let re = Regex::new(r#"^move (\d+) from (\d+) to (\d+)$"#).unwrap();
data.iter()
.filter_map(|str| re.captures(str))
.filter_map(|str| re.captures(str.as_ref()))
.map(|cap| (
cap.get(1).unwrap().as_str().parse().unwrap(),
cap.get(2).unwrap().as_str().parse::<usize>().unwrap() - 1,
@ -93,30 +94,27 @@ fn parse_data(data: Vec<String>) -> Data {
mod tests {
use super::*;
fn data() -> Vec<String> {
vec![
" [D] ",
"[N] [C] ",
"[Z] [M] [P]",
" 1 2 3 ",
"",
"move 1 from 2 to 1",
"move 3 from 1 to 3",
"move 2 from 2 to 1",
"move 1 from 1 to 2",
]
.into_iter().map(String::from).collect()
}
static DATA: &[&str; 9] = &[
" [D] ",
"[N] [C] ",
"[Z] [M] [P]",
" 1 2 3 ",
"",
"move 1 from 2 to 1",
"move 3 from 1 to 3",
"move 2 from 2 to 1",
"move 1 from 1 to 2",
];
#[test]
fn part1() {
let data = parse_data(data());
let data = parse_data(DATA);
assert_eq!("CMZ", solve1(&data));
}
#[test]
fn part2() {
let data = parse_data(data());
let data = parse_data(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() -> () {
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!("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> {
data.into_iter()
fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<char> {
data.iter()
.next()
.map(|char| char.chars().collect())
.map(|char| char.as_ref().chars().collect())
.unwrap()
}
@ -61,22 +61,20 @@ fn parse_data(data: Vec<String>) -> Vec<char> {
mod tests {
use super::*;
fn data() -> Vec<String> {
vec![
"mjqjpqmgbljsphdztnvjfqwrcgsmlb"
]
.into_iter().map(String::from).collect()
}
static DATA: &[&str; 1] = &[
"mjqjpqmgbljsphdztnvjfqwrcgsmlb"
];
#[test]
fn part1() {
let data = parse_data(data());
let data = parse_data(DATA);
assert_eq!(7, solve1(&data));
}
#[test]
fn part2() {
let data = parse_data(data());
let data = parse_data(DATA);
assert_eq!(19, solve2(&data));
}
}

15
2022/rust/template.rs
View file

@ -2,7 +2,7 @@ use crate::utils;
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!("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 {
use super::*;
fn data() -> Vec<String> {
vec![
""
]
.into_iter().map(String::from).collect()
}
static DATA: &[&str; 1] = [""];
#[test]
fn part1() {
let data = parse_data(data());
let data = parse_data(DATA);
assert_eq!(1, solve1(&data));
}
#[test]
fn part2() {
let data = parse_data(data());
let data = parse_data(DATA);
assert_eq!(2, solve2(&data));
}
}