Day 1: Trebuchet?!

use aoc_runner_derive::aoc;
use regex::Regex;

#[aoc(day1, part1)]
fn part1(input: &str) -> usize {
    input
        .lines()
        .map(|line| {
            let mut digits = line.chars().filter(char::is_ascii_digit);

            let first = digits.next().unwrap();
            let last = match digits.last() {
                Some(last) => last,
                None => first,
            };
            let n: usize = format!("{first}{last}").parse().unwrap();
            n
        })
        .sum()
}

#[aoc(day1, part2)]
fn part2(input: &str) -> usize {
    let digit_re = Regex::new("([1-9]|one|two|three|four|five|six|seven|eight|nine)").unwrap();
    input
        .lines()
        .map(|line| {
            let mut digits = Vec::new();
            let mut i = 0;
            while i < line.len() {
                if let Some(m) = digit_re.find_at(line, i) {
                    digits.push(match m.as_str() {
                        "one" => "1",
                        "two" => "2",
                        "three" => "3",
                        "four" => "4",
                        "five" => "5",
                        "six" => "6",
                        "seven" => "7",
                        "eight" => "8",
                        "nine" => "9",
                        c => c,
                    });
                    i = m.start() + 1;
                } else {
                    break;
                }
            }

            let first = digits.first().unwrap();
            let last = match digits.last() {
                Some(last) => last,
                None => first,
            };
            let n: usize = format!("{first}{last}").parse().unwrap();
            n
        })
        .sum()
}

use aoc_runner_derive::aoc;
use nom::{
    bytes::complete::{take_till, take_while1},
    error::Error,
    multi::many1,
    sequence::preceded,
};

#[aoc(day1, part1, nom)]
fn part1_nom(input: &str) -> usize {
    input
        .lines()
        .map(|line| {
            let (_, digits) = many1::<_, _, Error<_>, _>(preceded(
                take_till(|c: char| c.is_ascii_digit()),
                take_while1(|c: char| c.is_ascii_digit()),
            ))(line)
            .unwrap();

            let first = digits.first().unwrap();
            let last = digits.last().unwrap();
            let n: usize = format!("{first}{last}").parse().unwrap();
            n
        })
        .sum()
}

=ARRAYFORMULA(
  LET(
   x,IFERROR(REGEXREPLACE(TO_TEXT(A2:A),"\D","")),
   SUM((--(LEFT(x)&RIGHT(x))))))

=ARRAYFORMULA(
  LET(
   _w,{"one";"two";"three";"four";"five";"six";"seven";"eight";"nine"},
   _r,IF(ISBLANK(A2:A),,
       REGEXREPLACE(
        REDUCE(
         A2:A,ROW(1:9),
         LAMBDA(
          a,x,
          SUBSTITUTE(
           a,
           INDEX(_w,x),
           INDEX(_w&ROW(1:9)&_w,x)))),
        "\D",)),
   SUM(--(LEFT(_r)&RIGHT(_r)))))

Unlike many of the solutions I've seen people post, I did not use regexes. I have a function that looks for a match at the beginning of the string and returns the remaining string if it finds one. I hit the problem that most people hit (overlapping number names), but it was a simple as tweaking the algorithm to only consume the first letter of the name when it matches on it, leaving the others to match for the second letter.

#!/usr/bin/env pypy3

total = 0
for line in open(0):
    digits = [*filter(str.isdigit, line.strip())]
    calibration = int(digits[0] + digits[-1])
    total += calibration

print(total)

#!/usr/bin/env pypy3

import re

spellings = ('one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine')
pattern = r'(?=(' + r'|'.join(spellings + tuple('123456789')) + r'))'

total = 0
for line in open(0):
    digits = re.findall(pattern, line.strip())
    calibration = int(''.join(map(str, (int(d) if d.isdigit() else spellings.index(d) + 1
                                        for d in (digits[0], digits[-1])))))
    total += calibration

print(total)

#!/usr/bin/env python3

import pathlib
import datetime

now = datetime.datetime.now()
path = pathlib.Path(f'~/src/advent-of-code-{now.year}/day{now.day:02}').expanduser()
part1 = open(path / '1.py').read()
part2 = open(path / '2.py').read()

input_blue = lambda s: input(f'\033[34m{s}\033[0m')
part1_remarks = input_blue('Any remarks before part one?: ')
part2_remarks = input_blue('Any remarks before part two?: ')
final_remarks = input_blue('Any final remarks?: ')

