fix: change rust fmt defaults

rustfmt.toml

@@ -0,0 +1,4 @@
+tab_spaces = 2
+hard_tabs = true
+reorder_imports = true
+newline_style = "Unix"

src/day1.rs

@@ -1,15 +1,13 @@
 use std::num::ParseIntError;
 
 pub fn parse_input(input: &str) -> Result<Vec<u32>, ParseIntError> {
-    input.split_whitespace()
+	input.split_whitespace().map(|s| s.parse()).collect()
-        .map(|s| s.parse())
-        .collect()
 }
 
 pub fn part1(depths: &[u32]) -> u32 {
 	let mut count = 0;
 	for i in 1..depths.len() {
-        if depths[i] > depths[i-1] {
+		if depths[i] > depths[i - 1] {
 			count += 1;
 		}
 	}
@@ -18,8 +16,8 @@ pub fn part1(depths: &[u32]) -> u32 {
 
 pub fn part2(depths: &[u32]) -> u32 {
 	let mut count = 0;
-    for i in 2..depths.len()-1  {
+	for i in 2..depths.len() - 1 {
-        if depths[i+1] > depths[i-2] {
+		if depths[i + 1] > depths[i - 2] {
 			count += 1;
 		}
 	}
@@ -44,4 +42,3 @@ mod tests {
 		assert_eq!(result, 5);
 	}
 }
-

src/day10.rs

@@ -1,10 +1,9 @@
-
 #[derive(PartialEq)]
 enum ChunkVariant {
 	Parenthesis,
 	Bracket,
 	Curly,
-    Pointy
+	Pointy,
 }
 
 pub fn parse_input(input: &str) -> Vec<String> {
@@ -19,11 +18,11 @@ fn is_opening(c: char) -> bool {
 // error handling. And the input is guaranteed to be correct to this is fine.
 fn get_chunk_variant(c: char) -> ChunkVariant {
 	match c {
-        '('|')' => ChunkVariant::Parenthesis,
+		'(' | ')' => ChunkVariant::Parenthesis,
-        '['|']' => ChunkVariant::Bracket,
+		'[' | ']' => ChunkVariant::Bracket,
-        '{'|'}' => ChunkVariant::Curly,
+		'{' | '}' => ChunkVariant::Curly,
-        '<'|'>' => ChunkVariant::Pointy,
+		'<' | '>' => ChunkVariant::Pointy,
-        _ => panic!("Invalid chunk character")
+		_ => panic!("Invalid chunk character"),
 	}
 }
 
@@ -52,7 +51,7 @@ pub fn part1(lines: &Vec<String>) -> u32 {
 			Some(ChunkVariant::Bracket) => 57,
 			Some(ChunkVariant::Curly) => 1197,
 			Some(ChunkVariant::Pointy) => 25137,
-            None => 0
+			None => 0,
 		}
 	}
 	return score;
@@ -84,14 +83,14 @@ pub fn part2(lines: &Vec<String>) -> u64 {
 					ChunkVariant::Parenthesis => 1,
 					ChunkVariant::Bracket => 2,
 					ChunkVariant::Curly => 3,
-                    ChunkVariant::Pointy => 4
+					ChunkVariant::Pointy => 4,
 				}
 			}
 			scores.push(score);
 		}
 	}
 	scores.sort();
-    return scores[scores.len()/2];
+	return scores[scores.len() / 2];
 }
 
 #[cfg(test)]
@@ -134,4 +133,3 @@ mod tests {
 		assert_eq!(result, 288957);
 	}
 }
-

src/day11.rs

@@ -1,12 +1,15 @@
 use arrayvec::ArrayVec;
 
 pub fn parse_input(input: &str) -> [[u32; 10]; 10] {
-    input.lines()
+	input
-        .map(|s| s.chars()
+		.lines()
+		.map(|s| {
+			s.chars()
 				.map(|s| s.to_digit(10).unwrap())
 				.collect::<ArrayVec<u32, 10>>()
 				.into_inner()
-             .unwrap())
+				.unwrap()
+		})
 		.collect::<ArrayVec<[u32; 10], 10>>()
 		.into_inner()
 		.unwrap()
@@ -32,29 +35,29 @@ fn bump_energy(grid: &mut [[u32; 10]; 10]) {
 
 fn bump_energy_around(grid: &mut [[u32; 10]; 10], i: usize, j: usize) {
 	if j > 0 {
-        grid[i+0][j-1] += 1;
+		grid[i + 0][j - 1] += 1;
 	}
 	if j < 9 {
-        grid[i+0][j+1] += 1;
+		grid[i + 0][j + 1] += 1;
 	}
 	if i > 0 {
-        grid[i-1][j+0] += 1;
+		grid[i - 1][j + 0] += 1;
 	}
 	if i < 9 {
-        grid[i+1][j+0] += 1;
+		grid[i + 1][j + 0] += 1;
 	}
 
 	if i > 0 && j > 0 {
-        grid[i-1][j-1] += 1;
+		grid[i - 1][j - 1] += 1;
 	}
 	if i < 9 && j > 0 {
-        grid[i+1][j-1] += 1;
+		grid[i + 1][j - 1] += 1;
 	}
 	if i > 0 && j < 9 {
-        grid[i-1][j+1] += 1;
+		grid[i - 1][j + 1] += 1;
 	}
 	if i < 9 && j < 9 {
-        grid[i+1][j+1] += 1;
+		grid[i + 1][j + 1] += 1;
 	}
 }
 
@@ -144,7 +147,7 @@ mod tests {
 			[2, 1, 7, 6, 8, 4, 1, 7, 2, 1],
 			[6, 8, 8, 2, 8, 8, 1, 1, 3, 4],
 			[4, 8, 4, 6, 8, 4, 8, 5, 5, 4],
-            [5, 2, 8, 3, 7, 5, 1, 5, 2, 6]
+			[5, 2, 8, 3, 7, 5, 1, 5, 2, 6],
 		];
 		let result = part1(&input);
 		assert_eq!(result, 1656);
@@ -162,10 +165,9 @@ mod tests {
 			[2, 1, 7, 6, 8, 4, 1, 7, 2, 1],
 			[6, 8, 8, 2, 8, 8, 1, 1, 3, 4],
 			[4, 8, 4, 6, 8, 4, 8, 5, 5, 4],
-            [5, 2, 8, 3, 7, 5, 1, 5, 2, 6]
+			[5, 2, 8, 3, 7, 5, 1, 5, 2, 6],
 		];
 		let result = part2(&input);
 		assert_eq!(result, 195);
 	}
 }
-

src/day12.rs

@@ -15,11 +15,13 @@ fn edges_to_map(edges: &Vec<(String, String)>) -> HashMap<String, Vec<String>> {
 	let mut map = HashMap::new();
 
 	for line in edges {
-        map.entry(line.1.clone())
+		map
+			.entry(line.1.clone())
 			.or_insert(Vec::new())
 			.push(line.0.clone());
 
-        map.entry(line.0.clone())
+		map
+			.entry(line.0.clone())
 			.or_insert(Vec::new())
 			.push(line.1.clone());
 	}
@@ -28,7 +30,7 @@ fn edges_to_map(edges: &Vec<(String, String)>) -> HashMap<String, Vec<String>> {
 }
 
 fn is_path_finished(path: &Vec<&str>) -> bool {
-    return path.contains(&"end")
+	return path.contains(&"end");
 }
 
 fn can_be_appended_part1(path: &Vec<&str>, node: &str) -> bool {
@@ -67,14 +69,23 @@ pub fn part1(edges: &Vec<(String, String)>) -> usize {
 }
 
 fn can_be_appended_part2(path: &Vec<&str>, node: &str) -> bool {
-    if node == "start" { return false; }
+	if node == "start" {
-    if node == "end" { return true; }
+		return false;
-    if node.to_uppercase() == node { return true; }
+	}
+	if node == "end" {
+		return true;
+	}
+	if node.to_uppercase() == node {
+		return true;
+	}
 
 	// If all lowercase nodes only apear once we can be assure that any lowercase
 	// node that will be added will be correct.
 	let mut uniq = HashSet::new();
-    if path.into_iter().all(move |x| x.to_lowercase() != *x || uniq.insert(x)) {
+	if path
+		.into_iter()
+		.all(move |x| x.to_lowercase() != *x || uniq.insert(x))
+	{
 		return true;
 	}
 
@@ -125,7 +136,9 @@ mod tests {
 
 	#[test]
 	fn part1_larger_example() {
-        let cave_system = parse_input("dc-end\nHN-start\nstart-kj\ndc-start\ndc-HN\nLN-dc\nHN-end\nkj-sa\nkj-HN\nkj-dc");
+		let cave_system = parse_input(
+			"dc-end\nHN-start\nstart-kj\ndc-start\ndc-HN\nLN-dc\nHN-end\nkj-sa\nkj-HN\nkj-dc",
+		);
 		let result = part1(&cave_system);
 		assert_eq!(result, 19);
 	}
@@ -146,7 +159,9 @@ mod tests {
 
 	#[test]
 	fn part2_larger_example() {
-        let cave_system = parse_input("dc-end\nHN-start\nstart-kj\ndc-start\ndc-HN\nLN-dc\nHN-end\nkj-sa\nkj-HN\nkj-dc");
+		let cave_system = parse_input(
+			"dc-end\nHN-start\nstart-kj\ndc-start\ndc-HN\nLN-dc\nHN-end\nkj-sa\nkj-HN\nkj-dc",
+		);
 		let result = part2(&cave_system);
 		assert_eq!(result, 103);
 	}

src/day13.rs

@@ -11,15 +11,12 @@ pub enum Fold {
 
 pub struct InputData {
 	dots: Vec<Dot>,
-    folds: Vec<Fold>
+	folds: Vec<Fold>,
 }
 
 fn parse_dot(line: &str) -> Dot {
 	let (x, y) = line.split_once(',').unwrap();
-    return Dot(
+	return Dot(x.parse().unwrap(), y.parse().unwrap());
-        x.parse().unwrap(),
-        y.parse().unwrap()
-    );
 }
 
 fn parse_fold(line: &str) -> Fold {
@@ -28,24 +25,17 @@ fn parse_fold(line: &str) -> Fold {
 	match axis {
 		"fold along x" => Fold::X(coordinate),
 		"fold along y" => Fold::Y(coordinate),
-        _ => unreachable!("Unable to parse fold direction")
+		_ => unreachable!("Unable to parse fold direction"),
 	}
 }
 
 pub fn parse_input(input: &str) -> InputData {
 	let (dots_section, folds_section) = input.split_once("\n\n").unwrap();
 
-    let dots = dots_section.lines()
+	let dots = dots_section.lines().map(parse_dot).collect();
-        .map(parse_dot)
+	let folds = folds_section.lines().map(parse_fold).collect();
-        .collect();
-    let folds = folds_section.lines()
-        .map(parse_fold)
-        .collect();
 
-    return InputData {
+	return InputData { dots, folds };
-        dots,
-        folds
-    };
 }
 
 fn perform_fold(dots: &HashSet<Dot>, fold: &Fold) -> HashSet<Dot> {
@@ -55,18 +45,18 @@ fn perform_fold(dots: &HashSet<Dot>, fold: &Fold) -> HashSet<Dot> {
 		let folded_dot = match fold {
 			Fold::X(x) => {
 				if dot.0 > *x {
-                    Dot(2*x - dot.0, dot.1)
+					Dot(2 * x - dot.0, dot.1)
 				} else {
 					dot.clone()
 				}
-            },
+			}
 			Fold::Y(y) => {
 				if dot.1 > *y {
-                    Dot(dot.0, 2*y - dot.1)
+					Dot(dot.0, 2 * y - dot.1)
 				} else {
 					dot.clone()
 				}
-            },
+			}
 		};
 		folded_dots.insert(folded_dot);
 	}
@@ -146,15 +136,12 @@ mod tests {
 			Dot(3, 0),
 			Dot(8, 4),
 			Dot(1, 10),
-            Dot(2 ,14),
+			Dot(2, 14),
-            Dot(8 ,10),
+			Dot(8, 10),
-            Dot(9, 0)
+			Dot(9, 0),
 		];
-        let folds = vec![
+		let folds = vec![Fold::Y(7), Fold::X(5)];
-            Fold::Y(7),
+		let result = part1(&InputData { dots, folds });
-            Fold::X(5),
-        ];
-        let result = part1(&InputData{ dots, folds });
 		assert_eq!(result, 17);
 	}
 }

src/day14.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 pub struct InputData {
 	polymer_template: String,
-    rules: HashMap<[char; 2], char>
+	rules: HashMap<[char; 2], char>,
 }
 
 pub fn parse_input(input: &str) -> InputData {
@@ -11,21 +11,24 @@ pub fn parse_input(input: &str) -> InputData {
 	for line in rules_section.lines() {
 		let (pattern, expansion) = line.split_once(" -> ").unwrap();
 		rules.insert(
-            [pattern.chars().nth(0).unwrap(), pattern.chars().nth(1).unwrap()],
+			[
-            expansion.chars().nth(0).unwrap()
+				pattern.chars().nth(0).unwrap(),
+				pattern.chars().nth(1).unwrap(),
+			],
+			expansion.chars().nth(0).unwrap(),
 		);
 	}
 	return InputData {
 		polymer_template: polymer_template.into(),
-        rules
+		rules,
 	};
 }
 
 fn naive_expand_polymer(polymer: Vec<char>, rules: &HashMap<[char; 2], char>) -> Vec<char> {
 	let mut new_polymer = Vec::new();
-    for i in 0..polymer.len()-1 {
+	for i in 0..polymer.len() - 1 {
 		new_polymer.push(polymer[i]);
-        let pair = [polymer[i], polymer[i+1]];
+		let pair = [polymer[i], polymer[i + 1]];
 		let rule = rules.get(&pair);
 		if rule != None {
 			new_polymer.push(*rule.unwrap());
@@ -47,12 +50,23 @@ pub fn part1(input: &InputData) -> u32 {
 		*amount += 1;
 	}
 
-    let least_common_element = element_amounts.iter().min_by(|a, b| a.1.cmp(b.1)).unwrap().1;
+	let least_common_element = element_amounts
-    let most_common_element = element_amounts.iter().max_by(|a, b| a.1.cmp(b.1)).unwrap().1;
+		.iter()
+		.min_by(|a, b| a.1.cmp(b.1))
+		.unwrap()
+		.1;
+	let most_common_element = element_amounts
+		.iter()
+		.max_by(|a, b| a.1.cmp(b.1))
+		.unwrap()
+		.1;
 	return most_common_element - least_common_element;
 }
 
-fn expand_polymer(polymer_pairs: &HashMap<[char; 2], u64>, rules: &HashMap<[char; 2], char>) -> HashMap<[char; 2], u64> {
+fn expand_polymer(
+	polymer_pairs: &HashMap<[char; 2], u64>,
+	rules: &HashMap<[char; 2], char>,
+) -> HashMap<[char; 2], u64> {
 	let mut new_pairs = HashMap::new();
 	for entry in polymer_pairs {
 		let pair = entry.0;
@@ -72,16 +86,15 @@ fn expand_polymer(polymer_pairs: &HashMap<[char; 2], u64>, rules: &HashMap<[char
 		}
 	}
 	return new_pairs;
-    
 }
 
 pub fn part2(input: &InputData) -> u64 {
 	let polymer_template = &input.polymer_template;
 	let mut polymer_pairs = HashMap::new();
-    for i in 0..polymer_template.len()-1 {
+	for i in 0..polymer_template.len() - 1 {
 		let pair = [
 			polymer_template.chars().nth(i).unwrap(),
-            polymer_template.chars().nth(i+1).unwrap()
+			polymer_template.chars().nth(i + 1).unwrap(),
 		];
 		let entry = polymer_pairs.entry(pair).or_insert(0);
 		*entry += 1;
@@ -99,9 +112,17 @@ pub fn part2(input: &InputData) -> u64 {
 		}
 	}
 
-    let least_common_element = element_amounts.iter().min_by(|a, b| a.1.cmp(b.1)).unwrap().1;
+	let least_common_element = element_amounts
-    let most_common_element = element_amounts.iter().max_by(|a, b| a.1.cmp(b.1)).unwrap().1;
+		.iter()
-    return (most_common_element - least_common_element)/2 + 1;
+		.min_by(|a, b| a.1.cmp(b.1))
+		.unwrap()
+		.1;
+	let most_common_element = element_amounts
+		.iter()
+		.max_by(|a, b| a.1.cmp(b.1))
+		.unwrap()
+		.1;
+	return (most_common_element - least_common_element) / 2 + 1;
 }
 
 #[cfg(test)]
@@ -127,9 +148,12 @@ mod tests {
 			(['B', 'B'], 'N'),
 			(['B', 'C'], 'B'),
 			(['C', 'C'], 'N'),
-            (['C', 'N'], 'C')
+			(['C', 'N'], 'C'),
 		]);
-        let result = part1(&InputData { polymer_template, rules });
+		let result = part1(&InputData {
+			polymer_template,
+			rules,
+		});
 		assert_eq!(result, 1588);
 	}
 
@@ -152,9 +176,12 @@ mod tests {
 			(['B', 'B'], 'N'),
 			(['B', 'C'], 'B'),
 			(['C', 'C'], 'N'),
-            (['C', 'N'], 'C')
+			(['C', 'N'], 'C'),
 		]);
-        let result = part2(&InputData { polymer_template, rules });
+		let result = part2(&InputData {
+			polymer_template,
+			rules,
+		});
 		assert_eq!(result, 2188189693529);
 	}
 }

src/day15.rs

@@ -1,21 +1,22 @@
-use std::collections::{HashMap, HashSet};
 use priority_queue::PriorityQueue;
-
+use std::collections::{HashMap, HashSet};
 
 #[derive(Debug)]
 pub struct Grid {
 	rows: u32,
 	cols: u32,
 	data: Vec<u32>,
-    scale: u32
+	scale: u32,
 }
 
 impl Grid {
 	fn new(rows: u32, cols: u32, data: Vec<u32>) -> Grid {
 		return Grid {
-            rows, cols, data,
+			rows,
-            scale: 1
+			cols,
-        }
+			data,
+			scale: 1,
+		};
 	}
 
 	fn get(&self, point: &(u32, u32)) -> u32 {
@@ -45,7 +46,9 @@ pub fn parse_input(input: &str) -> Grid {
 	for line in input.lines() {
 		rows += 1;
 		for c in line.chars() {
-            if rows == 1 { cols += 1 }
+			if rows == 1 {
+				cols += 1
+			}
 			data.push(c.to_digit(10).unwrap());
 		}
 	}
@@ -68,7 +71,7 @@ fn find_shortest_path_cost(grid: &Grid) -> u32 {
 	let mut total_costs: HashMap<(u32, u32), u32> = HashMap::new();
 	let mut min_pq: PriorityQueue<(u32, u32), i32> = PriorityQueue::new();
 	let mut visited: HashSet<(u32, u32)> = HashSet::new();
-    let neighbour_offsets = [ (0, 1), (0, -1), (1, 0), (-1, 0) ];
+	let neighbour_offsets = [(0, 1), (0, -1), (1, 0), (-1, 0)];
 	min_pq.push((0, 0), 0);
 	total_costs.insert((0, 0), 0);
 
@@ -90,7 +93,9 @@ fn find_shortest_path_cost(grid: &Grid) -> u32 {
 		}
 	}
 
-    return *total_costs.get(&(grid.height()-1, grid.width()-1)).unwrap();
+	return *total_costs
+		.get(&(grid.height() - 1, grid.width() - 1))
+		.unwrap();
 }
 
 pub fn part1(grid: &Grid) -> u32 {
@@ -108,7 +113,8 @@ mod tests {
 
 	#[test]
 	fn part1_example() {
-        let grid = parse_input("1163751742
+		let grid = parse_input(
+			"1163751742
 1381373672
 2136511328
 3694931569
@@ -117,14 +123,16 @@ mod tests {
 1359912421
 3125421639
 1293138521
-2311944581");
+2311944581",
+		);
 		let result = part1(&grid);
 		assert_eq!(result, 40);
 	}
 
 	#[test]
 	fn part2_example() {
-        let mut grid = parse_input("1163751742
+		let mut grid = parse_input(
+			"1163751742
 1381373672
 2136511328
 3694931569
@@ -133,9 +141,9 @@ mod tests {
 1359912421
 3125421639
 1293138521
-2311944581");
+2311944581",
+		);
 		let result = part2(&mut grid);
 		assert_eq!(result, 315);
 	}
 }
-

src/day16.rs

@@ -1,13 +1,12 @@
-
 pub enum PacketBody {
 	Literal(u64),
-    Operator(Vec<Packet>)
+	Operator(Vec<Packet>),
 }
 
 pub struct Packet {
 	version: u8,
 	r#type: u8,
-    body: PacketBody
+	body: PacketBody,
 }
 
 fn to_bits(hex: &str) -> String {
@@ -16,7 +15,7 @@ fn to_bits(hex: &str) -> String {
 		match c {
 			b'0'..=b'9' => bits.push_str(format!("{:0>4b}", c - b'0').as_str()),
 			b'A'..=b'F' => bits.push_str(format!("{:0>4b}", c - b'A' + 10).as_str()),
-            _ => ()
+			_ => (),
 		}
 	}
 	return bits;
@@ -27,13 +26,15 @@ fn parse_literal_body(bits_str: &str) -> (PacketBody, u32) {
 	let mut cursor = 0;
 	let bytes = bits_str.as_bytes();
 	loop {
-        value_bits.push_str(&bits_str[cursor+1..cursor+5]);
+		value_bits.push_str(&bits_str[cursor + 1..cursor + 5]);
-        if bytes[cursor] == b'0' { break; }
+		if bytes[cursor] == b'0' {
+			break;
+		}
 		cursor += 5;
 	}
 	let value = u64::from_str_radix(&value_bits, 2).unwrap();
 
-    return (PacketBody::Literal(value), (cursor+5) as u32);
+	return (PacketBody::Literal(value), (cursor + 5) as u32);
 }
 
 fn parse_operator_body(bits_str: &str) -> (PacketBody, u32) {
@@ -52,7 +53,7 @@ fn parse_operator_body(bits_str: &str) -> (PacketBody, u32) {
 	} else {
 		let total_size = u32::from_str_radix(&bits_str[1..16], 2).unwrap();
 		size += 15;
-        while ((size-16) as u32) < total_size {
+		while ((size - 16) as u32) < total_size {
 			let (packet, s) = parse_packet(&bits_str[size..]);
 			packets.push(packet);
 			size += s as usize;
@@ -65,15 +66,16 @@ fn parse_packet(bits: &str) -> (Packet, u32) {
 	let r#type = u8::from_str_radix(&bits[3..6], 2).unwrap();
 	let (body, body_size) = match r#type {
 		4 => parse_literal_body(&bits[6..]),
-        _ => parse_operator_body(&bits[6..])
+		_ => parse_operator_body(&bits[6..]),
 	};
 
-    return (Packet {
+	return (
+		Packet {
 			version: u8::from_str_radix(&bits[0..3], 2).unwrap(),
 			r#type,
-        body
+			body,
 		},
-    body_size + 6
+		body_size + 6,
 	);
 }
 
@@ -89,8 +91,8 @@ fn sum_packet_versions(packet: &Packet) -> u32 {
 			for sub_packet in packets {
 				sum += sum_packet_versions(sub_packet);
 			}
-        },
+		}
-        _ => ()
+		_ => (),
 	};
 	return sum;
 }
@@ -130,24 +132,35 @@ fn eval_maximum_packets(packets: &[Packet]) -> u64 {
 fn eval_greater_packets(packets: &[Packet]) -> u64 {
 	let first_packet = packets.get(0).unwrap();
 	let second_packet = packets.get(1).unwrap();
-    if eval_packet(first_packet) > eval_packet(second_packet) { 1 } else { 0 }
+	if eval_packet(first_packet) > eval_packet(second_packet) {
+		1
+	} else {
+		0
+	}
 }
 fn eval_less_packets(packets: &[Packet]) -> u64 {
 	let first_packet = packets.get(0).unwrap();
 	let second_packet = packets.get(1).unwrap();
-    if eval_packet(first_packet) < eval_packet(second_packet) { 1 } else { 0 }
+	if eval_packet(first_packet) < eval_packet(second_packet) {
+		1
+	} else {
+		0
+	}
 }
 fn eval_equal_packets(packets: &[Packet]) -> u64 {
 	let first_packet = packets.get(0).unwrap();
 	let second_packet = packets.get(1).unwrap();
-    if eval_packet(first_packet) == eval_packet(second_packet) { 1 } else { 0 }
+	if eval_packet(first_packet) == eval_packet(second_packet) {
+		1
+	} else {
+		0
+	}
 }
 
 fn eval_packet(packet: &Packet) -> u64 {
 	match &packet.body {
 		PacketBody::Literal(value) => *value,
-        PacketBody::Operator(packets) => {
+		PacketBody::Operator(packets) => match packet.r#type {
-            match packet.r#type {
 			0 => eval_sum_packets(packets),
 			1 => eval_product_packets(packets),
 			2 => eval_minimum_packets(packets),
@@ -155,9 +168,8 @@ fn eval_packet(packet: &Packet) -> u64 {
 			5 => eval_greater_packets(packets),
 			6 => eval_less_packets(packets),
 			7 => eval_equal_packets(packets),
-                _ => unreachable!()
+			_ => unreachable!(),
-            }
+		},
-        }
 	}
 }
 
@@ -253,4 +265,3 @@ mod tests {
 		assert_eq!(result, 1);
 	}
 }
-

src/day17.rs

@@ -1,11 +1,13 @@
-
 pub struct Rect {
-    x0: i32, x1: i32,
+	x0: i32,
-    y0: i32, y1: i32,
+	x1: i32,
+	y0: i32,
+	y1: i32,
 }
 
 pub fn parse_input(input: &str) -> Rect {
-    let (x_part, y_part) = input.strip_suffix("\n")
+	let (x_part, y_part) = input
+		.strip_suffix("\n")
 		.or(Some(input))
 		.unwrap()
 		.strip_prefix("target area: ")
@@ -18,12 +20,18 @@ pub fn parse_input(input: &str) -> Rect {
 		x0: x0.parse().unwrap(),
 		x1: x1.parse().unwrap(),
 		y0: y0.parse().unwrap(),
-        y1: y1.parse().unwrap()
+		y1: y1.parse().unwrap(),
-    }
+	};
 }
 
 fn sign(x: i32) -> i32 {
-    if x > 0 { 1 } else if x < 0 { -1 } else { 0 }
+	if x > 0 {
+		1
+	} else if x < 0 {
+		-1
+	} else {
+		0
+	}
 }
 
 fn is_overshot(px: i32, py: i32, target: &Rect) -> bool {
@@ -31,8 +39,7 @@ fn is_overshot(px: i32, py: i32, target: &Rect) -> bool {
 }
 
 fn is_in_rect(px: i32, py: i32, target: &Rect) -> bool {
-    target.x0 <= px && px <= target.x1 &&
+	target.x0 <= px && px <= target.x1 && target.y0 <= py && py <= target.y1
-    target.y0 <= py && py <= target.y1
 }
 
 fn simulate(target: &Rect, initial_vx: i32, initial_vy: i32) -> i32 {
@@ -99,4 +106,3 @@ mod tests {
 		assert_eq!(result, 112);
 	}
 }
-

src/day18.rs

@@ -7,8 +7,8 @@ fn parse_snailfish(line: &str) -> Vec<(i32, u8)> {
 		match c {
 			'[' => depth += 1,
 			']' => depth -= 1,
-            ',' => {},
+			',' => {}
-            _   => nums.push(((c as u8 - b'0') as i32, depth))
+			_ => nums.push(((c as u8 - b'0') as i32, depth)),
 		}
 	}
 	return nums;
@@ -38,44 +38,50 @@ pub fn parse_input(input: &str) -> Vec<Vec<(i32, u8)>> {
 fn add_snailfish(a: &Vec<(i32, u8)>, b: &Vec<(i32, u8)>) -> Vec<(i32, u8)> {
 	let mut added = Vec::new();
 	for (num, depth) in a {
-        added.push((*num, depth+1));
+		added.push((*num, depth + 1));
 	}
 	for (num, depth) in b {
-        added.push((*num, depth+1));
+		added.push((*num, depth + 1));
 	}
 	return added;
 }
 
 fn try_exploding(num: &mut Vec<(i32, u8)>) -> bool {
 	let i = find_deepest_index(num);
-    if num[i].1 < 5 { return false; }
+	if num[i].1 < 5 {
+		return false;
+	}
 	let (left_num, depth) = num[i];
-    let right_num = num.remove(i+1).0;
+	let right_num = num.remove(i + 1).0;
 	if i > 0 {
-        num[i-1].0 += left_num;
+		num[i - 1].0 += left_num;
 	}
-    if i+1 < num.len() {
+	if i + 1 < num.len() {
-        num[i+1].0 += right_num;
+		num[i + 1].0 += right_num;
 	}
-    num[i] = (0, depth-1);
+	num[i] = (0, depth - 1);
 	return true;
 }
 
 fn try_splitting(num: &mut Vec<(i32, u8)>) -> bool {
-    let target = match num.iter().position(|&(n,_)| n > 9) {
+	let target = match num.iter().position(|&(n, _)| n > 9) {
 		Some(i) => i,
 		None => return false,
 	};
 	let (x, depth) = num[target];
-    num[target] = (x/2, depth+1);
+	num[target] = (x / 2, depth + 1);
-    num.insert(target+1, ((x+1)/2, depth+1));
+	num.insert(target + 1, ((x + 1) / 2, depth + 1));
 	return true;
 }
 
 fn reduce_snailfish(num: &mut Vec<(i32, u8)>) {
 	loop {
-        if try_exploding(num) { continue; }
+		if try_exploding(num) {
-        if try_splitting(num) { continue; }
+			continue;
+		}
+		if try_splitting(num) {
+			continue;
+		}
 		break;
 	}
 }
@@ -84,9 +90,9 @@ fn get_magnitude(mut num: Vec<(i32, u8)>) -> i32 {
 	while num.len() > 1 {
 		let i = find_deepest_index(&num);
 		let (left_num, depth) = num[i];
-        let right_num = num[i+1].0;
+		let right_num = num[i + 1].0;
-        num[i] = (3*left_num + 2*right_num, depth-1);
+		num[i] = (3 * left_num + 2 * right_num, depth - 1);
-        num.remove(i+1);
+		num.remove(i + 1);
 	}
 	num[0].0
 }
@@ -114,7 +120,7 @@ pub fn part2(nums: &Vec<Vec<(i32, u8)>>) -> i32 {
 	let mut max_magnitude = 0;
 	let n = nums.len();
 	for i in 0..n {
-        for j in 0..n-1 {
+		for j in 0..n - 1 {
 			let a = &nums[i];
 			let b = &nums[j];
 			max_magnitude = max_magnitude.max(get_magnitude(add_and_reduce(a, b)));
@@ -130,7 +136,8 @@ mod tests {
 
 	#[test]
 	fn part1_example() {
-        let nums = parse_input("[[[0,[5,8]],[[1,7],[9,6]]],[[4,[1,2]],[[1,4],2]]]
+		let nums = parse_input(
+			"[[[0,[5,8]],[[1,7],[9,6]]],[[4,[1,2]],[[1,4],2]]]
 [[[5,[2,8]],4],[5,[[9,9],0]]]
 [6,[[[6,2],[5,6]],[[7,6],[4,7]]]]
 [[[6,[0,7]],[0,9]],[4,[9,[9,0]]]]
@@ -139,14 +146,16 @@ mod tests {
 [[[[5,4],[7,7]],8],[[8,3],8]]
 [[9,3],[[9,9],[6,[4,9]]]]
 [[2,[[7,7],7]],[[5,8],[[9,3],[0,2]]]]
-[[[[5,2],5],[8,[3,7]]],[[5,[7,5]],[4,4]]]");
+[[[[5,2],5],[8,[3,7]]],[[5,[7,5]],[4,4]]]",
+		);
 		let result = part1(&nums);
 		assert_eq!(result, 4140);
 	}
 
 	#[test]
 	fn part2_example() {
-        let nums = parse_input("[[[0,[5,8]],[[1,7],[9,6]]],[[4,[1,2]],[[1,4],2]]]
+		let nums = parse_input(
+			"[[[0,[5,8]],[[1,7],[9,6]]],[[4,[1,2]],[[1,4],2]]]
 [[[5,[2,8]],4],[5,[[9,9],0]]]
 [6,[[[6,2],[5,6]],[[7,6],[4,7]]]]
 [[[6,[0,7]],[0,9]],[4,[9,[9,0]]]]
@@ -155,7 +164,8 @@ mod tests {
 [[[[5,4],[7,7]],8],[[8,3],8]]
 [[9,3],[[9,9],[6,[4,9]]]]
 [[2,[[7,7],7]],[[5,8],[[9,3],[0,2]]]]
-[[[[5,2],5],[8,[3,7]]],[[5,[7,5]],[4,4]]]");
+[[[[5,2],5],[8,[3,7]]],[[5,[7,5]],[4,4]]]",
+		);
 		let result = part2(&nums);
 		assert_eq!(result, 3993);
 	}
@@ -180,11 +190,17 @@ mod tests {
 	}
 	#[test]
 	fn exploding_4() {
-        test_explosion("[[3,[2,[1,[7,3]]]],[6,[5,[4,[3,2]]]]]", "[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]");
+		test_explosion(
+			"[[3,[2,[1,[7,3]]]],[6,[5,[4,[3,2]]]]]",
+			"[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]",
+		);
 	}
 	#[test]
 	fn exploding_5() {
-        test_explosion("[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]", "[[3,[2,[8,0]]],[9,[5,[7,0]]]]");
+		test_explosion(
+			"[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]",
+			"[[3,[2,[8,0]]],[9,[5,[7,0]]]]",
+		);
 	}
 
 	fn test_sum(nums: Vec<&str>, expected: &str) {
@@ -197,35 +213,17 @@ mod tests {
 
 	#[test]
 	fn sum_1() {
-        let nums = vec![
+		let nums = vec!["[1,1]", "[2,2]", "[3,3]", "[4,4]"];
-            "[1,1]",
-            "[2,2]",
-            "[3,3]",
-            "[4,4]"
-        ];
 		test_sum(nums, "[[[[1,1],[2,2]],[3,3]],[4,4]]");
 	}
 	#[test]
 	fn sum_2() {
-        let nums = vec![
+		let nums = vec!["[1,1]", "[2,2]", "[3,3]", "[4,4]", "[5,5]"];
-            "[1,1]",
-            "[2,2]",
-            "[3,3]",
-            "[4,4]",
-            "[5,5]"
-        ];
 		test_sum(nums, "[[[[3,0],[5,3]],[4,4]],[5,5]]");
 	}
 	#[test]
 	fn sum_3() {
-        let nums = vec![
+		let nums = vec!["[1,1]", "[2,2]", "[3,3]", "[4,4]", "[5,5]", "[6,6]"];
-            "[1,1]",
-            "[2,2]",
-            "[3,3]",
-            "[4,4]",
-            "[5,5]",
-            "[6,6]",
-        ];
 		test_sum(nums, "[[[[5,0],[7,4]],[5,5]],[6,6]]");
 	}
 	#[test]
@@ -240,9 +238,12 @@ mod tests {
 			"[2,9]",
 			"[1,[[[9,3],9],[[9,0],[0,7]]]]",
 			"[[[5,[7,4]],7],1]",
-            "[[[[4,2],2],6],[8,7]]"
+			"[[[[4,2],2],6],[8,7]]",
 		];
-        test_sum(nums, "[[[[8,7],[7,7]],[[8,6],[7,7]]],[[[0,7],[6,6]],[8,7]]]");
+		test_sum(
+			nums,
+			"[[[[8,7],[7,7]],[[8,6],[7,7]]],[[[0,7],[6,6]],[8,7]]]",
+		);
 	}
 
 	fn test_magnitude(initial: &str, expected: i32) {
@@ -272,7 +273,9 @@ mod tests {
 	}
 	#[test]
 	fn magnitude_6() {
-        test_magnitude("[[[[8,7],[7,7]],[[8,6],[7,7]]],[[[0,7],[6,6]],[8,7]]]", 3488);
+		test_magnitude(
+			"[[[[8,7],[7,7]],[[8,6],[7,7]]],[[[0,7],[6,6]],[8,7]]]",
+			3488,
+		);
 	}
 }
-

src/day2.rs

@@ -9,7 +9,7 @@ pub enum ParseCommandError {
 pub enum CommandType {
 	Forward,
 	Down,
-    Up
+	Up,
 }
 
 pub struct Command(CommandType, u32);
@@ -20,16 +20,14 @@ fn parse_line(line: &str) -> Result<Command, ParseCommandError> {
 		"up" => Ok(CommandType::Up),
 		"down" => Ok(CommandType::Down),
 		"forward" => Ok(CommandType::Forward),
-        _ => Err(ParseCommandError::ParseEnumError)
+		_ => Err(ParseCommandError::ParseEnumError),
 	}?;
 	let amount = parts[1].parse().map_err(ParseCommandError::ParseIntError)?;
 	Ok(Command(command, amount))
 }
 
 pub fn parse_input(input: &str) -> Result<Vec<Command>, ParseCommandError> {
-    input.split_terminator('\n')
+	input.split_terminator('\n').map(parse_line).collect()
-        .map(parse_line)
-        .collect()
 }
 
 pub fn part1(commands: &[Command]) -> u32 {
@@ -74,7 +72,7 @@ mod tests {
 			Command(CommandType::Forward, 8),
 			Command(CommandType::Up, 3),
 			Command(CommandType::Down, 8),
-            Command(CommandType::Forward, 2)
+			Command(CommandType::Forward, 2),
 		];
 		let result = part1(&commands);
 		assert_eq!(result, 150);
@@ -88,10 +86,9 @@ mod tests {
 			Command(CommandType::Forward, 8),
 			Command(CommandType::Up, 3),
 			Command(CommandType::Down, 8),
-            Command(CommandType::Forward, 2)
+			Command(CommandType::Forward, 2),
 		];
 		let result = part2(&commands);
 		assert_eq!(result, 900)
 	}
 }
-

src/day20.rs

@@ -1,5 +1,4 @@
-use std::{ops::Range, fmt::Display};
+use std::{fmt::Display, ops::Range};
-
 
 #[derive(Clone, Debug)]
 pub struct Image {
@@ -8,19 +7,19 @@ pub struct Image {
 	data: Vec<bool>,
 	default_value: bool,
 	offset_x: i32,
-    offset_y: i32
+	offset_y: i32,
 }
 
 impl Image {
 	fn new(width: usize, height: usize) -> Image {
-        let data = vec![false; width*height];
+		let data = vec![false; width * height];
 		Image {
 			width,
 			height,
 			data,
 			default_value: false,
 			offset_x: 0,
-            offset_y: 0
+			offset_y: 0,
 		}
 	}
 
@@ -81,7 +80,7 @@ impl Image {
 		let padding = padding as i32;
 		Range {
 			start: -self.offset_x - padding,
-            end: self.width as i32 - self.offset_x + padding
+			end: self.width as i32 - self.offset_x + padding,
 		}
 	}
 
@@ -89,7 +88,7 @@ impl Image {
 		let padding = padding as i32;
 		Range {
 			start: -self.offset_y - padding,
-            end: self.height as i32 - self.offset_y + padding
+			end: self.height as i32 - self.offset_y + padding,
 		}
 	}
 
@@ -99,7 +98,7 @@ impl Image {
 			-self.offset_x,
 			-self.offset_y,
 			self.width as i32 - self.offset_x,
-            self.height as i32 - self.offset_y
+			self.height as i32 - self.offset_y,
 		);
 	}
 }
@@ -137,24 +136,27 @@ fn parse_enchancer(input: &str) -> [bool; 512] {
 	let mut i = 0;
 	for c in input.chars() {
 		enhancer[i] = c == '#';
-        i+=1;
+		i += 1;
 	}
-    return enhancer
+	return enhancer;
 }
 
 pub fn parse_input(input: &str) -> ([bool; 512], Image) {
 	let (section1, section2) = input.split_once("\n\n").unwrap();
-    return (
+	return (parse_enchancer(section1), parse_image(section2));
-        parse_enchancer(section1),
-        parse_image(section2)
-    );
 }
 
 fn lookup_enhancer(x: i32, y: i32, image: &Image, enhancer: &[bool; 512]) -> bool {
 	let pixel_offsets = [
-        (-1, -1), ( 0, -1), ( 1, -1),
+		(-1, -1),
-        (-1,  0), ( 0,  0), ( 1,  0),
+		(0, -1),
-        (-1,  1), ( 0,  1), ( 1,  1)
+		(1, -1),
+		(-1, 0),
+		(0, 0),
+		(1, 0),
+		(-1, 1),
+		(0, 1),
+		(1, 1),
 	];
 
 	let mut lookup_index = 0;
@@ -162,7 +164,7 @@ fn lookup_enhancer(x: i32, y: i32, image: &Image, enhancer: &[bool; 512]) -> boo
 		let (ox, oy) = pixel_offsets[i];
 		let pixel = image.get(x + ox, y + oy);
 		if pixel {
-            lookup_index += 2usize.pow((8-i) as u32)
+			lookup_index += 2usize.pow((8 - i) as u32)
 		}
 	}
 
@@ -202,7 +204,6 @@ pub fn part2(data: &([bool; 512], Image)) -> usize {
 	enhanced_image.count(true)
 }
 
-
 #[cfg(test)]
 mod tests {
 	use super::*;

src/day21.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
-
 pub fn parse_input(input: &str) -> (u8, u8) {
-    let players: Vec<u8> = input.lines()
+	let players: Vec<u8> = input
+		.lines()
 		.map(|l| l.split_once(": ").unwrap().1.parse().unwrap())
 		.collect();
 	return (players[0], players[1]);
@@ -42,10 +42,21 @@ pub fn part1(starting_positions: &(u8, u8)) -> u32 {
 	player1_score.min(player2_score) * rolled_count as u32
 }
 
-fn get_wins_amount(starting_pos1: u32, starting_pos2: u32, starting_score1: u32, starting_score2: u32, memo: &mut HashMap<(u32, u32, u32, u32), (u64, u64)>) -> (u64, u64) {
+fn get_wins_amount(
-    let memo_key = (starting_pos1, starting_pos2, starting_score1, starting_score2);
+	starting_pos1: u32,
+	starting_pos2: u32,
+	starting_score1: u32,
+	starting_score2: u32,
+	memo: &mut HashMap<(u32, u32, u32, u32), (u64, u64)>,
+) -> (u64, u64) {
+	let memo_key = (
+		starting_pos1,
+		starting_pos2,
+		starting_score1,
+		starting_score2,
+	);
 	if memo.contains_key(&memo_key) {
-        return *memo.get(&memo_key).unwrap()
+		return *memo.get(&memo_key).unwrap();
 	}
 	let mut total_wins1 = 0;
 	let mut total_wins2 = 0;

src/day22.rs

@@ -1,17 +1,20 @@
-use std::{convert::{TryFrom, TryInto}, num::ParseIntError, collections::HashSet};
+use std::{
-
+	collections::HashSet,
+	convert::{TryFrom, TryInto},
+	num::ParseIntError,
+};
 
 #[derive(Debug, Clone)]
 pub struct Cuboid {
 	x: (i32, i32),
 	y: (i32, i32),
-    z: (i32, i32)
+	z: (i32, i32),
 }
 
 #[derive(Debug)]
 pub enum StepAction {
 	On,
-    Off
+	Off,
 }
 
 #[derive(Debug)]
@@ -21,14 +24,14 @@ pub struct RebootStep(StepAction, Cuboid);
 pub enum ParseRangeError {
 	Empty,
 	BadLen,
-    ParseInt(ParseIntError)
+	ParseInt(ParseIntError),
 }
 
 #[derive(Debug)]
 pub enum ParseCuboidError {
 	Empty,
 	BadLen,
-    ParseRange(ParseRangeError)
+	ParseRange(ParseRangeError),
 }
 
 #[derive(Debug)]
@@ -36,14 +39,17 @@ pub enum ParseRebootStepError {
 	Empty,
 	BadLen,
 	BadAction,
-    ParseCuboid(ParseCuboidError)
+	ParseCuboid(ParseCuboidError),
 }
 
 impl Cuboid {
 	fn contains(&self, point: &(i32, i32, i32)) -> bool {
-        self.x.0 <= point.0 && point.0 <= self.x.1 &&
+		self.x.0 <= point.0
-        self.y.0 <= point.1 && point.1 <= self.y.1 &&
+			&& point.0 <= self.x.1
-        self.z.0 <= point.2 && point.2 <= self.z.1
+			&& self.y.0 <= point.1
+			&& point.1 <= self.y.1
+			&& self.z.0 <= point.2
+			&& point.2 <= self.z.1
 	}
 
 	fn clamp(&self, other: &Cuboid) -> Cuboid {
@@ -55,16 +61,22 @@ impl Cuboid {
 	}
 
 	fn intersection(&self, other: &Cuboid) -> Option<Cuboid> {
-        if self.z.0 > other.z.1 || other.z.0 > self.z.1 { return None; }
+		if self.z.0 > other.z.1 || other.z.0 > self.z.1 {
-        if self.y.0 > other.y.1 || other.y.0 > self.y.1 { return None; }
+			return None;
-        if self.x.0 > other.x.1 || other.x.0 > self.x.1 { return None; }
+		}
+		if self.y.0 > other.y.1 || other.y.0 > self.y.1 {
+			return None;
+		}
+		if self.x.0 > other.x.1 || other.x.0 > self.x.1 {
+			return None;
+		}
 		Some(self.clamp(other))
 	}
 
 	fn volume(&self) -> u64 {
-        (self.x.1 - self.x.0 + 1) as u64 *
+		(self.x.1 - self.x.0 + 1) as u64
-        (self.y.1 - self.y.0 + 1) as u64 *
+			* (self.y.1 - self.y.0 + 1) as u64
-        (self.z.1 - self.z.0 + 1) as u64
+			* (self.z.1 - self.z.0 + 1) as u64
 	}
 }
 
@@ -84,9 +96,7 @@ fn parse_range(value: &str) -> Result<(i32, i32), ParseRangeError> {
 	if value.is_empty() {
 		return Err(ParseRangeError::Empty);
 	}
-    let (start, end) = value[2..]
+	let (start, end) = value[2..].split_once("..").ok_or(ParseRangeError::BadLen)?;
-        .split_once("..")
-        .ok_or(ParseRangeError::BadLen)?;
 	Ok((start.parse()?, end.parse()?))
 }
 
@@ -97,7 +107,8 @@ impl TryFrom<&str> for Cuboid {
 		if value.is_empty() {
 			return Err(Self::Error::Empty);
 		}
-        let ranges: Vec<_> = value.split(',')
+		let ranges: Vec<_> = value
+			.split(',')
 			.map(parse_range)
 			.collect::<Result<_, _>>()?;
 		if ranges.len() != 3 {
@@ -106,7 +117,7 @@ impl TryFrom<&str> for Cuboid {
 		Ok(Cuboid {
 			x: ranges[0],
 			y: ranges[1],
-            z: ranges[2]
+			z: ranges[2],
 		})
 	}
 }
@@ -129,7 +140,7 @@ impl TryFrom<&str> for RebootStep {
 		let action = match action_str {
 			"on" => StepAction::On,
 			"off" => StepAction::Off,
-            _ => return Err(Self::Error::BadAction)
+			_ => return Err(Self::Error::BadAction),
 		};
 
 		Ok(RebootStep(action, cuboid.try_into()?))
@@ -137,9 +148,7 @@ impl TryFrom<&str> for RebootStep {
 }
 
 pub fn parse_input(input: &str) -> Vec<RebootStep> {
-    input.lines()
+	input.lines().map(|l| l.try_into().unwrap()).collect()
-        .map(|l| l.try_into().unwrap())
-        .collect()
 }
 
 fn count_cubes_in_cuboid(steps: &[RebootStep], region: &Cuboid) -> u32 {
@@ -153,7 +162,7 @@ fn count_cubes_in_cuboid(steps: &[RebootStep], region: &Cuboid) -> u32 {
 					let cube = (x, y, z);
 					match step.0 {
 						StepAction::On => cubes.insert(cube),
-                        StepAction::Off => cubes.remove(&cube)
+						StepAction::Off => cubes.remove(&cube),
 					};
 				}
 			}
@@ -256,10 +265,10 @@ fn count_cubes(steps: Vec<RebootStep>) -> u64 {
 }
 
 pub fn part1(steps: &[RebootStep]) -> u32 {
-    let region = Cuboid{
+	let region = Cuboid {
 		x: (-50, 50),
 		y: (-50, 50),
-        z: (-50, 50)
+		z: (-50, 50),
 	};
 	count_cubes_in_cuboid(steps, &region)
 }
@@ -274,7 +283,8 @@ mod tests {
 
 	#[test]
 	fn part1_example() {
-        let steps = parse_input("on x=-20..26,y=-36..17,z=-47..7
+		let steps = parse_input(
+			"on x=-20..26,y=-36..17,z=-47..7
 on x=-20..33,y=-21..23,z=-26..28
 on x=-22..28,y=-29..23,z=-38..16
 on x=-46..7,y=-6..46,z=-50..-1
@@ -295,14 +305,16 @@ on x=-49..-5,y=-3..45,z=-29..18
 off x=18..30,y=-20..-8,z=-3..13
 on x=-41..9,y=-7..43,z=-33..15
 on x=-54112..-39298,y=-85059..-49293,z=-27449..7877
-on x=967..23432,y=45373..81175,z=27513..53682");
+on x=967..23432,y=45373..81175,z=27513..53682",
+		);
 		let result = part1(&steps);
 		assert_eq!(result, 590784);
 	}
 
 	#[test]
 	fn part2_example() {
-        let steps = parse_input("on x=-5..47,y=-31..22,z=-19..33
+		let steps = parse_input(
+			"on x=-5..47,y=-31..22,z=-19..33
 on x=-44..5,y=-27..21,z=-14..35
 on x=-49..-1,y=-11..42,z=-10..38
 on x=-20..34,y=-40..6,z=-44..1
@@ -361,7 +373,8 @@ off x=-37810..49457,y=-71013..-7894,z=-105357..-13188
 off x=-27365..46395,y=31009..98017,z=15428..76570
 off x=-70369..-16548,y=22648..78696,z=-1892..86821
 on x=-53470..21291,y=-120233..-33476,z=-44150..38147
-off x=-93533..-4276,y=-16170..68771,z=-104985..-24507");
+off x=-93533..-4276,y=-16170..68771,z=-104985..-24507",
+		);
 		let result = part2(steps);
 		assert_eq!(result, 2758514936282235);
 	}

src/day3.rs

@@ -1,7 +1,8 @@
 use std::{num::ParseIntError, slice::Iter};
 
 pub fn parse_input(input: &str) -> Result<Vec<i32>, ParseIntError> {
-    input.split_whitespace()
+	input
+		.split_whitespace()
 		.map(|s| i32::from_str_radix(s, 2))
 		.collect()
 }
@@ -33,7 +34,7 @@ pub fn part1(diagnostics: &[i32]) -> i32 {
 	let mut power = 1;
 	for _ in 1..=max_bits {
 		let bits = count_bits(diagnostics.iter(), &power);
-        if 2*bits >= n {
+		if 2 * bits >= n {
 			gamma += power;
 		} else {
 			epsilon += power;
@@ -52,29 +53,43 @@ pub fn part2(diagnostics: &[i32]) -> i32 {
 	oxygen_diagnostics.extend_from_slice(diagnostics);
 
 	let max_bits = calculate_max_bits(&diagnostics);
-    let mut power = 2i32.pow(max_bits-1);
+	let mut power = 2i32.pow(max_bits - 1);
 	for _ in 1..=max_bits {
 		let oxygen_len = oxygen_diagnostics.len() as u32;
 		if oxygen_len > 1 {
 			let bit_count = count_bits(oxygen_diagnostics.iter(), &power);
-            if 2*bit_count >= oxygen_len {
+			if 2 * bit_count >= oxygen_len {
-                oxygen_diagnostics = oxygen_diagnostics.into_iter().filter(|n| n & power > 0).collect();
+				oxygen_diagnostics = oxygen_diagnostics
+					.into_iter()
+					.filter(|n| n & power > 0)
+					.collect();
 			} else {
-                oxygen_diagnostics = oxygen_diagnostics.into_iter().filter(|n| n & power == 0).collect();
+				oxygen_diagnostics = oxygen_diagnostics
+					.into_iter()
+					.filter(|n| n & power == 0)
+					.collect();
 			}
 		}
 
 		let carbon_len = carbon_diagnostics.len() as u32;
 		if carbon_len > 1 {
 			let bit_count = count_bits(carbon_diagnostics.iter(), &power);
-            if 2*bit_count < carbon_len {
+			if 2 * bit_count < carbon_len {
-                carbon_diagnostics = carbon_diagnostics.into_iter().filter(|n| n & power > 0).collect();
+				carbon_diagnostics = carbon_diagnostics
+					.into_iter()
+					.filter(|n| n & power > 0)
+					.collect();
 			} else {
-                carbon_diagnostics = carbon_diagnostics.into_iter().filter(|n| n & power == 0).collect();
+				carbon_diagnostics = carbon_diagnostics
+					.into_iter()
+					.filter(|n| n & power == 0)
+					.collect();
 			}
 		}
 
-        if oxygen_len == 1 && carbon_len == 1 { break; }
+		if oxygen_len == 1 && carbon_len == 1 {
+			break;
+		}
 
 		power /= 2;
 	}
@@ -88,16 +103,21 @@ mod tests {
 
 	#[test]
 	fn part1_example() {
-        let diagnostics = [0b00100, 0b11110, 0b10110, 0b10111, 0b10101, 0b01111, 0b00111, 0b11100, 0b10000, 0b11001, 0b00010, 0b01010];
+		let diagnostics = [
+			0b00100, 0b11110, 0b10110, 0b10111, 0b10101, 0b01111, 0b00111, 0b11100, 0b10000, 0b11001,
+			0b00010, 0b01010,
+		];
 		let result = part1(&diagnostics);
 		assert_eq!(result, 198);
 	}
 
 	#[test]
 	fn part2_example() {
-        let diagnostics = [0b00100, 0b11110, 0b10110, 0b10111, 0b10101, 0b01111, 0b00111, 0b11100, 0b10000, 0b11001, 0b00010, 0b01010];
+		let diagnostics = [
+			0b00100, 0b11110, 0b10110, 0b10111, 0b10101, 0b01111, 0b00111, 0b11100, 0b10000, 0b11001,
+			0b00010, 0b01010,
+		];
 		let result = part2(&diagnostics);
 		assert_eq!(result, 230);
 	}
 }
-

src/day4.rs

@@ -1,10 +1,9 @@
 use std::num::ParseIntError;
 
-
 #[derive(Debug)]
 pub struct BingoGame {
 	numbers: Vec<i32>,
-    boards: Vec<[i32; 25]>
+	boards: Vec<[i32; 25]>,
 }
 
 #[derive(Debug)]
@@ -16,9 +15,7 @@ pub enum ParseBingoGameError {
 pub fn parse_input(input: &str) -> Result<BingoGame, ParseBingoGameError> {
 	let mut sections = input.split_terminator("\n\n");
 
-    let numbers_section = sections
+	let numbers_section = sections.next().ok_or(ParseBingoGameError::NoNumbersError)?;
-        .next()
-        .ok_or(ParseBingoGameError::NoNumbersError)?;
 
 	let numbers = numbers_section
 		.split_terminator(",")
@@ -33,8 +30,11 @@ pub fn parse_input(input: &str) -> Result<BingoGame, ParseBingoGameError> {
 		for row in section.split_terminator("\n") {
 			let mut x = 0;
 			for s in row.split_whitespace() {
-                let n = s.trim().parse::<i32>().map_err(ParseBingoGameError::ParseNumberError)?;
+				let n = s
-                board[5*y + x] = n;
+					.trim()
+					.parse::<i32>()
+					.map_err(ParseBingoGameError::ParseNumberError)?;
+				board[5 * y + x] = n;
 				x += 1;
 			}
 			y += 1;
@@ -58,7 +58,7 @@ fn mark_number(board: &[i32], markings: &mut i32, value: i32) -> bool {
 	let pos: usize;
 	match find_number(board, value) {
 		None => return false,
-        Some(n) => pos = n
+		Some(n) => pos = n,
 	};
 	*markings |= 1 << pos;
 	return true;
@@ -116,14 +116,21 @@ pub fn part2(game: &BingoGame) -> i32 {
 
 	for num in game.numbers.iter() {
 		for i in 0..game.boards.len() {
-            if winning_numbers[i] == 0 && mark_number(&game.boards[i], &mut markings[i], *num) && contains_win(markings[i]) {
+			if winning_numbers[i] == 0
+				&& mark_number(&game.boards[i], &mut markings[i], *num)
+				&& contains_win(markings[i])
+			{
 				winning_numbers[i] = *num;
 				last_winning_board = i;
 			}
 		}
 	}
 
-    return winning_numbers[last_winning_board] * sum_unmarked_numbers(&game.boards[last_winning_board], markings[last_winning_board]);
+	return winning_numbers[last_winning_board]
+		* sum_unmarked_numbers(
+			&game.boards[last_winning_board],
+			markings[last_winning_board],
+		);
 }
 
 #[cfg(test)]
@@ -141,30 +148,21 @@ mod tests {
 	#[test]
 	fn part1_example() {
 		let input = BingoGame {
-            numbers: vec![7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1],
+			numbers: vec![
+				7, 4, 9, 5, 11, 17, 23, 2, 0, 14, 21, 24, 10, 16, 13, 6, 15, 25, 12, 22, 18, 20, 8, 19, 3,
+				26, 1,
+			],
 			boards: vec![
 				[
-                    22, 13, 17, 11,  0,
+					22, 13, 17, 11, 0, 8, 2, 23, 4, 24, 21, 9, 14, 16, 7, 6, 10, 3, 18, 5, 1, 12, 20, 15, 19,
-                     8,  2, 23,  4, 24,
-                    21,  9, 14, 16,  7,
-                     6, 10,  3, 18,  5,
-                     1, 12, 20, 15, 19
 				],
 				[
-                     3, 15,  0,  2, 22,
+					3, 15, 0, 2, 22, 9, 18, 13, 17, 5, 19, 8, 7, 25, 23, 20, 11, 10, 24, 4, 14, 21, 16, 12, 6,
-                     9, 18, 13, 17,  5,
-                    19,  8,  7, 25, 23,
-                    20, 11, 10, 24,  4,
-                    14, 21, 16, 12,  6
 				],
 				[
-                    14, 21, 17, 24,  4,
+					14, 21, 17, 24, 4, 10, 16, 15, 9, 19, 18, 8, 23, 26, 20, 22, 11, 13, 6, 5, 2, 0, 12, 3, 7,
-                    10, 16, 15,  9, 19,
+				],
-                    18,  8, 23, 26, 20,
+			],
-                    22, 11, 13,  6,  5,
-                     2,  0, 12,  3,  7
-                ]
-            ]
 		};
 		let result = part1(&input);
 		assert_eq!(result, 4512);
@@ -173,30 +171,21 @@ mod tests {
 	#[test]
 	fn part2_example() {
 		let input = BingoGame {
-            numbers: vec![7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1],
+			numbers: vec![
+				7, 4, 9, 5, 11, 17, 23, 2, 0, 14, 21, 24, 10, 16, 13, 6, 15, 25, 12, 22, 18, 20, 8, 19, 3,
+				26, 1,
+			],
 			boards: vec![
 				[
-                    22, 13, 17, 11,  0,
+					22, 13, 17, 11, 0, 8, 2, 23, 4, 24, 21, 9, 14, 16, 7, 6, 10, 3, 18, 5, 1, 12, 20, 15, 19,
-                     8,  2, 23,  4, 24,
-                    21,  9, 14, 16,  7,
-                     6, 10,  3, 18,  5,
-                     1, 12, 20, 15, 19
 				],
 				[
-                     3, 15,  0,  2, 22,
+					3, 15, 0, 2, 22, 9, 18, 13, 17, 5, 19, 8, 7, 25, 23, 20, 11, 10, 24, 4, 14, 21, 16, 12, 6,
-                     9, 18, 13, 17,  5,
-                    19,  8,  7, 25, 23,
-                    20, 11, 10, 24,  4,
-                    14, 21, 16, 12,  6
 				],
 				[
-                    14, 21, 17, 24,  4,
+					14, 21, 17, 24, 4, 10, 16, 15, 9, 19, 18, 8, 23, 26, 20, 22, 11, 13, 6, 5, 2, 0, 12, 3, 7,
-                    10, 16, 15,  9, 19,
+				],
-                    18,  8, 23, 26, 20,
+			],
-                    22, 11, 13,  6,  5,
-                     2,  0, 12,  3,  7
-                ]
-            ]
 		};
 		let result = part2(&input);
 		assert_eq!(result, 1924);
@@ -226,4 +215,3 @@ mod tests {
 		assert!(contains_win(markings));
 	}
 }
-

src/day5.rs

@@ -1,4 +1,7 @@
-use std::{num::ParseIntError, cmp::{min, max}};
+use std::{
+	cmp::{max, min},
+	num::ParseIntError,
+};
 
 type Grid = Vec<Vec<i32>>;
 
@@ -7,23 +10,25 @@ pub struct Line {
 	x1: i32,
 	y1: i32,
 	x2: i32,
-    y2: i32
+	y2: i32,
 }
 
 #[derive(Debug)]
 pub enum ParseLineError {
 	ParseNumberError(ParseIntError),
 	ParsePointsError,
-    ParsePointError
+	ParsePointError,
 }
 
 pub fn parse_point(input: &str) -> Result<(i32, i32), ParseLineError> {
 	let mut parts = input.split(',');
-    let x = parts.next()
+	let x = parts
+		.next()
 		.ok_or(ParseLineError::ParsePointError)?
 		.parse()
 		.map_err(ParseLineError::ParseNumberError)?;
-    let y = parts.next()
+	let y = parts
+		.next()
 		.ok_or(ParseLineError::ParsePointError)?
 		.parse()
 		.map_err(ParseLineError::ParseNumberError)?;
@@ -142,16 +147,66 @@ mod tests {
 	#[test]
 	fn part1_example() {
 		let input = [
-            Line { x1: 0, y1: 9, x2: 5, y2: 9 },
+			Line {
-            Line { x1: 8, y1: 0, x2: 0, y2: 8 },
+				x1: 0,
-            Line { x1: 9, y1: 4, x2: 3, y2: 4 },
+				y1: 9,
-            Line { x1: 2, y1: 2, x2: 2, y2: 1 },
+				x2: 5,
-            Line { x1: 7, y1: 0, x2: 7, y2: 4 },
+				y2: 9,
-            Line { x1: 6, y1: 4, x2: 2, y2: 0 },
+			},
-            Line { x1: 0, y1: 9, x2: 2, y2: 9 },
+			Line {
-            Line { x1: 3, y1: 4, x2: 1, y2: 4 },
+				x1: 8,
-            Line { x1: 0, y1: 0, x2: 8, y2: 8 },
+				y1: 0,
-            Line { x1: 5, y1: 5, x2: 8, y2: 2 }
+				x2: 0,
+				y2: 8,
+			},
+			Line {
+				x1: 9,
+				y1: 4,
+				x2: 3,
+				y2: 4,
+			},
+			Line {
+				x1: 2,
+				y1: 2,
+				x2: 2,
+				y2: 1,
+			},
+			Line {
+				x1: 7,
+				y1: 0,
+				x2: 7,
+				y2: 4,
+			},
+			Line {
+				x1: 6,
+				y1: 4,
+				x2: 2,
+				y2: 0,
+			},
+			Line {
+				x1: 0,
+				y1: 9,
+				x2: 2,
+				y2: 9,
+			},
+			Line {
+				x1: 3,
+				y1: 4,
+				x2: 1,
+				y2: 4,
+			},
+			Line {
+				x1: 0,
+				y1: 0,
+				x2: 8,
+				y2: 8,
+			},
+			Line {
+				x1: 5,
+				y1: 5,
+				x2: 8,
+				y2: 2,
+			},
 		];
 		let result = part1(&input);
 		assert_eq!(result, 5);
@@ -160,16 +215,66 @@ mod tests {
 	#[test]
 	fn part2_example() {
 		let input = [
-            Line { x1: 0, y1: 9, x2: 5, y2: 9 },
+			Line {
-            Line { x1: 8, y1: 0, x2: 0, y2: 8 },
+				x1: 0,
-            Line { x1: 9, y1: 4, x2: 3, y2: 4 },
+				y1: 9,
-            Line { x1: 2, y1: 2, x2: 2, y2: 1 },
+				x2: 5,
-            Line { x1: 7, y1: 0, x2: 7, y2: 4 },
+				y2: 9,
-            Line { x1: 6, y1: 4, x2: 2, y2: 0 },
+			},
-            Line { x1: 0, y1: 9, x2: 2, y2: 9 },
+			Line {
-            Line { x1: 3, y1: 4, x2: 1, y2: 4 },
+				x1: 8,
-            Line { x1: 0, y1: 0, x2: 8, y2: 8 },
+				y1: 0,
-            Line { x1: 5, y1: 5, x2: 8, y2: 2 }
+				x2: 0,
+				y2: 8,
+			},
+			Line {
+				x1: 9,
+				y1: 4,
+				x2: 3,
+				y2: 4,
+			},
+			Line {
+				x1: 2,
+				y1: 2,
+				x2: 2,
+				y2: 1,
+			},
+			Line {
+				x1: 7,
+				y1: 0,
+				x2: 7,
+				y2: 4,
+			},
+			Line {
+				x1: 6,
+				y1: 4,
+				x2: 2,
+				y2: 0,
+			},
+			Line {
+				x1: 0,
+				y1: 9,
+				x2: 2,
+				y2: 9,
+			},
+			Line {
+				x1: 3,
+				y1: 4,
+				x2: 1,
+				y2: 4,
+			},
+			Line {
+				x1: 0,
+				y1: 0,
+				x2: 8,
+				y2: 8,
+			},
+			Line {
+				x1: 5,
+				y1: 5,
+				x2: 8,
+				y2: 2,
+			},
 		];
 		let result = part2(&input);
 		assert_eq!(result, 12);

src/day6.rs

@@ -1,7 +1,9 @@
 use std::num::ParseIntError;
 
 pub fn parse_input(input: &str) -> Result<Vec<i32>, ParseIntError> {
-    input.trim_end().split_terminator(',')
+	input
+		.trim_end()
+		.split_terminator(',')
 		.map(|s| s.parse())
 		.collect()
 }
@@ -45,7 +47,7 @@ pub fn part2(input: &[i32]) -> u64 {
 
 	for _ in 0..256 {
 		for i in 1..10 {
-            groups[i-1] += groups[i];
+			groups[i - 1] += groups[i];
 			groups[i] = 0;
 		}
 		groups[7] += groups[0];
@@ -66,16 +68,15 @@ mod tests {
 
 	#[test]
 	fn part1_example() {
-        let input = [3,4,3,1,2];
+		let input = [3, 4, 3, 1, 2];
 		let result = part1(&input);
 		assert_eq!(result, 5934);
 	}
 
 	#[test]
 	fn part2_example() {
-        let input = [3,4,3,1,2];
+		let input = [3, 4, 3, 1, 2];
 		let result = part2(&input);
 		assert_eq!(result, 26984457539 as u64);
 	}
 }
-

src/day7.rs

@@ -1,19 +1,25 @@
 use std::num::ParseIntError;
 
 pub fn parse_input(input: &str) -> Result<Vec<i32>, ParseIntError> {
-    input.trim_end().split_terminator(',')
+	input
+		.trim_end()
+		.split_terminator(',')
 		.map(|s| s.parse())
 		.collect()
 }
 
 fn abs(x: i32) -> u32 {
-    if x < 0 { -x as u32 } else { x as u32 }
+	if x < 0 {
+		-x as u32
+	} else {
+		x as u32
+	}
 }
 
 fn calculate_total_cost_to1(crabs: &[i32], target: i32) -> u32 {
 	let mut sum = 0;
 	for crab in crabs {
-        sum += abs(crab-target);
+		sum += abs(crab - target);
 	}
 	return sum;
 }
@@ -54,7 +60,7 @@ pub fn part2(crabs: &[i32]) -> u32 {
 	let average_position = calculate_average(crabs).round() as i32;
 	let mut best_cost = calculate_total_cost_to2(crabs, average_position);
 
-    for position in average_position-5..=average_position+5 {
+	for position in average_position - 5..=average_position + 5 {
 		let cost = calculate_total_cost_to2(crabs, position);
 		if cost < best_cost {
 			best_cost = cost;
@@ -70,16 +76,15 @@ mod tests {
 
 	#[test]
 	fn part1_example() {
-        let input = [16,1,2,0,4,2,7,1,2,14];
+		let input = [16, 1, 2, 0, 4, 2, 7, 1, 2, 14];
 		let result = part1(&input);
 		assert_eq!(result, 37);
 	}
 
 	#[test]
 	fn part2_example() {
-        let input = [16,1,2,0,4,2,7,1,2,14];
+		let input = [16, 1, 2, 0, 4, 2, 7, 1, 2, 14];
 		let result = part2(&input);
 		assert_eq!(result, 168);
 	}
 }
-

src/day8.rs

@@ -1,4 +1,4 @@
-use std::{convert::TryInto, collections::HashMap};
+use std::{collections::HashMap, convert::TryInto};
 
 pub struct Entry([String; 10], [String; 4]);
 
@@ -20,9 +20,7 @@ fn parse_line(line: &str) -> Entry {
 }
 
 pub fn parse_input(input: &str) -> Vec<Entry> {
-    input.lines()
+	input.lines().map(parse_line).collect()
-        .map(parse_line)
-        .collect()
 }
 
 pub fn part1(entries: &[Entry]) -> u32 {
@@ -51,7 +49,7 @@ fn signal_to_bitmask(signal: &str) -> u32 {
 			'e' => bitmask += 0b0010000,
 			'f' => bitmask += 0b0100000,
 			'g' => bitmask += 0b1000000,
-            _ => bitmask += 0
+			_ => bitmask += 0,
 		}
 	}
 	return bitmask;
@@ -66,7 +64,7 @@ fn decode_signals(signals: &[String], wire_loopup: &HashMap<u32, u32>) -> u32 {
 	let n = signals.len();
 	for i in 0..n {
 		let value = decode_signal(&signals[i], wire_loopup).unwrap();
-        number += value * u32::pow(10, (n-i-1) as u32);
+		number += value * u32::pow(10, (n - i - 1) as u32);
 	}
 	return number;
 }
@@ -144,16 +142,181 @@ mod tests {
 	#[test]
 	fn part1_example() {
 		let input = vec![
-            Entry(["be"      .into(), "cfbegad" .into(), "cbdgef"  .into(), "fgaecd"  .into(), "cgeb"    .into(), "fdcge"   .into(), "agebfd" .into(), "fecdb"  .into(), "fabcd"   .into(), "edb".into()], ["fdgacbe"    .into(), "cefdb"   .into(), "cefbgd"  .into(), "gcbe".into()]),
+			Entry(
-            Entry(["edbfga"  .into(), "begcd"   .into(), "cbg"     .into(), "gc"      .into(), "gcadebf" .into(), "fbgde"   .into(), "acbgfd" .into(), "abcde"  .into(), "gfcbed"  .into(), "gfec".into()], ["fcgedb"    .into(), "cgb"     .into(), "dgebacf" .into(), "gc".into()]),
+				[
-            Entry(["fgaebd"  .into(), "cg"      .into(), "bdaec"   .into(), "gdafb"   .into(), "agbcfd"  .into(), "gdcbef"  .into(), "bgcad"  .into(), "gfac"   .into(), "gcb"     .into(), "cdgabef".into()], ["cg"     .into(), "cg"      .into(), "fdcagb"  .into(), "cbg".into()]),
+					"be".into(),
-            Entry(["fbegcd"  .into(), "cbd"     .into(), "adcefb"  .into(), "dageb"   .into(), "afcb"    .into(), "bc"      .into(), "aefdc"  .into(), "ecdab"  .into(), "fgdeca"  .into(), "fcdbega".into()], ["efabcd" .into(), "cedba"   .into(), "gadfec"  .into(), "cb".into()]),
+					"cfbegad".into(),
-            Entry(["aecbfdg" .into(), "fbg"     .into(), "gf"      .into(), "bafeg"   .into(), "dbefa"   .into(), "fcge"    .into(), "gcbea"  .into(), "fcaegb" .into(), "dgceab"  .into(), "fcbdga".into()], ["gecf"    .into(), "egdcabf" .into(), "bgf"     .into(), "bfgea".into()]),
+					"cbdgef".into(),
-            Entry(["fgeab"   .into(), "ca"      .into(), "afcebg"  .into(), "bdacfeg" .into(), "cfaedg"  .into(), "gcfdb"   .into(), "baec"   .into(), "bfadeg" .into(), "bafgc"   .into(), "acf".into()], ["gebdcfa"    .into(), "ecba"    .into(), "ca"      .into(), "fadegcb".into()]),
+					"fgaecd".into(),
-            Entry(["dbcfg"   .into(), "fgd"     .into(), "bdegcaf" .into(), "fgec"    .into(), "aegbdf"  .into(), "ecdfab"  .into(), "fbedc"  .into(), "dacgb"  .into(), "gdcebf"  .into(), "gf".into()], ["cefg"        .into(), "dcbef"   .into(), "fcge"    .into(), "gbcadfe".into()]),
+					"cgeb".into(),
-            Entry(["bdfegc"  .into(), "cbegaf"  .into(), "gecbf"   .into(), "dfcage"  .into(), "bdacg"   .into(), "ed"      .into(), "bedf"   .into(), "ced"    .into(), "adcbefg" .into(), "gebcd".into()], ["ed"       .into(), "bcgafe"  .into(), "cdgba"   .into(), "cbgef".into()]),
+					"fdcge".into(),
-            Entry(["egadfb"  .into(), "cdbfeg"  .into(), "cegd"    .into(), "fecab"   .into(), "cgb"     .into(), "gbdefca" .into(), "cg"     .into(), "fgcdab" .into(), "egfdb"   .into(), "bfceg".into()], ["gbdfcae"  .into(), "bgc"     .into(), "cg"      .into(), "cgb".into()]),
+					"agebfd".into(),
-            Entry(["gcafb"   .into(), "gcf"     .into(), "dcaebfg" .into(), "ecagb"   .into(), "gf"      .into(), "abcdeg"  .into(), "gaef"   .into(), "cafbge" .into(), "fdbac"   .into(), "fegbdc".into()], ["fgae"    .into(), "cfgab"   .into(), "fg"      .into(), "bagce".into()]),
+					"fecdb".into(),
+					"fabcd".into(),
+					"edb".into(),
+				],
+				[
+					"fdgacbe".into(),
+					"cefdb".into(),
+					"cefbgd".into(),
+					"gcbe".into(),
+				],
+			),
+			Entry(
+				[
+					"edbfga".into(),
+					"begcd".into(),
+					"cbg".into(),
+					"gc".into(),
+					"gcadebf".into(),
+					"fbgde".into(),
+					"acbgfd".into(),
+					"abcde".into(),
+					"gfcbed".into(),
+					"gfec".into(),
+				],
+				["fcgedb".into(), "cgb".into(), "dgebacf".into(), "gc".into()],
+			),
+			Entry(
+				[
+					"fgaebd".into(),
+					"cg".into(),
+					"bdaec".into(),
+					"gdafb".into(),
+					"agbcfd".into(),
+					"gdcbef".into(),
+					"bgcad".into(),
+					"gfac".into(),
+					"gcb".into(),
+					"cdgabef".into(),
+				],
+				["cg".into(), "cg".into(), "fdcagb".into(), "cbg".into()],
+			),
+			Entry(
+				[
+					"fbegcd".into(),
+					"cbd".into(),
+					"adcefb".into(),
+					"dageb".into(),
+					"afcb".into(),
+					"bc".into(),
+					"aefdc".into(),
+					"ecdab".into(),
+					"fgdeca".into(),
+					"fcdbega".into(),
+				],
+				[
+					"efabcd".into(),
+					"cedba".into(),
+					"gadfec".into(),
+					"cb".into(),
+				],
+			),
+			Entry(
+				[
+					"aecbfdg".into(),
+					"fbg".into(),
+					"gf".into(),
+					"bafeg".into(),
+					"dbefa".into(),
+					"fcge".into(),
+					"gcbea".into(),
+					"fcaegb".into(),
+					"dgceab".into(),
+					"fcbdga".into(),
+				],
+				[
+					"gecf".into(),
+					"egdcabf".into(),
+					"bgf".into(),
+					"bfgea".into(),
+				],
+			),
+			Entry(
+				[
+					"fgeab".into(),
+					"ca".into(),
+					"afcebg".into(),
+					"bdacfeg".into(),
+					"cfaedg".into(),
+					"gcfdb".into(),
+					"baec".into(),
+					"bfadeg".into(),
+					"bafgc".into(),
+					"acf".into(),
+				],
+				[
+					"gebdcfa".into(),
+					"ecba".into(),
+					"ca".into(),
+					"fadegcb".into(),
+				],
+			),
+			Entry(
+				[
+					"dbcfg".into(),
+					"fgd".into(),
+					"bdegcaf".into(),
+					"fgec".into(),
+					"aegbdf".into(),
+					"ecdfab".into(),
+					"fbedc".into(),
+					"dacgb".into(),
+					"gdcebf".into(),
+					"gf".into(),
+				],
+				[
+					"cefg".into(),
+					"dcbef".into(),
+					"fcge".into(),
+					"gbcadfe".into(),
+				],
+			),
+			Entry(
+				[
+					"bdfegc".into(),
+					"cbegaf".into(),
+					"gecbf".into(),
+					"dfcage".into(),
+					"bdacg".into(),
+					"ed".into(),
+					"bedf".into(),
+					"ced".into(),
+					"adcbefg".into(),
+					"gebcd".into(),
+				],
+				["ed".into(), "bcgafe".into(), "cdgba".into(), "cbgef".into()],
+			),
+			Entry(
+				[
+					"egadfb".into(),
+					"cdbfeg".into(),
+					"cegd".into(),
+					"fecab".into(),
+					"cgb".into(),
+					"gbdefca".into(),
+					"cg".into(),
+					"fgcdab".into(),
+					"egfdb".into(),
+					"bfceg".into(),
+				],
+				["gbdfcae".into(), "bgc".into(), "cg".into(), "cgb".into()],
+			),
+			Entry(
+				[
+					"gcafb".into(),
+					"gcf".into(),
+					"dcaebfg".into(),
+					"ecagb".into(),
+					"gf".into(),
+					"abcdeg".into(),
+					"gaef".into(),
+					"cafbge".into(),
+					"fdbac".into(),
+					"fegbdc".into(),
+				],
+				["fgae".into(), "cfgab".into(), "fg".into(), "bagce".into()],
+			),
 		];
 		let result = part1(&input);
 		assert_eq!(result, 26);
@@ -162,16 +325,181 @@ mod tests {
 	#[test]
 	fn part2_example() {
 		let input = vec![
-            Entry(["be"      .into(), "cfbegad" .into(), "cbdgef"  .into(), "fgaecd"  .into(), "cgeb"    .into(), "fdcge"   .into(), "agebfd" .into(), "fecdb"  .into(), "fabcd"   .into(), "edb".into()], ["fdgacbe"    .into(), "cefdb"   .into(), "cefbgd"  .into(), "gcbe".into()]),
+			Entry(
-            Entry(["edbfga"  .into(), "begcd"   .into(), "cbg"     .into(), "gc"      .into(), "gcadebf" .into(), "fbgde"   .into(), "acbgfd" .into(), "abcde"  .into(), "gfcbed"  .into(), "gfec".into()], ["fcgedb"    .into(), "cgb"     .into(), "dgebacf" .into(), "gc".into()]),
+				[
-            Entry(["fgaebd"  .into(), "cg"      .into(), "bdaec"   .into(), "gdafb"   .into(), "agbcfd"  .into(), "gdcbef"  .into(), "bgcad"  .into(), "gfac"   .into(), "gcb"     .into(), "cdgabef".into()], ["cg"     .into(), "cg"      .into(), "fdcagb"  .into(), "cbg".into()]),
+					"be".into(),
-            Entry(["fbegcd"  .into(), "cbd"     .into(), "adcefb"  .into(), "dageb"   .into(), "afcb"    .into(), "bc"      .into(), "aefdc"  .into(), "ecdab"  .into(), "fgdeca"  .into(), "fcdbega".into()], ["efabcd" .into(), "cedba"   .into(), "gadfec"  .into(), "cb".into()]),
+					"cfbegad".into(),
-            Entry(["aecbfdg" .into(), "fbg"     .into(), "gf"      .into(), "bafeg"   .into(), "dbefa"   .into(), "fcge"    .into(), "gcbea"  .into(), "fcaegb" .into(), "dgceab"  .into(), "fcbdga".into()], ["gecf"    .into(), "egdcabf" .into(), "bgf"     .into(), "bfgea".into()]),
+					"cbdgef".into(),
-            Entry(["fgeab"   .into(), "ca"      .into(), "afcebg"  .into(), "bdacfeg" .into(), "cfaedg"  .into(), "gcfdb"   .into(), "baec"   .into(), "bfadeg" .into(), "bafgc"   .into(), "acf".into()], ["gebdcfa"    .into(), "ecba"    .into(), "ca"      .into(), "fadegcb".into()]),
+					"fgaecd".into(),
-            Entry(["dbcfg"   .into(), "fgd"     .into(), "bdegcaf" .into(), "fgec"    .into(), "aegbdf"  .into(), "ecdfab"  .into(), "fbedc"  .into(), "dacgb"  .into(), "gdcebf"  .into(), "gf".into()], ["cefg"        .into(), "dcbef"   .into(), "fcge"    .into(), "gbcadfe".into()]),
+					"cgeb".into(),
-            Entry(["bdfegc"  .into(), "cbegaf"  .into(), "gecbf"   .into(), "dfcage"  .into(), "bdacg"   .into(), "ed"      .into(), "bedf"   .into(), "ced"    .into(), "adcbefg" .into(), "gebcd".into()], ["ed"       .into(), "bcgafe"  .into(), "cdgba"   .into(), "cbgef".into()]),
+					"fdcge".into(),
-            Entry(["egadfb"  .into(), "cdbfeg"  .into(), "cegd"    .into(), "fecab"   .into(), "cgb"     .into(), "gbdefca" .into(), "cg"     .into(), "fgcdab" .into(), "egfdb"   .into(), "bfceg".into()], ["gbdfcae"  .into(), "bgc"     .into(), "cg"      .into(), "cgb".into()]),
+					"agebfd".into(),
-            Entry(["gcafb"   .into(), "gcf"     .into(), "dcaebfg" .into(), "ecagb"   .into(), "gf"      .into(), "abcdeg"  .into(), "gaef"   .into(), "cafbge" .into(), "fdbac"   .into(), "fegbdc".into()], ["fgae"    .into(), "cfgab"   .into(), "fg"      .into(), "bagce".into()]),
+					"fecdb".into(),
+					"fabcd".into(),
+					"edb".into(),
+				],
+				[
+					"fdgacbe".into(),
+					"cefdb".into(),
+					"cefbgd".into(),
+					"gcbe".into(),
+				],
+			),
+			Entry(
+				[
+					"edbfga".into(),
+					"begcd".into(),
+					"cbg".into(),
+					"gc".into(),
+					"gcadebf".into(),
+					"fbgde".into(),
+					"acbgfd".into(),
+					"abcde".into(),
+					"gfcbed".into(),
+					"gfec".into(),
+				],
+				["fcgedb".into(), "cgb".into(), "dgebacf".into(), "gc".into()],
+			),
+			Entry(
+				[
+					"fgaebd".into(),
+					"cg".into(),
+					"bdaec".into(),
+					"gdafb".into(),
+					"agbcfd".into(),
+					"gdcbef".into(),
+					"bgcad".into(),
+					"gfac".into(),
+					"gcb".into(),
+					"cdgabef".into(),
+				],
+				["cg".into(), "cg".into(), "fdcagb".into(), "cbg".into()],
+			),
+			Entry(
+				[
+					"fbegcd".into(),
+					"cbd".into(),
+					"adcefb".into(),
+					"dageb".into(),
+					"afcb".into(),
+					"bc".into(),
+					"aefdc".into(),
+					"ecdab".into(),
+					"fgdeca".into(),
+					"fcdbega".into(),
+				],
+				[
+					"efabcd".into(),
+					"cedba".into(),
+					"gadfec".into(),
+					"cb".into(),
+				],
+			),
+			Entry(
+				[
+					"aecbfdg".into(),
+					"fbg".into(),
+					"gf".into(),
+					"bafeg".into(),
+					"dbefa".into(),
+					"fcge".into(),
+					"gcbea".into(),
+					"fcaegb".into(),
+					"dgceab".into(),
+					"fcbdga".into(),
+				],
+				[
+					"gecf".into(),
+					"egdcabf".into(),
+					"bgf".into(),
+					"bfgea".into(),
+				],
+			),
+			Entry(
+				[
+					"fgeab".into(),
+					"ca".into(),
+					"afcebg".into(),
+					"bdacfeg".into(),
+					"cfaedg".into(),
+					"gcfdb".into(),
+					"baec".into(),
+					"bfadeg".into(),
+					"bafgc".into(),
+					"acf".into(),
+				],
+				[
+					"gebdcfa".into(),
+					"ecba".into(),
+					"ca".into(),
+					"fadegcb".into(),
+				],
+			),
+			Entry(
+				[
+					"dbcfg".into(),
+					"fgd".into(),
+					"bdegcaf".into(),
+					"fgec".into(),
+					"aegbdf".into(),
+					"ecdfab".into(),
+					"fbedc".into(),
+					"dacgb".into(),
+					"gdcebf".into(),
+					"gf".into(),
+				],
+				[
+					"cefg".into(),
+					"dcbef".into(),
+					"fcge".into(),
+					"gbcadfe".into(),
+				],
+			),
+			Entry(
+				[
+					"bdfegc".into(),
+					"cbegaf".into(),
+					"gecbf".into(),
+					"dfcage".into(),
+					"bdacg".into(),
+					"ed".into(),
+					"bedf".into(),
+					"ced".into(),
+					"adcbefg".into(),
+					"gebcd".into(),
+				],
+				["ed".into(), "bcgafe".into(), "cdgba".into(), "cbgef".into()],
+			),
+			Entry(
+				[
+					"egadfb".into(),
+					"cdbfeg".into(),
+					"cegd".into(),
+					"fecab".into(),
+					"cgb".into(),
+					"gbdefca".into(),
+					"cg".into(),
+					"fgcdab".into(),
+					"egfdb".into(),
+					"bfceg".into(),
+				],
+				["gbdfcae".into(), "bgc".into(), "cg".into(), "cgb".into()],
+			),
+			Entry(
+				[
+					"gcafb".into(),
+					"gcf".into(),
+					"dcaebfg".into(),
+					"ecagb".into(),
+					"gf".into(),
+					"abcdeg".into(),
+					"gaef".into(),
+					"cafbge".into(),
+					"fdbac".into(),
+					"fegbdc".into(),
+				],
+				["fgae".into(), "cfgab".into(), "fg".into(), "bagce".into()],
+			),
 		];
 		let result = part2(&input);
 		assert_eq!(result, 61229);

src/day9.rs

@@ -1,8 +1,8 @@
 use std::collections::HashSet;
 
-
 pub fn parse_input(input: &str) -> Vec<Vec<u32>> {
-    input.lines()
+	input
+		.lines()
 		.map(|s| s.chars().map(|c| c.to_digit(10).unwrap()).collect())
 		.collect()
 }
@@ -13,10 +13,11 @@ fn find_low_points(grid: &Vec<Vec<u32>>) -> Vec<(usize, usize)> {
 	for i in 0..height {
 		let width = grid[i].len();
 		for j in 0..width {
-            if (i == 0        || grid[i-1][j] > grid[i][j])
+			if (i == 0 || grid[i - 1][j] > grid[i][j])
-            && (i == height-1 || grid[i+1][j] > grid[i][j])
+				&& (i == height - 1 || grid[i + 1][j] > grid[i][j])
-            && (j == 0        || grid[i][j-1] > grid[i][j])
+				&& (j == 0 || grid[i][j - 1] > grid[i][j])
-            && (j == width-1  || grid[i][j+1] > grid[i][j]) {
+				&& (j == width - 1 || grid[i][j + 1] > grid[i][j])
+			{
 				low_points.push((i, j));
 			}
 		}
@@ -44,10 +45,18 @@ fn find_basin_size(grid: &Vec<Vec<u32>>, location: (usize, usize)) -> u32 {
 		explored_spots.insert(leaf_node);
 
 		let (i, j) = leaf_node;
-        if i > 0        && !explored_spots.contains(&(i-1, j)) && grid[i-1][j] != 9 { leaf_nodes.push((i-1, j)); }
+		if i > 0 && !explored_spots.contains(&(i - 1, j)) && grid[i - 1][j] != 9 {
-        if i < height-1 && !explored_spots.contains(&(i+1, j)) && grid[i+1][j] != 9 { leaf_nodes.push((i+1, j)); }
+			leaf_nodes.push((i - 1, j));
-        if j > 0        && !explored_spots.contains(&(i, j-1)) && grid[i][j-1] != 9 { leaf_nodes.push((i, j-1)); }
+		}
-        if j < width-1  && !explored_spots.contains(&(i, j+1)) && grid[i][j+1] != 9 { leaf_nodes.push((i, j+1)); }
+		if i < height - 1 && !explored_spots.contains(&(i + 1, j)) && grid[i + 1][j] != 9 {
+			leaf_nodes.push((i + 1, j));
+		}
+		if j > 0 && !explored_spots.contains(&(i, j - 1)) && grid[i][j - 1] != 9 {
+			leaf_nodes.push((i, j - 1));
+		}
+		if j < width - 1 && !explored_spots.contains(&(i, j + 1)) && grid[i][j + 1] != 9 {
+			leaf_nodes.push((i, j + 1));
+		}
 	}
 
 	return explored_spots.len() as u32;
@@ -67,7 +76,6 @@ pub fn part2(grid: Vec<Vec<u32>>) -> u32 {
 	return basin_sizes[0] * basin_sizes[1] * basin_sizes[2];
 }
 
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -79,7 +87,7 @@ mod tests {
 			vec![3, 9, 8, 7, 8, 9, 4, 9, 2, 1],
 			vec![9, 8, 5, 6, 7, 8, 9, 8, 9, 2],
 			vec![8, 7, 6, 7, 8, 9, 6, 7, 8, 9],
-            vec![9, 8, 9, 9, 9, 6, 5, 6, 7, 8]
+			vec![9, 8, 9, 9, 9, 6, 5, 6, 7, 8],
 		];
 		let result = part1(input);
 		assert_eq!(result, 15);
@@ -92,7 +100,7 @@ mod tests {
 			vec![3, 9, 8, 7, 8, 9, 4, 9, 2, 1],
 			vec![9, 8, 5, 6, 7, 8, 9, 8, 9, 2],
 			vec![8, 7, 6, 7, 8, 9, 6, 7, 8, 9],
-            vec![9, 8, 9, 9, 9, 6, 5, 6, 7, 8]
+			vec![9, 8, 9, 9, 9, 6, 5, 6, 7, 8],
 		];
 		let result = part2(input);
 		assert_eq!(result, 1134);

src/main.rs

@@ -20,6 +20,7 @@ mod day19;
 mod day20;
 mod day21;
 mod day22;
+mod day23;
 
 use std::{env, process};
 use std::fs::File;
@@ -80,6 +81,8 @@ fn run(day: i32, part: i32, input_filename: &str) {
         "21.2" => println!("{}", day21::part2(&day21::parse_input(&contents))),
         "22.1" => println!("{}", day22::part1(&day22::parse_input(&contents))),
         "22.2" => println!("{}", day22::part2(day22::parse_input(&contents))),
+        "23.1" => println!("{}", day23::part1(&day23::parse_input(&contents))),
+        "23.2" => println!("{}", day23::part2(&day23::parse_input(&contents))),
         _ => println!("Day {} part {} not found", day, part)
     }
 }