Nim

I hope y’all like nested loops:

• Day 3, part 1
• Day 3, part 2

That was not fun to solve. Lots of ugly code. This is a less ugly second version. Language: Nim.

day_03.nim

Rust

I’ve been using Regexes for every day so far, this time it helped in finding numbers along with their start and end position in a line. For the second part I mostly went with the approach of part 1 which was to look at all numbers and then figure out if it has a part symbol around it. Only in part 2 I saved all numbers next to a gear * in a hash table that maps each gear position to a list of adjacent numbers. Then in the end I can just look at all gears with exactly 2 numbers attached.

Also it has to be said, multiplying two numbers is the exact opposite of getting their ratio!

I wrote today’s program in Python. (I am going to do a different language each day.) The only thing that gave me a little trouble was I was counting “\n” as a part label. Once I realized that I was able to get both problems done very quickly.

My code for the two parts is on github:-

• https://github.com/pngwen/advent-2023/blob/main/day-3a.py
• https://github.com/pngwen/advent-2023/blob/main/day-3b.py

My Python solution for part 1 and part 2. I really practice my regex skills.

#!/usr/bin/python3

import re

value_re = '(\d+)'
symbol_re = '[^\d.]'
gear_re = '(\*)'

def main():
    input = list()
    with open("input.txt", 'r') as in_file:
        for line in in_file:
            input.append(line.strip('\n'))
    length = len(input)
    width = len(input[0])
    value_sum = 0
    for idx, line in enumerate(input):
        for match in re.finditer(value_re, line):
            for line_mask in input[max(idx - 1, 0):min(idx + 2, length)]:
                valid_chars = line_mask[max(match.span()[0] - 1, 0):min(match.span()[1] + 1, width)]
                if re.search(symbol_re, valid_chars):
                    value_sum += int(match[0])
                    break
    print(f"Value sum = {value_sum}")

    gear_ratio = 0
    for idx, line in enumerate(input):
        for match in re.finditer(gear_re, line):
            valid_lines = input[max(idx - 1, 0):min(idx + 2, length)]
            min_range = max(match.span()[0] - 1, 0)
            max_range = min(match.span()[1], width)
            num_of_adjacent = 0
            temp_gear_ratio = 1
            for valid_line in valid_lines:
                for match in re.finditer(value_re, valid_line):
                    if match.span()[0] in range(min_range,max_range + 1) or match.span()[1] - 1 in range(min_range,max_range + 1):
                        num_of_adjacent += 1
                        temp_gear_ratio *= int(match[0])
            if num_of_adjacent == 2:
                gear_ratio += temp_gear_ratio
    print(f"Gear ratio = {gear_ratio}")

if __name__ == '__main__':
    main()

Python solution

just more parsing problems

Edit: Updated now with part 2.

Managed to have a crack at this a bit earlier today, I’ve only done Part 01 so far. I’ll update with Part 02 later.

I tackled this with the personal challenge of not loading the entire puzzle input into memory, which would have made this a bit easier.

Solution in Rust 🦀

View formatted on GitLab

use std::{
    env, fs,
    io::{self, BufRead, BufReader, Read},
};

fn main() -> io::Result<()> {
    let args: Vec = env::args().collect();
    let filename = &args[1];
    let file1 = fs::File::open(filename)?;
    let file2 = fs::File::open(filename)?;
    let reader1 = BufReader::new(file1);
    let reader2 = BufReader::new(file2);

    println!("Part one: {}", process_part_one(reader1));
    println!("Part two: {}", process_part_two(reader2));
    Ok(())
}

fn process_part_one(reader: BufReader) -> u32 {
    let mut lines = reader.lines().peekable();
    let mut prev_line: Option = None;
    let mut sum = 0;
    while let Some(line) = lines.next() {
        let current_line = line.expect("line exists");
        let next_line = match lines.peek() {
            Some(Ok(line)) => Some(line),
            Some(Err(_)) => None,
            None => None,
        };
        match (prev_line, next_line) {
            (None, Some(next)) => {
                let lines = vec![¤t_line, next];
                sum += parse_lines(lines, true);
            }
            (Some(prev), Some(next)) => {
                let lines = vec![&prev, ¤t_line, next];
                sum += parse_lines(lines, false);
            }
            (Some(prev), None) => {
                let lines = vec![&prev, ¤t_line];
                sum += parse_lines(lines, false);
            }
            (None, None) => {}
        }

        prev_line = Some(current_line);
    }
    sum
}

