Rust

Part 1 Part 2

Fun with iterators! For the second part I went to regex for help.

Python 3

I had some trouble getting Part 2 to work, until I realized that there could be overlap ( blbleightwoqsqs -> 82).

import re

def puzzle_one():
    result_sum = 0
    with open("inputs/day_01", "r", encoding="utf_8") as input_file:
        for line in input_file:
            number_list = [char for char in line if char.isnumeric()]
            number = int(number_list[0] + number_list[-1])
            result_sum += number
    return result_sum

def puzzle_two():
    regex = r"(?=(zero|one|two|three|four|five|six|seven|eight|nine|[0-9]))"
    number_dict = {
        "zero": "0",
        "one": "1",
        "two": "2",
        "three": "3",
        "four": "4",
        "five": "5",
        "six": "6",
        "seven": "7",
        "eight": "8",
        "nine": "9",
    }
    result_sum = 0
    with open("inputs/day_01", "r", encoding="utf_8") as input_file:
        for line in input_file:
            number_list = [
                number_dict[num] if num in number_dict else num
                for num in re.findall(regex, line)
            ]
            number = int(number_list[0] + number_list[-1])
            result_sum += number
    return result_sum

I still have a hard time understanding regex, but I think it’s getting there.

A new C solution: without lookahead or backtracking! I keep a running tally of how many letters of each digit word were matched so far: https://github.com/sjmulder/aoc/blob/master/2023/c/day01.c

int main(int argc, char **argv)
{
	static const char names[][8] = {"zero", "one", "two", "three",
	    "four", "five", "six", "seven", "eight", "nine"};
	int p1=0, p2=0, i,c;
	int p1_first = -1, p1_last = -1;
	int p2_first = -1, p2_last = -1;
	int nmatched[10] = {0};
	
	while ((c = getchar()) != EOF)
		if (c == '\n') {
			p1 += p1_first*10 + p1_last;
			p2 += p2_first*10 + p2_last;
			p1_first = p1_last = p2_first = p2_last = -1;
			memset(nmatched, 0, sizeof(nmatched));
		} else if (c >= '0' && c <= '9') {
			if (p1_first == -1) p1_first = c-'0';
			if (p2_first == -1) p2_first = c-'0';
			p1_last = p2_last = c-'0';
			memset(nmatched, 0, sizeof(nmatched));
		} else for (i=0; i<10; i++)
			/* advance or reset no. matched digit chars */
			if (c != names[i][nmatched[i]++])
				nmatched[i] = c == names[i][0];
			/* matched to end? */
			else if (!names[i][nmatched[i]]) {
				if (p2_first == -1) p2_first = i;
				p2_last = i;
				nmatched[i] = 0;
			}

	printf("%d %d\n", p1, p2);
	return 0;
}

Part 02 in Rust 🦀 :

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

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

    let number_map = HashMap::from([
        ("one", "1"),
        ("two", "2"),
        ("three", "3"),
        ("four", "4"),
        ("five", "5"),
        ("six", "6"),
        ("seven", "7"),
        ("eight", "8"),
        ("nine", "9"),
    ]);

    let mut total = 0;
    for _line in reader.lines() {
        let digits = get_text_numbers(_line.unwrap(), &number_map);
        if !digits.is_empty() {
            let digit_first = digits.first().unwrap();
            let digit_last = digits.last().unwrap();
            let mut cat = String::new();
            cat.push(*digit_first);
            cat.push(*digit_last);
            let cat: i32 = cat.parse().unwrap();
            total += cat;
        }
    }
    println!("{total}");
    Ok(())
}

fn get_text_numbers(text: String, number_map: &HashMap<&str, &str>) -> Vec {
    let mut digits: Vec = Vec::new();
    if text.is_empty() {
        return digits;
    }
    let mut sample = String::new();
    let chars: Vec = text.chars().collect();
    let mut ptr1: usize = 0;
    let mut ptr2: usize;
    while ptr1 < chars.len() {
        sample.clear();
        ptr2 = ptr1 + 1;
        if chars[ptr1].is_digit(10) {
            digits.push(chars[ptr1]);
            sample.clear();
            ptr1 += 1;
            continue;
        }
        sample.push(chars[ptr1]);
        while ptr2 < chars.len() {
            if chars[ptr2].is_digit(10) {
                sample.clear();
                break;
            }
            sample.push(chars[ptr2]);
            if number_map.contains_key(&sample.as_str()) {
                let str_digit: char = number_map.get(&sample.as_str()).unwrap().parse().unwrap();
                digits.push(str_digit);
                sample.clear();
                break;
            }
            ptr2 += 1;
        }
        ptr1 += 1;
    }

    digits
}

