Day 6

data/examples/06.txt

@@ -0,0 +1,4 @@
+123 328  51 64 
+ 45 64  387 23 
+  6 98  215 314
+*   +   *   +  

src/bin/04.rs

@@ -1,7 +1,7 @@
 advent_of_code::solution!(4);
 
 pub fn part_one(input: &str) -> Option<u64> {
-    let mut map = input;
+    let map = input;
     let (accessible_rolls, new_map) = move_rolls(&map);
     println!("{}", new_map);
     Some(accessible_rolls)

src/bin/05.rs

@@ -14,10 +14,10 @@ pub fn part_one(input: &str) -> Option<u64> {
 
         let mut j = 0;
         while j < range_count {
-            if (debug) { println!("Checking ID {id} against range {}-{}", starts[j], ends[j]); }
+            if debug { println!("Checking ID {id} against range {}-{}", starts[j], ends[j]); }
             if starts[j] <= id && ends[j] >= id {
                 fresh_id_count += 1;
-                if (debug) { println!("ID {id} is fresh."); }
+                if debug { println!("ID {id} is fresh."); }
                 break;
             }    
             j += 1;
@@ -47,7 +47,7 @@ fn parse (input: &str) -> (Vec<u64>, Vec<u64>, Vec<u64>) {
             let parts: Vec<&str> = line.split("-").collect();
             let mut s :u64 = parts[0].parse().unwrap();
             let mut e: u64 = parts[1].parse().unwrap();
-            if (debug) { print!("Parsing range: {}-{}. ", parts[0], parts[1]); }
+            if debug { print!("Parsing range: {}-{}. ", parts[0], parts[1]); }
 
             let size: usize = starts.len();
             let mut starts_to_remove = Vec::new();
@@ -56,7 +56,7 @@ fn parse (input: &str) -> (Vec<u64>, Vec<u64>, Vec<u64>) {
             for i in 0..size {
                 let existing_start = *starts.iter().nth(i).unwrap();
                 let existing_end = *ends.iter().nth(i).unwrap();
-                if (debug) { print!("\n\tChecking against existing range {existing_start}-{existing_end}."); }
+                if debug { print!("\n\tChecking against existing range {existing_start}-{existing_end}."); }
 
                 // start before existing end.
                 // case 1: existing start, new start, existing end, new end
@@ -67,7 +67,7 @@ fn parse (input: &str) -> (Vec<u64>, Vec<u64>, Vec<u64>) {
                     starts_to_remove.push(existing_start);
                     ends_to_remove.push(existing_end);
                     overlaps += 1;
-                    if (debug) { println!("\n\tNew Range {existing_start}-{existing_end} overlaps with existing range {s}-{e}. Target range {new_start}-{new_end}"); }
+                    if debug { println!("\n\tNew Range {existing_start}-{existing_end} overlaps with existing range {s}-{e}. Target range {new_start}-{new_end}"); }
                     s = new_start;
                     e = new_end;    
                     continue;
@@ -108,7 +108,7 @@ mod tests {
     #[test]
     fn day5_test_part_one_overlap(){
         // overlaps at the end of existing range
-        let (starts, ends, ids) = parse(&advent_of_code::template::read_file("examples", DAY));
+        let (starts, ends, _ids) = parse(&advent_of_code::template::read_file("examples", DAY));
         let size: usize = starts.len();
 
         for i in 0..size {
@@ -117,13 +117,13 @@ mod tests {
         assert_eq!(size, 2);
 
         // overlaps at the start of existing range
-        let (starts, ends, ids) = parse("4-6\n1-5");
+        let (starts, ends, _ids) = parse("4-6\n1-5");
         assert_eq!(starts.len(), 1);
         assert_eq!(starts[0], 1);
         assert_eq!(ends[0], 6);
 
         // entirely inside existing range
-        let (starts, ends, ids) = parse("1-6\n3-5");
+        let (starts, ends, _ids) = parse("1-6\n3-5");
         assert_eq!(starts.len(), 1);
         assert_eq!(starts[0], 1);
         assert_eq!(ends[0], 6);

src/bin/06.rs

@@ -0,0 +1,138 @@
+advent_of_code::solution!(6);
+
+pub fn part_one(input: &str) -> Option<u64> {
+    let (values, rows, columns) = parse_one(input);
+    let number_rows = rows - 2;
+    let mut column_results = Vec::new();
+    for c in 0..columns {
+        let numbers = (0..=number_rows).map(|r| get_value(&values, columns, r, c).parse::<u64>().unwrap());
+        let operator = get_value(&values, columns, rows - 1, c);
+        let value:u64 = if operator == "+"              { numbers.sum() } 
+                        else if operator == "*"         { numbers.product() } else { panic!("Unknown operator {}", operator) };
+        println!("Column {c}: {:?} -> {} = {value}", (0..=number_rows).map(|r| get_value(&values, columns, r, c).parse::<u64>().unwrap()).collect::<Vec<u64>>(), operator);
+        column_results.push(value);
+    }
+    Some(column_results.iter().sum())
+}
+pub fn parse_one(input: &str) -> (Vec<&str>, usize, usize) {
+    let lines = input
+        .lines()
+        .filter(|line| !line.is_empty())
+        .collect::<Vec<&str>>();
+    let rows = lines.len();
+    let values = input.split_whitespace().collect::<Vec<&str>>();
+    let columns = values.len() / rows;
+
+    (values, rows, columns)
+}
+
+pub fn get_value<'a>(values: &'a Vec<&str>, width: usize, row: usize, col: usize) -> &'a str {
+    values[row * width + col]
+}
+
+pub fn parse_two(input: &str) -> (Vec<char>, usize, usize) {
+    let lines = input
+        .lines()
+        .filter(|line| !line.is_empty())
+        .collect::<Vec<&str>>();
+    let rows = lines.len();
+    let lchars = input.chars().collect::<Vec<char>>();
+    let columns = lchars.len() / rows;
+
+    (lchars, rows, columns)
+}
+pub fn part_two(input: &str) -> Option<u64> {
+    let (lchars, rows, cols) = parse_two(input);
+    println!("Rows: {}, Cols: {}", rows, cols);
+
+    let mut operator: char = ' ';
+    let mut problem_results: Vec<u64> = Vec::new();
+    let mut problem_parts: Vec<u64> = Vec::new();
+
+    for c in 0..cols {
+        let op_char = lchars[index(cols,rows -1, c)];
+        if op_char != ' ' { 
+            problem_parts = Vec::new();
+            operator = op_char; 
+            println!("problem operator: {operator} at index {}", index(cols,rows -1, c));
+        }
+
+        // read all the characters in this column except the final operator one.
+        let mut column_value = Vec::new();
+        for r in 0..rows - 1 {
+            let value = lchars[index(cols,r,c)];
+            if value == ' ' { continue; }
+            column_value.push(value);
+        }
+
+        let number_count = column_value.len();
+        // if there's a value, parse it to u64 and add to problem parts.
+        if number_count > 0 { 
+            let s: String = column_value.into_iter().collect();
+            let value = s.parse::<u64>().unwrap();
+            problem_parts.push(value);
+            println!("  Column {c} values: {value}");
+        }
+
+        // if it's an empty column, or the final column, this problem is complete. solve the problem and push the result.
+        if number_count == 0 || c == cols -1 { 
+            let value = if operator == '+' { 
+                                problem_parts.iter().sum() 
+                            } else if operator == '*' {
+                                problem_parts.iter().product()
+                            } else { 
+                                panic!("Unknown operator {operator}"); 
+                            };
+            println!("New Problem! Last Result = {value}");
+            problem_results.push(value);
+            continue; 
+        }
+// error here. it's conditional on an empty column to denote an end. if final column, it fails.
+
+    }
+
+    Some(problem_results.iter().sum())
+}
+
+pub fn index(width: usize, row: usize, col: usize) -> usize { row * (width + 1) + col }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn day6_test_parse_and_index(){
+        let input = &advent_of_code::template::read_file("examples", DAY);
+        let (values, rows, columns) = parse_one(input);
+        assert_eq!(rows, 4);
+        assert_eq!(columns, 4);
+        assert_eq!(get_value(&values.clone(), columns, 0, 0), "123");
+        assert_eq!(get_value(&values.clone(), columns, 0, 1), "328");
+        assert_eq!(get_value(&values.clone(), columns, 2, 3), "314");
+        assert_eq!(get_value(&values.clone(), columns, 3, 1), "+");
+    }
+
+    #[test]
+    fn day6_test_parse_2(){
+        let input = &advent_of_code::template::read_file("examples", DAY);
+        let (lchars, rows, columns) = parse_two(input);
+        for i in 0..lchars.len() {
+            print!("{i} : {}.  ", if lchars[i] == '\n' { "\\n".to_string() } else { lchars[i].to_string() } );
+        }
+        assert_eq!(rows, 4);
+        assert_eq!(columns, 15);
+        assert_eq!(lchars[index(columns,3,0)], '*');
+
+    }
+    #[test]
+    fn day6_test_part_one() {
+        let result = part_one(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(4277556));
+    }
+
+    #[test]
+    fn day6_test_part_two() {
+        let result = part_two(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(3263827));
+    }
+}