fn process_part_two(reader: BufReader) -> u32 {
    let mut lines = reader.lines().peekable();
    let mut prev_line: Option = None;
    let mut sum = 0;
    while let Some(line) = lines.next() {
        let current_line = line.expect("line exists");
        let next_line = match lines.peek() {
            Some(Ok(line)) => Some(line),
            Some(Err(_)) => None,
            None => None,
        };
        match (prev_line, next_line) {
            (None, Some(next)) => {
                let lines = vec![¤t_line, next];
                sum += parse_lines_for_gears(lines, true);
            }
            (Some(prev), Some(next)) => {
                let lines = vec![&prev, ¤t_line, next];
                sum += parse_lines_for_gears(lines, false);
            }
            (Some(prev), None) => {
                let lines = vec![&prev, ¤t_line];
                sum += parse_lines_for_gears(lines, false);
            }
            (None, None) => {}
        }

        prev_line = Some(current_line);
    }

    sum
}

fn parse_lines(lines: Vec<&String>, first_line: bool) -> u32 {
    let mut sum = 0;
    let mut num = 0;
    let mut valid = false;
    let mut char_vec: Vec> = Vec::new();
    for line in lines {
        char_vec.push(line.chars().collect());
    }
    let chars = match first_line {
        true => &char_vec[0],
        false => &char_vec[1],
    };
    for i in 0..chars.len() {
        if chars[i].is_digit(10) {
            // Add the digit to the number
            num = num * 10 + chars[i].to_digit(10).expect("is digit");

            // Check the surrounding character for non-period symbols
            for &x in &[-1, 0, 1] {
                for chars in &char_vec {
                    if (i as isize + x).is_positive() && ((i as isize + x) as usize) < chars.len() {
                        let index = (i as isize + x) as usize;
                        if !chars[index].is_digit(10) && chars[index] != '.' {
                            valid = true;
                        }
                    }
                }
            }
        } else {
            if valid {
                sum += num;
            }
            valid = false;
            num = 0;
        }
    }
    if valid {
        sum += num;
    }
    sum
}

fn parse_lines_for_gears(lines: Vec<&String>, first_line: bool) -> u32 {
    let mut sum = 0;
    let mut char_vec: Vec> = Vec::new();
    for line in &lines {
        char_vec.push(line.chars().collect());
    }
    let chars = match first_line {
        true => &char_vec[0],
        false => &char_vec[1],
    };
    for i in 0..chars.len() {
        if chars[i] == '*' {
            let surrounding_nums = get_surrounding_numbers(&lines, i);
            let product = match surrounding_nums.len() {
                0 | 1 => 0,
                _ => surrounding_nums.iter().product(),
            };
            sum += product;
        }
    }
    sum
}

fn get_surrounding_numbers(lines: &Vec<&String>, gear_pos: usize) -> Vec {
    let mut nums: Vec = Vec::new();
    let mut num: u32 = 0;
    let mut valid = false;
    for line in lines {
        for (i, char) in line.chars().enumerate() {
            if char.is_digit(10) {
                num = num * 10 + char.to_digit(10).expect("is digit");
                if [gear_pos - 1, gear_pos, gear_pos + 1].contains(&i) {
                    valid = true;
                }
            } else if num > 0 && valid {
                nums.push(num);
                num = 0;
                valid = false;
            } else {
                num = 0;
                valid = false;
            }
        }
        if num > 0 && valid {
            nums.push(num);
        }
        num = 0;
        valid = false;
    }
    nums
}

#[cfg(test)]
mod tests {
    use super::*;

    const INPUT: &str = "467..114..
...*......
..35..633.
......#...
617*......
.....+.58.
..592.....
......755.
...$.*....
.664.598..";

