Day 3: Mull It Over

def compute_p1(input)
  re = /mul\((\d+),(\d+)\)/
  input.scan(re).map { |match|
    match.map(&:to_i).inject(:*)
  }.sum
end

def compute_p2(input)
  re = /(do)\(\)|(don't)\(\)|(mul)\((\d+),(\d+)\)/
  commands = input.scan(re).map(&:compact)

  state = :do
  value = 0
  until commands.empty?
    cmd = commands.shift
    case cmd[0]
    when "mul" then
      value += (cmd[1].to_i * cmd[2].to_i) unless state == :dont
    when "do"
      state = :do
    when "don't"
      state = :dont
    end
  end
  return value
end

import re
import sys

operands = re.findall(r'mul\((\d{1,3}),(\d{1,3})\)', sys.stdin.read())
print(sum(int(x) * int(y) for x, y in operands))

import re
import sys

memory = re.sub(r"don't\(\).*?(do\(\)|$)", '', sys.stdin.read(), flags=re.DOTALL)
operands = re.findall(r'mul\((\d{1,3}),(\d{1,3})\)', memory)
print(sum(int(x) * int(y) for x, y in operands))

/* Advent of Code 2024
 * Day 03: Mull It Over
 */

#import "Basic";
#import "File";
#import "String";

main :: () {
    input, success := read_entire_file("inputs/day_03.txt");
    assert(success);

    result_sum := 0;
    result_sum_conditional := 0;
    mul_enabled := true;

    // The shortest valid instruction is 4 characters long (do()), so
    // technically with this range, if do() appeared at the very end of the
    // input, we would ignore it. However, that's not a concern, since at that
    // point there is no more room for mul() instructions anyway, meaning the
    // do() instruction would be effectively useless.
    for 0..input.count - 9 {
        // Don't waste time checking slices that aren't even a possibility.
        // The only valid instructions start with m (mul) or d (do/don't).
        if input[it] != #char "m" && input[it] != #char "d" {
            continue;
        }

        // The maximum instruction size is 12 (a mul() instruction with two
        // three-digit numbers).
        instruction := slice(
            input,
            it,
            ifx it >= input.count - 12 then input.count - it else 12
        );

        end_index := find_index_from_left(instruction, #char ")");
        if end_index == -1 {
            continue;
        }

        trimmed_instruction := slice(instruction, 0, end_index + 1);
        if slice(trimmed_instruction, 0, 4) == "mul(" {
            numbers := split(
                slice(trimmed_instruction, 4, trimmed_instruction.count - 5),
                ","
            );

            if numbers.count == 2 {
                valid := true;
                for numbers {
                    all_numbers := true;
                    for it {
                        if it < #char "0" || it > #char "9" {
                            all_numbers = false;
                            break;
                        }
                    }

                    if !all_numbers {
                        valid = false;
                        break;
                    }
                }

                if valid {
                    result := (
                        string_to_int(numbers[0]) * string_to_int(numbers[1])
                    );

                    result_sum += result;
                    if mul_enabled {
                        result_sum_conditional += result;
                    }
                }
            }
        } else if trimmed_instruction == {
            case "do()";    mul_enabled = true;
            case "don't()"; mul_enabled = false;
        }
    }

    print("Part 1: %\nPart 2: %\n", result_sum, result_sum_conditional);
}

Class {
	#name : 'Day3Solver',
	#superclass : 'AoCSolver',
	#instVars : [
		'operations'
	],
	#category : 'AoCDay3',
	#package : 'AoCDay3'
}

Day3Solver >> evalMul: aString [ 
	| idx val1 val2 |
	idx := aString indexOf: $,.
	val1 := (aString copyFrom: 5 to: idx) asNumber.
	val2 := (aString copyFrom: (idx + 1) to: (aString size - 1)) asNumber.
	^ val1 * val2
]

Day3Solver >> parseRawData [
	operations := rawData regex: 'mul\(\d{1,3},\d{1,3}\)|do\(\)|don''t\(\)' matchesCollect: [ :x | x ]
]