import re
numbers = {
    "one" : 1,
    "two" : 2,
    "three" : 3,
    "four" : 4,
    "five" : 5,
    "six" : 6,
    "seven" : 7,
    "eight" : 8,
    "nine" : 9
    }
for digit in range(10):
    numbers[str(digit)] = digit
pattern = "(%s)" % "|".join(numbers.keys())
   
re1 = re.compile(".*?" + pattern)
re2 = re.compile(".*" + pattern)
total = 0
for line in open("input.txt"):
    m1 = re1.match(line)
    m2 = re2.match(line)
    num = (numbers[m1.group(1)] * 10) + numbers[m2.group(1)]
    total += num
print(total)

There weren’t any zeros in the training data I got - the text seems to suggest that “0” is allowed but “zero” isn’t.

I finally got my solutions done. I used rust. I feel like 114 lines (not including empty lines or driver code) for both solutions is pretty decent. If lemmy’s code blocks are hard to read, I also put my solutions on github.

use std::{
    cell::OnceCell,
    collections::{HashMap, VecDeque},
    ops::ControlFlow::{Break, Continue},
};

use crate::utils::read_lines;

#[derive(Clone, Copy, PartialEq, Eq)]
enum NumType {
    Digit,
    DigitOrWord,
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum FromDirection {
    Left,
    Right,
}

const WORD_NUM_MAP: OnceCell> = OnceCell::new();

fn init_num_map() -> HashMap<&'static str, u8> {
    HashMap::from([
        ("one", b'1'),
        ("two", b'2'),
        ("three", b'3'),
        ("four", b'4'),
        ("five", b'5'),
        ("six", b'6'),
        ("seven", b'7'),
        ("eight", b'8'),
        ("nine", b'9'),
    ])
}

const MAX_WORD_LEN: usize = 5;

fn get_digit<i>(mut bytes: I, num_type: NumType, from_direction: FromDirection) -> Option
where
    I: Iterator,
{
    let digit = bytes.try_fold(VecDeque::new(), |mut byte_queue, byte| {
        if byte.is_ascii_digit() {
            Break(byte)
        } else if num_type == NumType::DigitOrWord {
            if from_direction == FromDirection::Left {
                byte_queue.push_back(byte);
            } else {
                byte_queue.push_front(byte);
            }

            let word = byte_queue
                .iter()
                .map(|&amp;byte| byte as char)
                .collect::();

            for &amp;key in WORD_NUM_MAP
                .get_or_init(init_num_map)
                .keys()
                .filter(|k| k.len() &lt;= byte_queue.len())
            {
                if word.contains(key) {
                    return Break(*WORD_NUM_MAP.get_or_init(init_num_map).get(key).unwrap());
                }
            }

            if byte_queue.len() == MAX_WORD_LEN {
                if from_direction == FromDirection::Left {
                    byte_queue.pop_front();
                } else {
                    byte_queue.pop_back();
                }
            }

            Continue(byte_queue)
        } else {
            Continue(byte_queue)
        }
    });

    if let Break(byte) = digit {
        Some(byte)
    } else {
        None
    }
}

fn process_digits(x: u8, y: u8) -> u16 {
    ((10 * (x - b'0')) + (y - b'0')).into()
}

fn solution(num_type: NumType) {
    if let Ok(lines) = read_lines("src/day_1/input.txt") {
        let sum = lines.fold(0_u16, |acc, line| {
            let line = line.unwrap_or_else(|_| String::new());
            let bytes = line.bytes();
            let left = get_digit(bytes.clone(), num_type, FromDirection::Left).unwrap_or(b'0');
            let right = get_digit(bytes.rev(), num_type, FromDirection::Right).unwrap_or(left);

            acc + process_digits(left, right)
        });

        println!("{sum}");
    }
}

pub fn solution_1() {
    solution(NumType::Digit);
}