    #[test]
    fn test_process_part_one() {
        let input_bytes = INPUT.as_bytes();
        assert_eq!(4361, process_part_one(BufReader::new(input_bytes)));
    }

    #[test]
    fn test_process_part_two() {
        let input_bytes = INPUT.as_bytes();
        assert_eq!(467835, process_part_two(BufReader::new(input_bytes)));
    }
}

Python

Questions and comments welcome!

import collections
import re

from .solver import Solver

class Day03(Solver):
  def __init__(self):
    super().__init__(3)
    self.lines = []

  def presolve(self, input: str):
    self.lines = input.rstrip().split('\n')

  def solve_first_star(self):
    adjacent_to_symbols = set()
    for i, line in enumerate(self.lines):
      for j, sym in enumerate(line):
        if sym in ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.'):
          continue
        for di in (-1, 0, 1):
          for dj in (-1, 0, 1):
            adjacent_to_symbols.add((i + di, j + dj))
    numbers = []
    for i, line in enumerate(self. lines):
      for number_match in re.finditer(r'\d+', line):
        is_adjacent_to_symbol = False
        for j in range(number_match.start(), number_match.end()):
          if (i, j) in adjacent_to_symbols:
            is_adjacent_to_symbol = True
        if is_adjacent_to_symbol:
          numbers.append(int(number_match.group()))
    return sum(numbers)

  def solve_second_star(self):
    gear_numbers = collections.defaultdict(list)
    adjacent_to_gears = {}
    for i, line in enumerate(self.lines):
      for j, sym in enumerate(line):
        if sym == '*':
          for di in (-1, 0, 1):
            for dj in (-1, 0, 1):
              adjacent_to_gears[(i + di, j + dj)] = (i, j)
    for i, line in enumerate(self. lines):
      for number_match in re.finditer(r'\d+', line):
        adjacent_to_gear = None
        for j in range(number_match.start(), number_match.end()):
          if (i, j) in adjacent_to_gears:
            adjacent_to_gear = adjacent_to_gears[(i, j)]
        if adjacent_to_gear:
          gear_numbers[adjacent_to_gear].append(int(number_match.group()))
    ratios = []
    for gear_numbers in gear_numbers.values():
      match gear_numbers:
        case [a, b]:
          ratios.append(a * b)
    return sum(ratios)

deleted by creator

Language: C#

I aimed at keeping it as simple and short as reasonably possible this time, no overbuilding here!

I even used a goto to let me break out of multiple loops at once 🤮 (I had to look up how they worked!) I would totally fail me in a code review!

internal class Day3 : IRunnable
    {
        public void Run()
        {
            var input = File.ReadAllLines("Days/Three/Day3Input.txt");
            int sum = 0;
            string numStr = "";
            var starMap = new Dictionary<(int,int),List>();
            for (int i = 0; i < input.Length; i++)           
                for (int j = 0; j < input[i].Length; j++)
                {
                    if (char.IsDigit(input[i][j]))                    
                        numStr += input[i][j];                    
                    if (numStr.Length > 0 && (j == input[i].Length - 1 || !char.IsDigit(input[i][j + 1])))
                    {
                        for (int k = Math.Max(0, i - 1); k < Math.Min(i + 2, input.Length); k++)                        
                            for (int l = Math.Max(0, j - numStr.Length); l < Math.Min(j + 2, input[i].Length); l++)                            
                                if (!char.IsDigit(input[k][l]) && input[k][l] != '.')
                                {
                                    sum += int.Parse(numStr);
                                    if (input[k][l] == '*')
                                    {
                                        if (starMap.ContainsKey((k, l)))                                        
                                            starMap[(k, l)].Add(int.Parse(numStr));                                        
                                        else
                                            starMap.Add((k,l),new List { int.Parse(numStr) });
                                    }
                                    goto endSymbSearch;
                                }                           
                    endSymbSearch:
                        numStr = "";
                    }
                }            
            Console.WriteLine("Result1:"+sum.ToString());
            Console.WriteLine("Result2:" + starMap.Where(sm => sm.Value.Count == 2).Sum(sm => sm.Value[0] * sm.Value[1]));
        }
    }

