I did part 2 live with the python interactive shell. I deleted all the stuff where I was just exploring ideas.

part 1:

import re

def multiply_and_add(data: "str") -> int:
    digit_matches = re.findall(r"mul\(\d{0,3},\d{0,3}\)", data)
    result = 0
    for _ in digit_matches:
        first = _.split("(")[1].split(")")[0].split(",")[0]
        second = _.split("(")[1].split(")")[0].split(",")[1]
        result += int(first) * int(second)

    return result

with open("input") as file:
    data = file.read()


answer = multiply_and_add(data)
print(answer)

part 2:

Python 3.11.2 (main, Aug 26 2024, 07:20:54) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import solution2
<re.Match object; span=(647, 651), match='do()'>
>>> from solution2 import *
>>> split_on_dont = data.split("don't()")
>>> valid = []
>>> valid.append(split_on_dont[0])
>>> for substring in split_on_dont[1:]:
...     subsubstrings = substring.split("do()", maxsplit=1)
...     for subsubstring in subsubstrings[1:]:
...             valid.append(subsubstring)
...
>>> answer = 0
>>> for _ in valid:
...     answer += multiply_and_add(_)
...
>>> answer
103811193

Smalltalk

I wrote matchesActual cause all of smalltalk'sstupid matchesDo: or whatever don't give you the actual match with captures, only substrings (that wasted a good 40 minutes).

Also smalltalk really needs an index operator

day3p1: input
  | reg sum |
    reg := 'mul\((\d\d?\d?),(\d\d?\d?)\)' asRegex.
    sum := 0.
    
    reg matchesActual: input do: [ :m | " + sum at end cause operator precedence"
        sum := (m subexpression: 2) asInteger * (m subexpression: 3) asInteger + sum 
    ].
    
    ^ sum.

day3p2: input
  | reg sum do val |

    reg := 'do(\:?n''t)?\(\)|mul\((\d{1,3}),(\d{1,3})\)' asRegex.
    sum := 0.
    do := true.
    reg matchesActual: input do: [ :m |
        val := m subexpression: 1.
        (val at: 1) = $d ifTrue: [ do := (val size < 5) ]
        ifFalse: [ 
            do ifTrue: [ 
                sum := (m subexpression: 2) asInteger * (m subexpression: 3) asInteger + sum.
        ].  ].
    ].
    
    ^ sum.

Elixir

defmodule AdventOfCode.Solution.Year2024.Day03 do
  def part1(input) do
    Regex.scan(~r/mul\((?<l>\d+),(?<r>\d+)\)/, input, capture: ["l", "r"])
    |> Stream.map(fn l -> Enum.reduce(l, 1, &(&2 * String.to_integer(&1))) end)
    |> Enum.sum()
  end

  def part2(input) do
    input |> String.replace(~r/don't\(\).*(do\(\)|$)/Us, "") |> part1
  end
end

Lisp

Just did some basic regex stuff.

(defun p1-mult (str)
  "pulls out numbers and multiplies them, assumes already filtered by size"
  (let ((vals (ppcre:all-matches-as-strings "\\d+" str)))
    (apply #'* (or (mapcar #'parse-integer vals) '(0)))))

(defun p1-process-line (line)
  "look for mul, do the mul, and sum"
  (let ((ptrn "mul\\(\\d?\\d?\\d,\\d?\\d?\\d\\)"))
    (apply #'+ (mapcar #'p1-mult (ppcre:all-matches-as-strings ptrn line)))))

(defun run-p1 (file) 
  (let ((data (read-file file #'p1-process-line)))
    (apply #'+ data)))

(defun p2-process-line (line)
  "looks for mul, do, and don't"
  (let ((ptrn "(mul\\(\\d?\\d?\\d,\\d?\\d?\\d\\))|(do\\(\\))|(don't\\(\\))"))
    (ppcre:all-matches-as-strings ptrn line)))

(defun p2-filter (data)
  "expects list containing the string tokens (mul, do, don't) from the file"
  (let ((process t))
    (loop for x in data
          when (string= "don't()" x)
            do (setf process nil)
          when (string= "do()" x)
            do (setf process t)
          when process
            sum (p1-mult x))))

(defun run-p2 (file) 
  (let ((data (read-file file #'p2-process-line)))
    ;; treat the input as one line to make processing the do's and don't's easier
    (p2-filter (flatten data))))