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

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

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!

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)

Python solution

just more parsing problems

deleted by creator

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)));
    }
}

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]));
        }
    }

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()

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;
}

F# solution

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

Ruby

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

I get the feeling that I should include some default types for handling 2D maps in my boilerplate, it’s a very recurring problem in AoC after all.

My solution is reasonably simplistic - and therefore also a bit slow, but the design meant I could do part 2 with just a few extra lines of code on the already processed data, here’s the functional part of it; (I push the previous days solution as part of my workflow for starting with the current day so the full code won’t be up until tomorrow)

Point = Struct.new('Point', :x, :y)
PartNumber = Struct.new('PartNumber', :number, :adjacent) do
  def adjacent?(to); adjacent.include?(to); end
  def irrelevant?; adjacent.empty?; end
  def to_i; number; end
end

class Implementation
  def initialize
    @map = []; @dim = { width: 0, height: 0 }; @symbols = []; @numbers = []
  end

  def input(line)
    @dim[:width] = line.size; @dim[:height] += 1
    @map += line.chars
  end

  def calc
    for y in (0..@dim[:height]-1) do
      for x in (0..@dim[:width]-1) do
        chr = get(x, y); next if chr =~ /\d/ || chr == '.'
        @symbols << Point.new(x, y)
      end
    end

    for y in (0..@dim[:height]-1) do
      buf = ""; adj = []
      for x in (0..@dim[:width]) do # Going one over, to fake a non-number as an end char on all lines
        chr = get(x, y)
        if chr =~ /\d/
          buf += chr
          (-1..1).each do |adj_x|
            (-1..1).each do |adj_y|
              next if adj_x == 0 && adj_y == 0 ||
                (x + adj_x < 0) || (x + adj_x >= @dim[:width]) ||
                (y + adj_y < 0) || (y + adj_y >= @dim[:height])
              sym = Point.new(x + adj_x, y + adj_y)
              adj << sym if @symbols.any? sym
            end
          end
        elsif !buf.empty?
          @numbers << PartNumber.new(buf.to_i, adj)
          buf = ""; adj = []
        end
      end
    end
  end

  def output
    part1 = @numbers.reject(&:irrelevant?).map(&:to_i).sum
    puts "Part 1:", part1

    gears = @symbols.select do |sym|
      next unless get(sym) == '*'
      next unless @numbers.select { |num| num.adjacent? sym }.size == 2
      true
    end
    part2 = gears.sum { |gear| @numbers.select { |num| num.adjacent? gear }.map(&:to_i).inject(:*) }

    puts "Part 2:", part2
  end

  private

  def get(x, y = -1)
    y = x.y if x.is_a?(Point)
    x = x.x if x.is_a?(Point)
    return unless (0..@dim[:width]-1).include?(x) && (0..@dim[:height]-1).include?(y)

    @map[y * @dim[:width] + x % @dim[:width]]
  end
end

Crystal

My computer crashed right most of the way through and I lost everything, so this was even more frustrating than it should have been
Also damn, lemmy’s tabs are massive

will post part 2 when I get to it

input = File.read("input.txt")

lines = input.lines.map(&.chars)

sum = 0
num_marker = nil
lines.each_with_index do |line, y|
	line.each_with_index do |char, x|
		num_marker ||= x if char.number?
	
		if (!char.number? || x == line.size-1) && num_marker
			if check_symbol(y, (num_marker-1)..x, lines)
				sum += lines[y][(char.number? ? num_marker..x : num_marker...x)].join.to_i 
			end
			num_marker = nil
end end end
puts sum

def check_symbol(y, rx, lines)
	carr = [ lines[y][rx.begin]?, lines[y][rx.end]? ]
	carr += rx.map {|x| lines[y-1][x]? } if y > 0  
	carr += rx.map {|x| lines[y+1][x]? } if y < lines.size-1 

	carr.each {|c| return true if c && c != '.' && !c.number?}
	false
end