127 lines
4.1 KiB
Rust
127 lines
4.1 KiB
Rust
// https://adventofcode.com/2024/day/5
|
|
//
|
|
// Run command: cargo run ./input.txt
|
|
|
|
use std::{
|
|
collections::{HashMap, HashSet},
|
|
env,
|
|
error::Error,
|
|
fs::File,
|
|
io::{BufReader, prelude::*},
|
|
};
|
|
|
|
fn accumulate_middle_pages(page_updates: Vec<Vec<i64>>) -> i64 {
|
|
let mut accumulator = 0;
|
|
for update in page_updates {
|
|
let middle_page = update[update.len() / 2];
|
|
accumulator += middle_page;
|
|
}
|
|
accumulator
|
|
}
|
|
|
|
fn main() -> Result<(), Box<dyn Error>> {
|
|
// Handle command input
|
|
let args: Vec<String> = env::args().collect();
|
|
if args.len() != 2 {
|
|
panic!(
|
|
"{} must be run with a single argument of files name!",
|
|
&args[0]
|
|
)
|
|
}
|
|
let input_file = &args[1];
|
|
|
|
let buffer = BufReader::new(File::open(input_file)?);
|
|
|
|
let mut rules_stage = true;
|
|
let mut page_rules: HashMap<i64, HashSet<i64>> = HashMap::new();
|
|
let mut valid_page_updates: Vec<Vec<i64>> = Vec::new();
|
|
let mut invalid_page_updates: Vec<Vec<i64>> = Vec::new();
|
|
for line in buffer.lines() {
|
|
let line = line?;
|
|
if rules_stage {
|
|
// Stage 1: load rules
|
|
// Load rules that look like 1|1
|
|
if line.is_empty() {
|
|
// Blank line means end of rules
|
|
rules_stage = false;
|
|
// println!("Page Rules: {:?}", page_rules);
|
|
continue;
|
|
}
|
|
let split_line: Vec<&str> = line.split("|").collect();
|
|
if split_line.len() != 2 {
|
|
Err(format!("Invalid input in rules: {}", line))?;
|
|
}
|
|
|
|
// parse rule line and insert into out rule sets
|
|
let key = split_line[0].parse::<i64>()?;
|
|
let value = split_line[1].parse::<i64>()?;
|
|
match page_rules.get_mut(&key) {
|
|
Some(rule_set) => {
|
|
rule_set.insert(value);
|
|
}
|
|
None => {
|
|
let mut new_rule_set = HashSet::new();
|
|
new_rule_set.insert(value);
|
|
page_rules.insert(key, new_rule_set);
|
|
}
|
|
}
|
|
} else {
|
|
// Stage 2: check updates
|
|
let page_update: Vec<i64> = line
|
|
.split(",")
|
|
.map(|v| v.parse::<_>())
|
|
.collect::<Result<_, _>>()?;
|
|
|
|
let mut prev_pages: HashSet<i64> = HashSet::new();
|
|
let mut is_valid = true;
|
|
for page_num in page_update.iter() {
|
|
if let Some(rule_set) = page_rules.get(page_num) {
|
|
if !prev_pages.is_disjoint(rule_set) {
|
|
is_valid = false;
|
|
break;
|
|
}
|
|
prev_pages.insert(*page_num);
|
|
}
|
|
}
|
|
if is_valid {
|
|
valid_page_updates.push(page_update);
|
|
} else {
|
|
invalid_page_updates.push(page_update);
|
|
}
|
|
}
|
|
}
|
|
|
|
let accumulator = accumulate_middle_pages(valid_page_updates);
|
|
println!("Sum of middle pages from valid updates: {}", accumulator);
|
|
|
|
let mut fixed_updates = Vec::new();
|
|
for page_update in invalid_page_updates {
|
|
let mut reordered_page_update: Vec<i64> = Vec::new();
|
|
for page in page_update {
|
|
let inserted = if let Some(rule_set) = page_rules.get(&page) {
|
|
let mut inserted = false;
|
|
for (i, reordered_page) in reordered_page_update.iter().enumerate() {
|
|
if rule_set.contains(reordered_page) {
|
|
reordered_page_update.insert(i, page);
|
|
inserted = true;
|
|
break;
|
|
}
|
|
}
|
|
inserted
|
|
} else {
|
|
reordered_page_update.push(page);
|
|
true
|
|
};
|
|
if !inserted {
|
|
reordered_page_update.push(page);
|
|
}
|
|
}
|
|
fixed_updates.push(reordered_page_update);
|
|
}
|
|
|
|
let accumulator = accumulate_middle_pages(fixed_updates);
|
|
println!("Sum of middle pages from fixed updates: {}", accumulator);
|
|
|
|
Ok(())
|
|
}
|