104 lines
3.8 KiB
Rust
104 lines
3.8 KiB
Rust
use std::fs::read_to_string;
|
|
|
|
fn main() {
|
|
// store of numbers
|
|
let mut numbers: Vec<i32> = Vec::new();
|
|
// whether the number counts
|
|
let mut numbers_occur: Vec<bool> = Vec::new();
|
|
// spatial information about the data
|
|
// natural number is index in numbers table, negative are special
|
|
let mut adjacency_table: Vec<i32> = Vec::new();
|
|
const EMPTY_SPACE: i32 = -1;
|
|
const SYMBOL: i32 = -2;
|
|
const GEAR: i32 = -3;
|
|
let mut row_counter = 0;
|
|
let mut col_counter = 0;
|
|
for line in read_to_string("input.txt").unwrap().lines() {
|
|
let mut parsing_number = false;
|
|
let mut constructed_number = 0;
|
|
if line.is_empty() {
|
|
break;
|
|
}
|
|
col_counter += 1;
|
|
row_counter = line.len() as i32;
|
|
for c in line.chars() {
|
|
match c {
|
|
'0'..='9' => {
|
|
let value = c as i32 - '0' as i32;
|
|
constructed_number = constructed_number * 10 + value;
|
|
parsing_number = true;
|
|
adjacency_table.push(numbers.len() as i32);
|
|
}
|
|
_ => {
|
|
if parsing_number {
|
|
numbers.push(constructed_number);
|
|
numbers_occur.push(false);
|
|
parsing_number = false;
|
|
constructed_number = 0;
|
|
}
|
|
match c {
|
|
'.' => {
|
|
adjacency_table.push(EMPTY_SPACE);
|
|
}
|
|
'*' => {
|
|
adjacency_table.push(GEAR);
|
|
}
|
|
_ => {
|
|
adjacency_table.push(SYMBOL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if parsing_number {
|
|
numbers.push(constructed_number);
|
|
numbers_occur.push(false);
|
|
}
|
|
}
|
|
let mut sum1 = 0;
|
|
let mut sum2 = 0;
|
|
for row in 0 .. row_counter {
|
|
for col in 0 ..col_counter {
|
|
let value = adjacency_table[(row * col_counter + col) as usize];
|
|
if value == SYMBOL || value == GEAR {
|
|
let mut num1 = -1;
|
|
let mut num2 = -1;
|
|
let mut valid_gear = value == GEAR;
|
|
for offset_row in -1..2 {
|
|
for offset_col in -1..2 {
|
|
let new_row = row + offset_row;
|
|
let new_col = col + offset_col;
|
|
if new_row >= 0 && new_row < row_counter && new_col >= 0 && new_col < col_counter {
|
|
let new_value = adjacency_table[(new_row * col_counter + new_col) as usize];
|
|
if new_value >= 0 {
|
|
numbers_occur[new_value as usize] = true;
|
|
if value == GEAR {
|
|
if num1 == -1 {
|
|
num1 = new_value;
|
|
} else if num1 != new_value {
|
|
if num2 == -1 {
|
|
num2 = new_value;
|
|
} else if num2 != new_value {
|
|
valid_gear = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if valid_gear && num1 >= 0 && num2 >= 0 {
|
|
sum2 += numbers[num1 as usize] * numbers[num2 as usize];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for i in 0 .. numbers.len() {
|
|
if numbers_occur[i] {
|
|
sum1 += numbers[i];
|
|
}
|
|
}
|
|
println!("Sum1: {}", sum1);
|
|
println!("Sum2: {}", sum2);
|
|
}
|