74 lines
2.3 KiB
Rust
74 lines
2.3 KiB
Rust
use std::fs::File;
|
|
use std::io::{self, BufRead};
|
|
|
|
fn parse_instructions(file_path: &str) -> io::Result<Vec<String>> {
|
|
let file = File::open(file_path)?;
|
|
let lines = io::BufReader::new(file).lines();
|
|
let instructions: Vec<String> = lines.collect::<Result<_, _>>()?;
|
|
println!(
|
|
"Parsed {} instructions from {}",
|
|
instructions.len(),
|
|
file_path
|
|
);
|
|
Ok(instructions)
|
|
}
|
|
|
|
fn calculate_area(lines: &Vec<String>) -> i64 {
|
|
let directions: Vec<(i64, i64)> = vec![(0, 1), (1, 0), (0, -1), (-1, 0)];
|
|
let mut points: Vec<(i64, i64)> = vec![(0, 0)];
|
|
let mut boundary = 0;
|
|
|
|
for line in lines {
|
|
if line.is_empty() {
|
|
continue;
|
|
}
|
|
|
|
if let Some(color) = line.split(' ').last() {
|
|
let instructions = &color[2..color.len() - 1];
|
|
let direction_index =
|
|
i64::from_str_radix(&instructions[instructions.len() - 1..], 16).unwrap();
|
|
let (dr, dc) = directions[direction_index as usize];
|
|
let steps = i64::from_str_radix(&instructions[..instructions.len() - 1], 16).unwrap();
|
|
boundary += steps;
|
|
let (row, column) = points.last().unwrap();
|
|
points.push((row + dr * steps, column + dc * steps));
|
|
}
|
|
}
|
|
|
|
let mut area = 0;
|
|
for i in 0..points.len() {
|
|
let (x1, y1) = points[i];
|
|
let (x2, y2) = points[(i + 1) % points.len()];
|
|
area += x1 * y2 - x2 * y1;
|
|
}
|
|
|
|
(area.abs() / 2) + (boundary / 2) + 1
|
|
}
|
|
|
|
fn run_test(test_file: &str, expected_result: i64) -> io::Result<()> {
|
|
let lines = parse_instructions(test_file)?;
|
|
let calculated_area = calculate_area(&lines);
|
|
assert_eq!(calculated_area, expected_result, "Test failed");
|
|
println!("Test passed, area: {}", calculated_area);
|
|
Ok(())
|
|
}
|
|
|
|
fn main() {
|
|
let test_file = "../test.txt";
|
|
let input_file = "../input.txt";
|
|
let expected_test_area: i64 = 952408144115; // Replace with the correct expected area for the test
|
|
|
|
if let Err(e) = run_test(test_file, expected_test_area) {
|
|
eprintln!("Execution halted due to error: {}", e);
|
|
return;
|
|
}
|
|
|
|
match parse_instructions(input_file) {
|
|
Ok(lines) => {
|
|
let area = calculate_area(&lines);
|
|
println!("Puzzle result (area): {}", area);
|
|
}
|
|
Err(e) => eprintln!("Execution halted due to error: {}", e),
|
|
}
|
|
}
|