print(f'''\
{part1_remarks}
<details>
<summary>Part 1</summary>

```python
{part1}
```
</details>
{part2_remarks}
<details>
<summary>Part 2</summary>

```python
{part2}
```
</details>
{final_remarks}''')

package com.michaeleisemann.aoc23.services;

import com.michaeleisemann.aoc23.interfaces.DayInterface;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.stereotype.Service;

// https://adventofcode.com/2023/day/1

@Service
public class Day1Service implements DayInterface {

    private final String[] wordToNumbers = {
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"
    };

    // Fundamentally, we have to just get the first and last digit of the String.
    // The first and last number can be the same. e.g. asdf1asdf produces the first and last number as 1.
    public String day1Part1(String puzzleInput) {
        logger.info("Day 1 Part 1");
        logger.debug("Puzzle Input:\n{}", puzzleInput);
        int sum = 0;
        for (String line : puzzleInput.split("\n")) {
            // remove all non-digits
            String digits = line.replaceAll("\\D+", "");
            int calibrationValue = getFirstAndLastDigits(digits);
            logger.debug("Calibration Value: {}", calibrationValue);
            sum += calibrationValue;
        }
        return String.valueOf(sum);
    }

    public String day1Part2(String puzzleInput) {
        logger.info("Day 1 Part 2");
        logger.debug("Puzzle Input:\n{}", puzzleInput);
        int sum = 0;
        for (String line : puzzleInput.split("\n")) {
            // search through the line for either a digit or the word for a digit
            StringBuilder realDigits = new StringBuilder();
            StringBuilder tempString = new StringBuilder();
            for (String letter : line.split("")) {
                if (letter.matches("\\d")) {
                    realDigits.append(letter);
                    tempString = new StringBuilder();
                    continue;
                }
                tempString.append(letter);
                for (String wordNumber : wordToNumbers) {
                    if (tempString.toString().contains(wordNumber)) {
                        realDigits.append(ArrayUtils.indexOf(wordToNumbers, wordNumber));
                        tempString = new StringBuilder();
                        tempString.append(letter);
                        break;
                    }
                }
            }
            String digits = realDigits.toString();
            int calibrationValue = getFirstAndLastDigits(digits);
            logger.debug("Calibration Value: {}", calibrationValue);
            sum += calibrationValue;
        }
        return String.valueOf(sum);
    }

    private int getFirstAndLastDigits(String digits) {
        String firstDigit = String.valueOf(digits.charAt(0));
        String lastDigit = String.valueOf(digits.charAt(digits.length() - 1));
        return Integer.parseInt(firstDigit + lastDigit);
    }
}

This was pretty straightforward: just used a list comprehension to extract the digits.

def read_values(stream=sys.stdin) -> list[list[str]]:
    return [
        list(filter(str.isdigit, line))
        for line in stream
    ]

def main(stream=sys.stdin) -> None:
    values = read_values(stream)
    total  = sum(
        int(digits[0] + digits[-1]) for digits in values
    )
    print(total)

This was trickier than expected as you had to account for overlapping words such as eightwo. Fortunately, I only had to change my read_values function.

def read_values(stream=sys.stdin) -> list[list[str]]:
    values = []
    for line in stream:
        letters = line.strip()
        digits  = []

        for index, letter in enumerate(letters):
            if letter.isdigit():
                digits.append(letter)

            for value, digit in enumerate(DIGITS, 1):
                if letters[index:].startswith(digit):
                    digits.append(str(value))
                    break

        values.append(digits)
    return values

While showering, I thought of a way to make Part 2 more functional by using map to convert the words to digits before filtering as I did in Part 1:

def word_to_digit(s: str, index: int) -> str:
    for value, digit in enumerate(DIGITS, 1): 
        if s[index:].startswith(digit):
            return str(value)
    return s[index]

def read_values(stream=sys.stdin) -> list[list[str]]:
    return [
        list(filter(str.isdigit, map(lambda p: word_to_digit(line, p[0]), enumerate(line))))
        for line in stream
    ] 

#!/usr/bin/awk -f
{
	gsub(/[^0-9]/, "")
	total += substr($0, 1, 1) substr($0, length($0 - 1))
}

END { print total }

After spotting the overlapping problem, I initially just decided to parse it from left to right for some reason. The worst part is that it worked perfectly for the sample but not for my input... made things a lot harder for myself.