Day3Solver >> solvePart1 [
	| mulOps |
	mulOps := operations select: [ :op | op beginsWith: 'mul' ].
	^ (mulOps collect: [ :mulOp | self evalMul: mulOp ]) sum
]

Day3Solver >> solvePart2 [
	| total shouldMul |
	total := 0.
	shouldMul := true.
	operations do: [ :op |
		((op beginsWith: 'mul') and: shouldMul)
			ifTrue: [ total := total + (self evalMul: op) ]
			ifFalse: [ shouldMul := op = 'do()' ] ].
	^ total
]

import "utils" as utils;

let input = utils::get_input(3, false);

// PART 1
let total = 0;
for (section, i) in input.split("mul(").extract(1) {
    let possible_params = section.split(")");
    if possible_params.len() < 2 {
        continue;
    }
    let possible_digits = possible_params[0].split(",");
    if possible_digits.len() != 2
       || possible_digits[0].to_chars().some(|c| c < '0' || c > '9')
       || possible_digits[1].to_chars().some(|c| c < '0' || c > '9') {
        continue;
    }
    let x = possible_digits[0].parse_int();
    let y = possible_digits[1].parse_int();
    total += x * y;
}

print(`part 1: ${total}`);

// PART 2
let total = 0;
let enabled = true;
for (section, i) in input.split("mul(") {
    if enabled && i != 0 {
        let possible_params = section.split(")");
        if possible_params.len() < 2 {
            continue;
        }
        let possible_digits = possible_params[0].split(",");
        if possible_digits.len() != 2
           || possible_digits[0].to_chars().some(|c| c < '0' || c > '9')
           || possible_digits[1].to_chars().some(|c| c < '0' || c > '9') {
            continue;
        }
        let x = possible_digits[0].parse_int();
        let y = possible_digits[1].parse_int();
        total += x * y;
    }
    if enabled && section.contains("don't()") {
        enabled = false;
    }
    if !enabled && section.contains("do()") {
        enabled = true;
    }
}

print(`part 2: ${total}`);

fn get_input(day, example) {
    if example {
        let input = open_file(`day${day}_example.txt`)
            .read_string();
        input.trim();
        input
    } else {
        let input = open_file(`day${day}.txt`)
            .read_string();
        input.trim();
        input
    }
}

fn is_sorted(array) {
    for i in 0..array.len()-1 {
        if array[i] > array[i+1] {
            return false;
        }
    }
    true
}

fn is_rev_sorted(array) {
    for i in range(array.len()-1, 0, -1) {
        if array[i] > array[i-1] {
            return false;
        }
    }
    true
}

fn is_ordered(array) {
    let fails = 0;
    for i in 0..array.len()-1 {
        if array[i] > array[i+1] {
            fails += 1;
            break;
        }
    }
    for i in range(array.len()-1, 0, -1) {
        if array[i] > array[i-1] {
            fails += 1;
            break;
        }
    }
    fails < 2
}

import "utils" as utils;

let input = utils::get_input(3, false);