Dart Solution

Holy moley, if this year is intended to be impervious to AI solution, it’s also working pretty well as a filter to this paltry Human Intelligence.

Find interesting symbols, look around for digits, and expand these into numbers. A dirty hacky solution leaning on a re-used Grid class. Not recommended.

late ListGrid grid;

Index look(Index ix, Index dir) {
  var here = ix;
  var next = here + dir;
  while (grid.isInBounds(next) && '1234567890'.contains(grid.at(next))) {
    here = next;
    next = here + dir;
  }
  return here;
}

/// Return start and end indices of a number at a point.
(Index, Index) expandNumber(Index ix) =>
    (look(ix, Grid.dirs['L']!), look(ix, Grid.dirs['R']!));

int parseNumber((Index, Index) e) => int.parse([
      for (var i = e.$1; i != e.$2 + Grid.dirs['R']!; i += Grid.dirs['R']!)
        grid.at(i)
    ].join());

/// Return de-duplicated positions of all numbers near the given symbols.
nearSymbols(Set syms) => [
      for (var ix in grid.indexes.where((i) => syms.contains(grid.at(i))))
        {
          for (var n in grid
              .near8(ix)
              .where((n) => ('1234567890'.contains(grid.at(n)))))
            expandNumber(n)
        }.toList()
    ];

part1(List lines) {
  grid = ListGrid([for (var e in lines) e.split('')]);
  var syms = lines
      .join('')
      .split('')
      .toSet()
      .difference('0123456789.'.split('').toSet());
  // Find distinct number locations near symbols and sum them.
  return {
    for (var ns in nearSymbols(syms))
      for (var n in ns) n
  }.map(parseNumber).sum;
}

part2(List lines) {
  grid = ListGrid([for (var e in lines) e.split('')]);
  // Look for _pairs_ of numbers near '*' and multiply them.
  var products = [
    for (var ns in nearSymbols({'*'}).where((e) => e.length == 2))
      ns.map(parseNumber).reduce((s, t) => s * t)
  ];
  return products.sum;
}

Factor on github (with comments and imports):

: symbol-indices ( line -- seq )
  [ ".0123456789" member? not ] find-all [ first ] map
;

: num-spans ( line -- seq )
  >array [ over digit? [ nip ] [ 2drop f ] if ] map-index
  { f } split harvest
  [ [ first ] [ last ] bi 2array ] map
;

: adjacent? ( num-span symbol-indices -- ? )
  swap [ first 1 - ] [ last 1 + ] bi [a,b]
  '[ _ interval-contains? ] any?
;

: part-numbers ( line nearby-symbol-indices -- seq )
  [ dup num-spans ] dip
  '[ _ adjacent? ] filter
  swap '[ first2 1 + _ subseq string>number ] map
;

: part1 ( -- )
  "vocab:aoc-2023/day03/input.txt" utf8 file-lines
  [ [ symbol-indices ] map ] keep
  [
    pick swap [ 1 - ?nth-of ] [ nth-of ] [ 1 + ?nth-of ] 2tri
    3append part-numbers sum
  ] map-index sum nip .
;

: star-indices ( line -- seq )
  [ CHAR: * = ] find-all [ first ] map
;

: gears ( line prev-line next-line -- seq-of-pairs )
  pick star-indices
  [ 1array '[ _ part-numbers ] [ 3dup ] dip tri@ 3append ]
  [ length 2 = ] map-filter [ 3drop ] dip
;

: part2 ( -- )
  "vocab:aoc-2023/day03/input.txt" utf8 file-lines
  dup [
    pick swap [ 1 - ?nth-of ] [ 1 + ?nth-of ] 2bi
    gears [ product ] map-sum
  ] map-index sum nip .
;

Python, used a number map to search positions near symbols.

https://github.com/massahud/advent-of-code-2023/blob/main/day03/day03.ipynb

Ruby

My goodness I struggled today. https://github.com/snowe2010/advent-of-code/blob/master/ruby_aoc/2023/day03/day03.rb

F# solution

Had an off-by-one error that took me a while to find