day 3

day3/src/main.rs

@@ -0,0 +1,103 @@
+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);
+}