#!/usr/bin/awk -f
{
	trans["one"] = 1
	trans["two"] = 2
	trans["three"] = 3
	trans["four"] = 4
	trans["five"] = 5
	trans["six"] = 6
	trans["seven"] = 7
	trans["eight"] = 8
	trans["nine"] = 9

	do
		for (k in trans)
			if ($0 ~ "^[0-9]*" k)
				sub(k, trans[k] k)
	while (sub(/[^0-9]/, ""))

	total += substr($0, 1, 1) substr($0, length($0 - 1))
}

END { print total }

#define MAX_STR_LENGTH 128

// a lookup table of number spellings and numerals, grouped by spelling length
char* const DIGIT_NAMES[3][9][2] = {
{
{ "one", "1" },
{ "two", "2" },
{ "six", "6" },
}, {
{ "four", "4" },
{ "five", "5" },
{ "nine", "9" },
}, {
{ "three", "3" },
{. "seven", "7" },
{ "eight", "8" }
}
};

// replace a substring at a given index with another
void insertNumeral(char* srcString, int startIndex, int endIndex, char num) {

char builtString[MAX_STR_LENGTH];

// load up the leadin...
strncpy(
        builtString,
        srcString,
        startIndex
);

// ...sneak in our little numeral package...
builtString[startIndex] = num;

// ...and then top off with the rest!
strncpy(
        &builtString[startIndex + 1],
        srcString + endIndex,
        MAX_STR_LENGTH - endIndex
);

// donezo; now just copy back to the source :)
strcpy(srcString, builtString);

}

// pass through a given string, replacing spelled numbers with numerals
void sanitiseDigits(char* srcString) {

for     (int start     = 0; start < (MAX_STR_LENGTH-5);    start++    )
    for (int numLen    = 0; numLen < 3;                    numLen++) {

        if (!isalnum(srcString[start+numLen+2]))
            break;

        // get current substring to query
        char* srcSubstr = (char*) malloc( (numLen+3) * sizeof(char) );
        memcpy(
            srcSubstr, 
            srcString + start    * sizeof(char),
            (numLen + 3)    * sizeof(char)
        );

        // check for numeral hits
        for (int i = 0; i < 3; i++)
            if (!strcmp(srcSubstr, DIGIT_NAMES[numLen][i][0]))
                insertNumeral(
                    srcString, 
                    start,
                    (start + numLen + 3),
                    DIGIT_NAMES[numLen][i][1][0]
                );

        free(srcSubstr);

    }

}

int main(int argc, char* argv[]) {

// first, let's open up our input file...
char const* const fn = argv[1];
FILE* f = fopen(fn, "r");
char curLine[MAX_STR_LENGTH];

// ..and finally we can iterate through its lines!
int        noOfDigits;
char    curTerminals[2];
int        runningTotal = 0;
while ( fgets(curLine, sizeof(curLine), f) ) {

    // firstly let's sanitise our spelled digits as a first pass
    printf("raw str is %s...", curLine);
    sanitiseDigits(curLine);
    printf(" and sanitised str is %s!\n", curLine);



    // now all there is to do is to extract the digits...
    int* curDigits = (int*) malloc(MAX_STR_LENGTH * sizeof(int));
    noOfDigits = 0;
    
    for (int i = 0; i < (int)sizeof(curLine); i++) {
        
        if (!isalnum(curLine[i]))
            break;
        
        if (curLine[i]>='0' && curLine[i]<='9') {
            // (treat as single-character int by subtracting 0 literal)
            curDigits[noOfDigits] = (curLine[i] - '0');
            noOfDigits++;
        }
    
    }

    // ...and build the calibrators!
    curTerminals[0] = '0' + curDigits[0];
    curTerminals[1] = '0' + curDigits[noOfDigits-1];
    runningTotal += atoi(curTerminals);

    free(curDigits);
}



fclose(f);

// lovely stuff. :)
printf("FINAL TOTAL IS %d. End.", runningTotal);

return 0;

}

</details>

use std::env;
use std::io::{self, prelude::*, BufReader};
use std::fs::File;

extern crate regex;
use regex::Regex;

fn calibration_value(input: &str) -> usize {
    let re = Regex::new(r"(\d)").unwrap();
    let matches: Vec<_> = re
        .find_iter(input)
        .map(|x| x.as_str().parse::<usize>().ok())
        .collect();
    10 * matches[0].unwrap() + matches[matches.len()-1].unwrap()
}

fn calibration_value_2(input: &str) -> usize {
    let re = Regex::new(r"(\d|one|two|three|four|five|six|seven|eight|nine)").unwrap();
    let matches: Vec<_> = re
        .find_iter(input)
        .map(|x| x.as_str())
        .collect();
    10 * actual_value(matches[0]) + actual_value(matches[matches.len()-1])
}