pub fn solution_2() {
    solution(NumType::DigitOrWord);
}
```</i>

Trickier than expected! I ran into an issue with Lua patterns, so I had to revert to a more verbose solution, which I then used in Hare as well.

Lua:

-- SPDX-FileCopyrightText: 2023 Jummit
--
-- SPDX-License-Identifier: GPL-3.0-or-later

local sum = 0
for line in io.open("1.input"):lines() do
  local a, b = line:match("^.-(%d).*(%d).-$")
  if not a then
    a = line:match("%d+")
    b = a
  end
  if a and b then
    sum = sum + tonumber(a..b)
  end
end
print(sum)

local names = {
  ["one"] = 1,
  ["two"] = 2,
  ["three"] = 3,
  ["four"] = 4,
  ["five"] = 5,
  ["six"] = 6,
  ["seven"] = 7,
  ["eight"] = 8,
  ["nine"] = 9,
  ["1"] = 1,
  ["2"] = 2,
  ["3"] = 3,
  ["4"] = 4,
  ["5"] = 5,
  ["6"] = 6,
  ["7"] = 7,
  ["8"] = 8,
  ["9"] = 9,
}
sum = 0
for line in io.open("1.input"):lines() do
  local firstPos = math.huge
  local first
  for name, num in pairs(names) do
    local left = line:find(name)
    if left and left < firstPos then
      firstPos = left
      first = num
    end
  end
  local last
  for i = #line, 1, -1 do
    for name, num in pairs(names) do
      local right = line:find(name, i)
      if right then
        last = num
        goto found
      end
    end
  end
  ::found::
  sum = sum + tonumber(first * 10 + last)
end
print(sum)

Hare:

// SPDX-FileCopyrightText: 2023 Jummit
//
// SPDX-License-Identifier: GPL-3.0-or-later

use fmt;
use types;
use bufio;
use strings;
use io;
use os;

const numbers: [](str, int) = [
	("one", 1),
	("two", 2),
	("three", 3),
	("four", 4),
	("five", 5),
	("six", 6),
	("seven", 7),
	("eight", 8),
	("nine", 9),
	("1", 1),
	("2", 2),
	("3", 3),
	("4", 4),
	("5", 5),
	("6", 6),
	("7", 7),
	("8", 8),
	("9", 9),
];

fn solve(start: size) void = {
	const file = os::open("1.input")!;
	defer io::close(file)!;
	const scan = bufio::newscanner(file, types::SIZE_MAX);
	let sum = 0;
	for (let i = 1u; true; i += 1) {
		const line = match (bufio::scan_line(&scan)!) {
		case io::EOF =>
			break;
		case let line: const str =>
			yield line;
		};
		let first: (void | int) = void;
		let last: (void | int) = void;
		for (let i = 0z; i < len(line); i += 1) :found {
			for (let num = start; num < len(numbers); num += 1) {
				const start = strings::sub(line, i, strings::end);
				if (first is void && strings::hasprefix(start, numbers[num].0)) {
					first = numbers[num].1;
				};
				const end = strings::sub(line, len(line) - 1 - i, strings::end);
				if (last is void && strings::hasprefix(end, numbers[num].0)) {
					last = numbers[num].1;
				};
				if (first is int && last is int) {
					break :found;
				};
			};
		};
		sum += first as int * 10 + last as int;
	};
	fmt::printfln("{}", sum)!;
};

export fn main() void = {
	solve(9);
	solve(0);
};

I think I found a decently short solution for part 2 in python:

DIGITS = {
    'one': '1',
    'two': '2',
    'three': '3',
    'four': '4',
    'five': '5',
    'six': '6',
    'seven': '7',
    'eight': '8',
    'nine': '9',
}


def find_digit(word: str) -> str:
    for digit, value in DIGITS.items():
        if word.startswith(digit):
            return value
        if word.startswith(value):
            return value
    return ''


total = 0
for line in puzzle.split('\n'):
    digits = [
        digit for i in range(len(line))
        if (digit := find_digit(line[i:]))
    ]
    total += int(digits[0] + digits[-1])


print(total)

I wanted to see if it was possible to do part 1 in a single line of Python:

print(sum([(([int(i) for i in line if i.isdigit()][0]) * 10 + [int(i) for i in line if i.isdigit()][-1]) for line in open("input.txt")]))

I feel ok about part 1, and just terrible about part 2.

day01.factor on github (with comments and imports):

: part1 ( -- )
  "vocab:aoc-2023/day01/input.txt" utf8 file-lines
  [
    [ [ digit? ] find nip ]
    [ [ digit? ] find-last nip ] bi
    2array string>number
  ] map-sum .
;

MEMO: digit-words ( -- name-char-assoc )
  [ "123456789" [ dup char>name "-" split1 nip ,, ] each ] H{ } make
;

: first-digit-char ( str -- num-char/f i/f )
  [ digit? ] find swap
;

: last-digit-char ( str -- num-char/f i/f )
  [ digit? ] find-last swap
;

: first-digit-word ( str -- num-char/f )
  [
    digit-words keys [
      2dup subseq-index
      dup [
        [ digit-words at ] dip
        ,,
      ] [ 2drop ] if
    ] each drop                           !
  ] H{ } make
  [ f ] [
    sort-keys first last
  ] if-assoc-empty
;

: last-digit-word ( str -- num-char/f )
  reverse
  [
    digit-words keys [
      reverse
      2dup subseq-index
      dup [
        [ reverse digit-words at ] dip
        ,,
      ] [ 2drop ] if
    ] each drop                           !
  ] H{ } make
  [ f ] [
    sort-keys first last
  ] if-assoc-empty
;

: first-digit ( str -- num-char )
  dup first-digit-char dup [
    pick 2dup swap head nip
    first-digit-word dup [
      [ 2drop ] dip
    ] [ 2drop ] if
    nip
  ] [
    2drop first-digit-word
  ] if
;

: last-digit ( str -- num-char )
  dup last-digit-char dup [
    pick 2dup swap 1 + tail nip
    last-digit-word dup [
      [ 2drop ] dip
    ] [ 2drop ] if
    nip
  ] [
    2drop last-digit-word
  ] if
;

: part2 ( -- )
  "vocab:aoc-2023/day01/input.txt" utf8 file-lines
  [ [ first-digit ] [ last-digit ] bi 2array string>number ] map-sum .
;

Java

My take on a modern Java solution (parts 1 & 2).

package thtroyer.day1;

import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;


public class Day1 {
    record Match(int index, String name, int value) {
    }

    Map numbers = Map.of(
            "one", 1,
            "two", 2,
            "three", 3,
            "four", 4,
            "five", 5,
            "six", 6,
            "seven", 7,
            "eight", 8,
            "nine", 9);

    /**
     * Takes in all lines, returns summed answer
     */
    public int getCalibrationValue(String... lines) {
        return Arrays.stream(lines)
                .map(this::getCalibrationValue)
                .map(Integer::parseInt)
                .reduce(0, Integer::sum);
    }

    /**
     * Takes a single line and returns the value for that line,
     * which is the first and last number (numerical or text).
     */
    protected String getCalibrationValue(String line) {
        var matches = Stream.concat(
                        findAllNumberStrings(line).stream(),
                        findAllNumerics(line).stream()
                ).sorted(Comparator.comparingInt(Match::index))
                .toList();

        return "" + matches.getFirst().value() + matches.getLast().value();
    }

    /**
     * Find all the strings of written numbers (e.g. "one")
     *
     * @return List of Matches
     */
    private List findAllNumberStrings(String line) {
        return IntStream.range(0, line.length())
                .boxed()
                .map(i -> findAMatchAtIndex(line, i))
                .filter(Optional::isPresent)
                .map(Optional::get)
                .sorted(Comparator.comparingInt(Match::index))
                .toList();
    }


    private Optional findAMatchAtIndex(String line, int index) {
        return numbers.entrySet().stream()
                .filter(n -> line.indexOf(n.getKey(), index) == index)
                .map(n -> new Match(index, n.getKey(), n.getValue()))
                .findAny();
    }

    /**
     * Find all the strings of digits (e.g. "1")
     *
     * @return List of Matches
     */
    private List findAllNumerics(String line) {
        return IntStream.range(0, line.length())
                .boxed()
                .filter(i -> Character.isDigit(line.charAt(i)))
                .map(i -> new Match(i, null, Integer.parseInt(line.substring(i, i + 1))))
                .toList();
    }

    public static void main(String[] args) {
        System.out.println(new Day1().getCalibrationValue(args));
    }
}

My solution in rust. I’m sure there’s a lot more clever ways to do it but this is what I came up with.

use std::{io::prelude::*, fs::File, path::Path, io };

fn main() 
{
    run_solution(false); 

    println!("\nPress enter to continue");
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer).unwrap();

    run_solution(true); 
}

fn run_solution(check_for_spelled: bool)
{
    let data = load_data("data/input");

    println!("\nProcessing Data...");

    let mut sum: u64 = 0;
    for line in data.lines()
    {
        // Doesn't seem like the to_ascii_lower call is needed but... just in case
        let first = get_digit(line.to_ascii_lowercase().as_bytes(), false, check_for_spelled);
        let last = get_digit(line.to_ascii_lowercase().as_bytes(), true, check_for_spelled);


        let num = (first * 10) + last;

        // println!("\nLine: {} -- First: {}, Second: {}, Num: {}", line, first, last, num);
        sum += num as u64;
    }

    println!("\nFinal Sum: {}", sum);
}

fn get_digit(line: &[u8], from_back: bool, check_for_spelled: bool) -> u8
{
    let mut range: Vec = (0..line.len()).collect();
    if from_back
    {
        range.reverse();
    }

    for i in range
    {
        if is_num(line[i])
        {
            return (line[i] - 48) as u8;
        }

        if check_for_spelled
        {
            if let Some(num) = is_spelled_num(line, i)
            {
                return num;
            }
        }
    }

    return 0;
}

fn is_num(c: u8) -> bool
{
    c >= 48 && c <= 57
}

fn is_spelled_num(line: &[u8], start: usize) -> Option
{
    let words = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine"];

    for word_idx in 0..words.len()
    {
        let mut i = start;
        let mut found = true;
        for c in words[word_idx].as_bytes()
        {
            if i < line.len() && *c != line[i]
            {
                found = false;
                break;
            }
            i += 1;
        }

        if found && i <= line.len()
        {
            return Some(word_idx as u8 + 1);
        }
    }

    return None;
}

fn load_data(file_name: &str) -> String
{
    let mut file = match File::open(Path::new(file_name))
    {
        Ok(file) => file,
        Err(why) => panic!("Could not open file {}: {}", Path::new(file_name).display(), why),
    };

    let mut s = String::new();
    let file_contents = match file.read_to_string(&mut s) 
    {
        Err(why) => panic!("couldn't read {}: {}", Path::new(file_name).display(), why),
        Ok(_) => s,
    };
    
    return file_contents;
}

[Rust] 11157/6740

use std::fs;

const m: [(&str, u32); 10] = [
    ("zero", 0),
    ("one", 1),
    ("two", 2),
    ("three", 3),
    ("four", 4),
    ("five", 5),
    ("six", 6),
    ("seven", 7),
    ("eight", 8),
    ("nine", 9)
];

fn main() {
    let s = fs::read_to_string("data/input.txt").unwrap();

    let mut u = 0;

    for l in s.lines() {
        let mut h = l.chars();
        let mut f = 0;
        let mut a = 0;

        for n in 0..l.len() {
            let u = h.next().unwrap();

            match u.is_numeric() {
                true => {
                    let v = u.to_digit(10).unwrap();
                    if f == 0 {
                        f = v;
                    }
                    a = v;
                },
                _ => {
                    for (t, v) in m {
                        if l[n..].starts_with(t) {
                            if f == 0 {
                                f = v;
                            }
                            a = v;
                        }
                    }
                },
            }
        }

        u += f * 10 + a;
    }

    println!("Sum: {}", u);
}

Link

Dart solution

This has got to be one of the biggest jumps in trickiness in a Day 1 puzzle. In the end I rolled my part 1 answer into the part 2 logic. [Edit: I’ve golfed it a bit since first posting it]

import 'package:collection/collection.dart';

var ds = '0123456789'.split('');
var wds = 'one two three four five six seven eight nine'.split(' ');

int s2d(String s) => s.length == 1 ? int.parse(s) : wds.indexOf(s) + 1;

int value(String s, List digits) {
  var firsts = {for (var e in digits) s.indexOf(e): e}..remove(-1);
  var lasts = {for (var e in digits) s.lastIndexOf(e): e}..remove(-1);
  return s2d(firsts[firsts.keys.min]) * 10 + s2d(lasts[lasts.keys.max]);
}

part1(List lines) => lines.map((e) => value(e, ds)).sum;

part2(List lines) => lines.map((e) => value(e, ds + wds)).sum;

Solution in C: https://github.com/sjmulder/aoc/blob/master/2023/c/day01-orig.c

Usually day 1 solutions are super short numeric things, this was a little more verbose. For part 2 I just loop over an array of digit names and use strncmp().

int main(int argc, char **argv)
{
	static const char * const nm[] = {"zero", "one", "two", "three",
	    "four", "five", "six", "seven", "eight", "nine"};
	char buf[64], *s;
	int p1=0,p2=0, p1f,p1l, p2f,p2l, d;
	
	while (fgets(buf, sizeof(buf), stdin)) {
		p1f = p1l = p2f = p2l = -1;

		for (s=buf; *s; s++)
			if (*s >= '0' && *s <= '9') {
				d = *s-'0';
				if (p1f == -1) p1f = d;
				if (p2f == -1) p2f = d;
				p1l = p2l = d;
			} else for (d=0; d<10; d++) {
				if (strncmp(s, nm[d], strlen(nm[d])))
					continue;
				if (p2f == -1) p2f = d;
				p2l = d;
				break;
			}

		p1 += p1f*10 + p1l;
		p2 += p2f*10 + p2l;
	}

	printf("%d %d\n", p1, p2);
	return 0;
}