// PART 1
let total = 0;
let regex = new_regex(#"mul\(([0-9]+),([0-9]+)\)"#);
for captures in regex.captures(input) {
    let x = captures[1].parse_int();
    let y = captures[2].parse_int();
    total += x * y;
}

print(`part 1: ${total}`);

// PART 2
let total = 0;
let enabled = true;
let regex = new_regex(#"(mul|do|don't)\((?:([0-9]+),([0-9]+))?\)"#);
for captures in regex.captures(input) {
    switch captures[1] {
        "don't" => enabled = false,
        "do" => enabled = true,
        "mul" if enabled => {
            let x = captures[2].parse_int();
            let y = captures[3].parse_int();
            total += x * y;
        }
    }
}

print(`part 2: ${total}`);

I first did this using RegEx, but that solution was kind of boring (even though it took me longer than it should have), so here's the hand-rolled evaluator for part 2 I came up with just now:

pub fn parse2(input: &str) -> PuzzleInput {
    let mut input = input;
    let mut enabled = true;
    let mut muls = Vec::new();

    while !input.is_empty() {
        if input.starts_with("do()") {
            input = &input[4..];
            enabled = true;
            continue;
        }

        if input.starts_with("don't()") {
            input = &input[7..];
            enabled = false;
            continue;
        }

        if !enabled || !input.starts_with("mul(") {
            input = &input[1..];
            continue;
        }

        // Skip "mul("
        input = &input[4..];

        let Some((a, b)) = input.split_once(")") else {
            // Unclosed parenthesis, skip the rest of the input
            break;
        };

        if a.len() > 7 {
            // Too many digits (also generally caused by unclosed or mismatched parentheses)
            input = &input[1..];
            continue;
        }

        let Some((x, y)) = a.split_once(",") else {
            // No comma -- skip past the parenthesis
            input = b;
            continue;
        };

        let x = x.parse::<usize>().unwrap();
        let y = y.parse::<usize>().unwrap();

        muls.push(x * y);

        input = b;
    }

    PuzzleInput { muls }
}

Doing it this way actually took less time to implement than installing a regex crate and figuring out how to properly escape everything, though of course, doing it for the second time avoids the stupid mistakes you make when you rush.

defmodule AdventOfCode.Solution.Year2024.Day03 do
  use AdventOfCode.Solution.SharedParse

  @impl true
  def parse(input), do: String.trim(input)

  def part1(mem) do
    ~r/mul\((\d{1,3}),(\d{1,3})\)/
    |> Regex.scan(mem, capture: :all_but_first)
    |> sum_of_products()
  end

  def part2(mem) do
    # (?| ...) drops unmatched alternatives from the returned captures.
    # E.g. matching "don't()" will produce ["don't()"] instead of ["", "", "", "don't()"]
    ~r"""
    (?|
      (mul)\((\d{1,3}),(\d{1,3})\)
      |(do)\(\)
      |(don't)\(\)
    )
    """x
    |> Regex.scan(mem, capture: :all_but_first)
    |> apply_toggles()
    |> sum_of_products()
  end

  defp sum_of_products(factor_pairs) do
    factor_pairs
    |> Enum.map(fn [a, b] -> String.to_integer(a) * String.to_integer(b) end)
    |> Enum.sum()
  end

  defp apply_toggles(matches) do
    Enum.reduce(matches, %{on?: true, acc: []}, fn
      ["mul" | factor_pair], state when state.on? -> update_in(state.acc, &[factor_pair | &1])
      ["mul" | _factor_pair], state when not state.on? -> state
      ["do"], state -> %{state | on?: true}
      ["don't"], state -> %{state | on?: false}
    end).acc
  end
end

=ARRAYFORMULA(
  SUM(
   BYROW(
    IFERROR(
     SPLIT(
      REGEXEXTRACT(
       TRANSPOSE(
        SPLIT(
         REGEXREPLACE(A1,"(mul)","|$1"),
         "|")),
       "(mul\(\d+,\d+\))"),
      "mul[](),")),
     LAMBDA(
      x,
      INDEX(x,0,1)*INDEX(x,0,2)))))

=ARRAYFORMULA(
  SUM(
   LET(s,
    SPLIT(
     QUERY(
      TOCOL(
       SPLIT(
        REGEXREPLACE(
         QUERY(
          TRANSPOSE(
           SPLIT(
            REGEXREPLACE(A1,"(do)","|$1"),
            "|")),
          "where Col1 starts with 'do()'",0),
         "(mul\(\d+,\d+\))","|$1|"),
        "|",1,1),
       3),
      "where Col1 matches '^mul\(\d+,\d+\).*'"),
     "mul(),"),
    INDEX(s,0,1)*INDEX(s,0,2))))

#! /usr/bin/env racket
#lang racket

(require math/base rackunit)

; TODO: Use #:match-select and capture groups
(define (day03/run-part01 in)
  (sum (map (lambda (lst)
              (foldl * 1 lst))
            (map (lambda (lst)
                   (map string->number (regexp-match* (pregexp "\\d{1,3}") lst)))
                 (regexp-match* (pregexp "mul\\(\\d{1,3},\\d{1,3}\\)")
                                (read-line in))))))

(define (day03/run-part02 in)
  (car (foldl (lambda (cur result)
                ; we pass a pair along with the current result + status
                (if (string? cur)
                    (if (equal? "don't()" cur)
                        (cons (car result) #f)
                        (cons (car result) #t))
                    (if (cdr result) ; should be 1
                        (cons (+ (* (car cur) (list-ref cur 1)) (car result)) #t)
                        result)))
              (cons 0 #t)
              (map (lambda (lst)
                     ; for "mul" operators, parse the strings into numbers and return as a list
                     (if (regexp-match #rx"mul" lst)
                         (map string->number (regexp-match* (pregexp "\\d{1,3}") lst))
                         lst))
                   ; match on any of the operators we know
                   (regexp-match* (pregexp "(mul\\((\\d{1,3}),(\\d{1,3})\\))|(don)'t\\(\\)|(do)\\(\\)")
                                  (read-line in))))))

(let ([input (open-input-file "inputs/day03.in")])
  (printf "~a\n" (day03/run-part01 input)))
(let ([input (open-input-file "inputs/day03.in")])
  (printf "~a\n" (day03/run-part02 input)))

(check-equal? (day03/run-part01 (open-input-file "examples/day03_1.in")) 161 "Test part 1")
(check-equal? (day03/run-part02 (open-input-file "examples/day03_2.in")) 48 "Test part 2")

(require 'uiop)

; Please install quicklisp on your own time from https://common-lisp-libraries.readthedocs.io/quicklisp/
(ql:quickload "cl-ppcre")

(defun mul-instructions (str)
  (ppcre:all-matches-as-strings "mul\\(([0-9]+),([0-9]+)\\)" str))

(defun get-enabled-portion (str)
  (let (
	(disables (ppcre:all-matches "don't\\(\\)" str))
	(enables (ppcre:all-matches "do\\(\\)" str))
	(result "")
	(enabled t))
    (progn
      (loop
	for index from 0
        for c in (coerce str 'list)
        do (progn
	     (when (equal (first disables) index)
	       (setq enabled nil)
	       (pop disables))
	     (when (equal (first enables) index)
	       (setq enabled t)
	       (pop enables))
	     (when enabled
	       (setq result (concatenate 'string result (list c))))))
      result)))

(defun numbers-to-multiply (instruction)
  (ppcre:register-groups-bind
    ((#'parse-integer num1 num2))
    ("mul\\(([0-9]+),([0-9]+)\\)" instruction :sharedp t)
    (list num1 num2)))

(defun all-multiplications (str)
  (mapcar #'numbers-to-multiply (mul-instructions str)))

(defun part1 (filename)
  (let* (
	 (str (uiop:read-file-string filename))
	 (multiplications (all-multiplications str))
	 (multiplied (mapcar
		       (lambda (nums)
			 (reduce #'* nums))
		       multiplications))
	 (total (reduce #'+ multiplied)))
    total))

(defun part2 (filename)
  (let* (
	 (str (uiop:read-file-string filename))
	 (active (get-enabled-portion str))
	 (multiplications (all-multiplications active))
	 (multiplied (mapcar
		       (lambda (nums)
			 (reduce #'* nums))
		       multiplications))
	 (total (reduce #'+ multiplied)))
    total))

import re
import click

class Day3Solver():
    def __init__(self, filename):
        with open(filename) as txtfile:
            self.text = txtfile.read()

    def solve(self):
        pattern = r"mul\(\d\d?\d?,\d\d?\d?\)|do\(\)|don't\(\)"
        mul_matches = re.findall(pattern, self.text)
        out = 0
        calculate = True
        for mul in mul_matches:
            if 'mul' in mul:
                if calculate:
                    values = mul[4:-1].split(',')
                    out = out + int(values[0])*int(values[1])
            elif 'do()' in mul:
                calculate = True
            elif "don't()" in mul:
                calculate = False
            # print(f"match: {mul}, calculate = {calculate}")
        return out

@click.command()
@click.argument('filename')
def main(filename):
    p = Day3Solver(filename)
    print(p.solve())

if __name__=="__main__":
    main()