fn actual_value(input: &str) -> usize {
    match input {
        "1" | "one"   => 1,
        "2" | "two"   => 2,
        "3" | "three" => 3,
        "4" | "four"  => 4,
        "5" | "five"  => 5,
        "6" | "six"   => 6,
        "7" | "seven" => 7,
        "8" | "eight" => 8,
        "9" | "nine"  => 9,
        _ => panic!("Unexpected input to actual_value: {input}"),
    }
}

fn solve(input: &str) -> io::Result<()> {
    let file = File::open(input).expect("Input file not found.");
    let reader = BufReader::new(file);

    // Input
    let input: Vec<String> = match reader.lines().collect() {
        Err(err) => panic!("Unknown error reading input: {}", err),
        Ok(result) => result,
    };

    // Part 1
    let part1 = input
        .iter()
        .map(|x| calibration_value(x))
        .sum::<usize>();
    println!("Part 1: {part1}"); // 54561

    // Part 2
    let part2 = input
        .iter()
        .map(|x| calibration_value_2(x))
        .sum::<usize>();
    println!("Part 2: {part2}"); // 54076

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    solve(&filename).unwrap();
}

import java.util.regex.Pattern

fun main() {
    /*
    For each line, filter the digits, concatenate the first and last digits, and then add it to the result.
     */
    fun part1(input: List<String>): Int {
        var result = 0
        for (line in input) {
            val digits = line.filter { it.isDigit() }.map { it.digitToInt() }
            result += digits[0] * 10 + digits[digits.size - 1]
        }
        return result
    }

    check(part1(readExample(1, 1)) == 142)
    val output1 = part1(readInput(1))
    println(output1)
    check(output1 == 53334)

    /*
    For each line, generate digits using a map, concatenate the first and last digits, and then add it to the result.
     */
    fun part2(input: List<String>): Int {
        var result = 0
        val map = mapOf(
            "one" to 1,
            "two" to 2,
            "three" to 3,
            "four" to 4,
            "five" to 5,
            "six" to 6,
            "seven" to 7,
            "eight" to 8,
            "nine" to 9
        ).plus((0 until 10).map { it.toString() to it })
        val pattern = Pattern.compile(map.keys.joinToString("|"))
        for (line in input) {
            val digits = arrayListOf<Int>()
            val matcher = pattern.matcher(line)
            while (matcher.find()) {
                digits.addLast(map[matcher.group()])
            }
            result += digits[0] * 10 + digits[digits.size - 1]
        }
        return result
    }

    check(part2(readExample(1, 2)) == 281)
    val output2 = part2(readInput(1))
    println(output2)
    check(output2 == 52834)
}

import { assertEquals } from "https://deno.land/std@0.208.0/assert/mod.ts";
import { runPart } from "https://deno.land/x/aocd@v1.5.1/mod.ts";

function parse(input: string) {
  return input.trimEnd().split("\n");
}

function part1(input: string): number {
  const items = parse(input);
  return items.map((line) => {
    const onlyNumbers = line.replace(/[^0-9]+/g, "");
    const firstDigit = onlyNumbers[0];
    const lastDigit = onlyNumbers[onlyNumbers.length - 1];
    return Number(firstDigit + lastDigit);
  }).reduce((a, b) => a + b, 0);
}

const digits = [
  "zero",
  "one",
  "two",
  "three",
  "four",
  "five",
  "six",
  "seven",
  "eight",
  "nine",
];

function part2(input: string): number {
  const items = parse(input);
  return items.map((line) => {
    const digitsInLine: number[] = [];
    for (let i = 0; i < line.length; i++) {
      if (line[i] >= "0" && line[i] <= "9") {
        digitsInLine.push(Number(line[i]));
      } else {
        for (
          let digitIndex = 0;
          digitIndex < digits.length;
          digitIndex++
        ) {
          if (line.startsWith(digits[digitIndex], i)) {
            digitsInLine.push(digitIndex);
            break;
          }
        }
      }
    }
    const firstDigit = digitsInLine[0];
    const lastDigit = digitsInLine[digitsInLine.length - 1];
    return firstDigit * 10 + lastDigit;
  }).reduce((a, b) => a + b, 0);
}

if (import.meta.main) {
  runPart(2023, 1, 1, part1);
  runPart(2023, 1, 2, part2);
}

const TEST_INPUT = `\
1abc2
pqr3stu8vwx
a1b2c3d4e5f
treb7uchet
`;

Deno.test("part1", () => {
  assertEquals(part1(TEST_INPUT), 142);
});

const TEST_INPUT2 = `\
two1nine
eightwothree
abcone2threexyz
xtwone3four
4nineeightseven2
zoneight234
7pqrstsixteen
`;

Deno.test("part2", () => {
  assertEquals(part2(TEST_INPUT2), 281);
});

For now, it's just a function that reads in the input-file line by line, hands back a list of lines.

(use-modules (ice-9 rdelim))

(define (slurp filename)
  (call-with-input-file filename
                        (lambda (p)
                          (let loop ([line (read-line p)]
                                     [result '()])
                            (if (eof-object? line)
                              result
                              (loop (read-line p) (cons line result)))))))

Nothing particularly fancy, just regex-ing it.

(use-modules (ice-9 regex)
             (ice-9 format))
(load "utils.scm")

(define beginning-digit-re "^[^1-9]*([1-9])")
(define end-digit-re "([1-9])[^1-9]*$")

(define (process-line line)
  (let ([begin-match (string-match beginning-digit-re line)]
        [end-match   (string-match end-digit-re line)])
    (string-join (list (match:substring begin-match 1)
                       (match:substring end-match 1))
                 "")))

(define (proc-task-01a filename)
  (define puzzle-input (slurp filename))
  (apply + (map string->number (map process-line puzzle-input))))

(if (= (proc-task-01a "tiny_input_01a") 142)
  (format #t "Task 01, part 1: ~a\n" (proc-task-01a "input_01"))
  (error "tiny-task-01a didn't pass sanity checks"))

(define (front-splicer str matcher)
  (let [(m (string-match matcher str))]
    (if (regexp-match? m)
      m
      (front-splicer (string-drop str 1) matcher))))
(define (back-splicer str matcher)
  (let [(m (string-match matcher str))]
    (if (regexp-match? m)
      m
      (back-splicer (string-drop-right str 1) matcher))))

(define (digit-getter m)
  (cond
    [(or (string=? "1" m) (string=? "one" m))   "1"]
    [(or (string=? "2" m) (string=? "two" m))   "2"]
    [(or (string=? "3" m) (string=? "three" m)) "3"]
    [(or (string=? "4" m) (string=? "four" m))  "4"]
    [(or (string=? "5" m) (string=? "five" m))  "5"]
    [(or (string=? "6" m) (string=? "six" m))   "6"]
    [(or (string=? "7" m) (string=? "seven" m)) "7"]
    [(or (string=? "8" m) (string=? "eight" m)) "8"]
    [(or (string=? "9" m) (string=? "nine" m))  "9"]
    [else
      (error (format #f "we matched something else? ~a" m))]) )

(define (grab-first line)
  (define matcher "^(1|2|3|4|5|6|7|8|9|one|two|three|four|five|six|seven|eight|nine)")
  (let [(m (match:substring (front-splicer line matcher) 1))]
    (digit-getter m)))

(define (grab-last line)
  (define matcher "(1|2|3|4|5|6|7|8|9|one|two|three|four|five|six|seven|eight|nine)$")
  (let [(m (match:substring (back-splicer line matcher) 1))]
    (digit-getter m)))

(define (proc-line line)
  (let [(front (grab-first line))
        (back  (grab-last  line))]
    (string->number (format #f "~a~a" front back))))

(define (proc-task-01b filename)
  (define puzzle-input (slurp filename))
  (apply + (map proc-line puzzle-input)))

(if (= (proc-task-01b "tiny_input_01b") 281)
  (format #t "Task 01, part 2: ~a\n" (proc-task-01b "input_01"))
  (error "tiny-task-01b didn't pass sanity checks"))

I got tripped up by the fact that spelled-out digits can overlap in part 2. At first, I had my code jump ahead by length(digit_string) every time I found one, so I was missing any spelled-out digits that started within that first one. Annoyingly, this issue only came up in the real puzzle input and not the examples.

defmodule AdventOfCode.Solution.Year2023.Day01 do
  def part1(input), do: solve(input, &digits_part1/1)
  def part2(input), do: solve(input, &digits_part2/1)

  defp solve(input, get_digits_fn) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(&(&1 |> get_digits_fn.() |> Integer.undigits()))
    |> Enum.sum()
  end

  defguardp is_digit(char) when char in ?0..?9

  defp digits_part1(line, acc \\ [])
  defp digits_part1("", acc), do: [List.first(acc), List.last(acc)]

  defp digits_part1(<<char, rest::binary>>, acc) when is_digit(char) do
    digits_part1(rest, put_digit(acc, char - ?0))
  end

  defp digits_part1(<<_, rest::binary>>, acc) do
    digits_part1(rest, acc)
  end

  ###

  defp digits_part2(line, acc \\ [])
  defp digits_part2("", acc), do: [List.first(acc), List.last(acc)]

  defp digits_part2(<<char, rest::binary>>, acc) when is_digit(char) do
    digits_part2(rest, put_digit(acc, char - ?0))
  end

  defp digits_part2(<<_, rest::binary>> = line, acc) do
    acc =
      case find_leading_word_digit(line) do
        {:ok, digit} -> put_digit(acc, digit)
        :error -> acc
      end

    digits_part2(rest, acc)
  end

  defp put_digit([], first_digit), do: [first_digit]
  defp put_digit([first_digit | _], digit), do: [first_digit, digit]

  for {str, n} <- Enum.zip(~w[one two three four five six seven eight nine], 1..9) do
    defp find_leading_word_digit(unquote(str) <> _), do: {:ok, unquote(n)}
  end

  defp find_leading_word_digit(_), do: :error
end

P.S. This is the cleaned up version of my solution—my initial code was a big ol' mess

I realized you don't need to search through the entirety of each line—you can look for the first digit from the left end and the first digit from the right end, and potentially skip a large amount of text in the middle of the line.

Seems like the Erlang VM is optimized for parsing through binary data from left to right though, so even though this does "less work" by stopping as soon as it finds a digit on either end, instead of always iterating through the whole line, the code that works backward from the end of the string tends to run slowly enough to almost cancel out the benefit. In fact, part 1 now runs a few hundred μs slower!

However I still like this approach better because it's a bit easier to understand what the code is doing.

defmodule AdventOfCode.Solution.Year2023.Day01 do
  def part1(input), do: solve(input, &find_digit_part1/1)
  def part2(input), do: solve(input, &find_digit_part2/1)

  defp solve(input, finder_fn) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(fn line ->
      [find_first_digit(line, finder_fn), find_last_digit(line, finder_fn)]
      |> Integer.undigits()
    end)
    |> Enum.sum()
  end

  defguardp is_digit(char) when char in ?0..?9

  defp find_first_digit(<<_, rest::binary>> = str, finder_fn) do
    case finder_fn.(str) do
      {:ok, d} -> d
      :error -> find_first_digit(rest, finder_fn)
    end
  end

  defp find_last_digit(line, finder_fn), do: find_last_digit(line, finder_fn, byte_size(line) - 1)

  defp find_last_digit(line, finder_fn, drop_from_front) do
    <<_::binary-size(drop_from_front), str::binary>> = line

    case finder_fn.(str) do
      {:ok, d} -> d
      :error -> find_last_digit(line, finder_fn, drop_from_front - 1)
    end
  end

  defp find_digit_part1(<<char, _::binary>>) when is_digit(char), do: {:ok, char - ?0}
  defp find_digit_part1(_), do: :error

  defp find_digit_part2(<<char, _::binary>>) when is_digit(char), do: {:ok, char - ?0}

  for {str, n} <- Enum.zip(~w[one two three four five six seven eight nine], 1..9) do
    defp find_digit_part2(<<unquote(str), _::binary>>), do: {:ok, unquote(n)}
  end

  defp find_digit_part2(_), do: :error
end

Then I realised I didn't need to do all that parsing, and it was only the first and last numbers that were interesting, which meant I could skip all the overlapping stuff, and made the parsing a lot easier, although I did end up needing to do it twice to handle the forwards case and the backwards case.

If I were going to improve this, I'd probably look at the regex crate, or better yet some of its internals. The full power of regex is probably overkill in this situation, but Burntsushi knows his way around string matching, so maybe there's something there that'll handle the parsing better. But I think I'm happy for now.

use std::io;
use std::io::Read;

// The newly-improved calibration document consists of lines of text
// each line originally contained a specific calibration value that the Elves now need to recover
// On each line, the calibration value can be found by combining the first digit and the last digit (in that order) to form a single two-digit number.
fn solve(text: &str) -> u32 {
    text.lines().map(|v| {
        let first_digit = v.chars().find(|c| c.is_numeric()).map(|c| c.to_digit(10)).flatten().unwrap();
        let last_digit = v.chars().rfind(|c| c.is_numeric()).map(|c| c.to_digit(10)).flatten().unwrap();

        (first_digit * 10) + last_digit
    }).fold(0u32, |a, b| a + b)
}

struct Replacement {
    len: usize,
    text: &'static [u8; 5],
    replacement: &'static [u8; 1],
}

const NUMBERS: [Replacement; 9] = [
    Replacement { len: 3, text: b"one  ", replacement: b"1" },
    Replacement { len: 3, text: b"two  ", replacement: b"2" },
    Replacement { len: 5, text: b"three", replacement: b"3" },
    Replacement { len: 4, text: b"four ", replacement: b"4" },
    Replacement { len: 4, text: b"five ", replacement: b"5" },
    Replacement { len: 3, text: b"six  ", replacement: b"6" },
    Replacement { len: 5, text: b"seven", replacement: b"7" },
    Replacement { len: 5, text: b"eight", replacement: b"8" },
    Replacement { len: 4, text: b"nine ", replacement: b"9" },
];

fn solve2(text: &str) -> u32 {
    text.lines().map(|v| {
        let mut new_v = Vec::<u8>::new();
        let raw = v.as_bytes();
        let mut i = 0;
        let mut last_covered = 0;
        'outer: while i < raw.len() {
            for pattern in &NUMBERS {
                if i + pattern.len > raw.len() {
                    continue;
                }
                if raw[i..i + pattern.len] == pattern.text[0..pattern.len] {
                    last_covered = i + pattern.len;
                    new_v.extend_from_slice(pattern.replacement);
                    i += 1;
                    continue 'outer;
                }
            }
            if last_covered <= i {
                new_v.push(raw[i]);
            }
            i += 1;
        }
        let new_v = unsafe { String::from_utf8_unchecked(new_v) };
        let first_digit = new_v.chars().find(|c| c.is_numeric()).map(|c| c.to_digit(10)).flatten().unwrap();
        let last_digit = new_v.chars().rfind(|c| c.is_numeric()).map(|c| c.to_digit(10)).flatten().unwrap();

        (first_digit * 10) + last_digit
    }).fold(0u32, |a, b| a + b)
}

fn main() {
    let mut stdin = io::stdin();
    let mut input = String::new();
    stdin.read_to_string(&mut input).unwrap();
    println!("{}", solve2(&input));
}

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

    #[test]
    fn test_example() {
        let input = "1abc2
pqr3stu8vwx
a1b2c3d4e5f
treb7uchet";
        assert_eq!(solve(input), 142);
    }

    #[test]
    fn test_example2() {
        let input = "two1nine
eightwothree
abcone2threexyz
xtwone3four
4nineeightseven2
zoneight234
7pqrstsixteen";
        assert_eq!(solve2(input), 281);
    }

    #[test]
    fn test_example2_reddit() {
        let input = "eighthree
sevenine";
        assert_eq!(solve2(input), 83 + 79);
    }
}

#!/usr/bin/env ruby

require 'benchmark'
require 'minitest'
require 'pry-byebug'

TEST_STR = "\
1abc2
pqr3stu8vwx
a1b2c3d4e5f
treb7uchet
"

TEST_STR_2 = "\
two1nine
eightwothree
abcone2threexyz
xtwone3four
4nineeightseven2
zoneight234
7pqrstsixteen
"

class Test < MiniTest::Test
  def test_p1
    assert_equal(142, compute_p1(TEST_STR))
  end

  def test_p2
    assert_equal(281, compute_p2(TEST_STR_2))
  end

  def test_p2_overlap
    assert_equal(51, compute_p2("jjhxddmg5mqxqbgfivextlcpnvtwothreetwonerzk"))
  end
end

def compute_p1(input)
  input.lines.map { |line|
    numbers = line
                .chars
                .filter { |c| c.match(/[[:digit:]]/) }
    [numbers.first, numbers.last]
      .join
      .to_i
  }.sum
end

def compute_p2(input)
  input.lines.map { |line|
    numbers = line
      .scan(/(?=(\d|one|two|three|four|five|six|seven|eight|nine))/)
      .flatten
      .map { |num|
        case num
        when "one"
          1
        when "two"
          2
        when "three"
          3
        when "four"
          4
        when "five"
          5
        when "six"
          6
        when "seven"
          7
        when "eight"
          8
        when "nine"
          9
        else
          num
        end
    }

    [numbers.first, numbers.last]
      .join
      .to_i
  }.sum
end

if MiniTest.run
  puts 'Test case OK, running...'

  @input = File.read(ARGV[0] || 'input')
  do_p2 = defined?(compute_p2)

  Benchmark.bm do |bm|
    bm.report('Part 1:') { @p1 = compute_p1(@input) }
    bm.report('Part 2:') { @p2 = compute_p2(@input) } if do_p2
  end

  puts "\nResults:"
  puts 'Part 1: %i' % @p1
  puts 'Part 2: %i' % @p2 if do_p2

else
  puts 'Test case ERR'
end

# Advent of Code 2023
# Day 1: Trebuchet?!

spelled_digits = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
    "five": 5,
    "six": 6,
    "seven": 7,
    "eight": 8,
    "nine": 9,
    "ten": 10
}

result_part_1 = 0
result_part_2 = 0

with open("inputs/day_1.txt") as file:
    for line in file:
        digits_part_1 = []
        digits_part_2 = []

        for pos in range(len(line)):
            if line[pos].isdigit():
                digit = int(line[pos])
                digits_part_1.append(digit)
                digits_part_2.append(digit)

            for spelled in spelled_digits:
                if line[pos:].startswith(spelled):
                    digits_part_2.append(spelled_digits[spelled])

        result_part_1 += digits_part_1[0] * 10 + digits_part_1[-1]
        result_part_2 += digits_part_2[0] * 10 + digits_part_2[-1]

print(f"Part 1: {result_part_1}")
print(f"Part 2: {result_part_2}")

defmodule Solution do
  def run(filename) do
    File.stream!(filename, [:read])
    |> Enum.reduce(0, fn line, sum -> 
      sum + get_number_from_line(line)
    end)
    |> IO.puts()
  end

  defp get_number_from_line(line) do
    case Regex.run(~r/^.*?(\d|one|two|three|four|five|six|seven|eight|nine).*(\d|one|two|three|four|five|six|seven|eight|nine).*?$/, line) do
      [_, first_digit, last_digit] -> create_number(first_digit, last_digit)
      nil -> case Regex.run(~r/^.*(\d|one|two|three|four|five|six|seven|eight|nine).*$/, line) do
        [_, digit] -> create_number(digit, digit)
      end
    end
  end

  defp create_number(first_digit, second_digit) do
    to_integer(first_digit) * 10 + to_integer(second_digit)
  end

  defp to_integer(number) do
    case number do
      "one" -> 1
      "two" -> 2
      "three" -> 3
      "four" -> 4
      "five" -> 5
      "six" -> 6
      "seven" -> 7
      "eight" -> 8
      "nine" -> 9
      number -> String.to_integer(number)
    end
  end
end

Solution.run("./input")

open System.IO
open System

let inputData =  File.ReadLines @".\input.txt"

let getNumberFromString (input:string) = 
    input
    |> Seq.filter Char.IsNumber
    |> fun numbers  -> 
        let first = Seq.head numbers
        let last =  Seq.last numbers 
        (first.ToString() + last.ToString()) |> int


let result =
    inputData
    |> Seq.map getNumberFromString
    |> Seq.sum

result

open System.IO
open System

let inputData =  File.ReadLines @".\input.txt"

let numberWords =
    [   "one", 1
        "two", 2
        "three", 3
        "four", 4
        "five", 5
        "six", 6
        "seven", 7
        "eight", 8
        "nine", 9 ]

type NumberIndex = 
    {   Index: int
        Value: string }

let getNumberFromWord (input:string) = 
    numberWords
    |> List.collect(fun (number, value) -> 
        let first = input.IndexOf number 
        let last = input.LastIndexOf number
        [   { Index = first; Value = value.ToString() }
            { Index = last; Value = value.ToString()} ] ) 
    |> List.filter(fun indexes -> indexes.Index >= 0)
    |> List.sortBy(fun index -> index.Value)
    
let getNumberFromCharacter (input:string) = 
    input
    |> Seq.mapi(fun i c ->
        match Char.IsNumber c with 
        | true -> Some { Index = i; Value = c.ToString() } 
        | false -> None
    )
    |> Seq.choose id
    |> Seq.toList

let result =
    inputData
    |> Seq.map( fun line ->
        getNumberFromWord line @ getNumberFromCharacter line
        |> List.sortBy _.Index
        |> fun indexes -> (List.head indexes).Value + (List.last indexes).Value |> int
    )
    |> Seq.toList
    |> Seq.sum

// Ye ole fashion debugging.
// result 
// |> Seq.map _.ToString()
// |> fun data -> File.WriteAllLines(@".\test.txt", data)

#!/bin/bash

INPUT=$(sed ./input.txt -e 's/[a-z]//g' | awk '{print substr($0,0,1) substr($0,length($0),1)}')
declare -a NUMS=()
NUM=0
#echo -e "$INPUT"

for LINE in $INPUT; do
#echo $LINE
let NUM+=$LINE
done

echo "$NUM"

</details>