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

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.

Solved part one in about thirty seconds. But wow, either my brain is just tired at this hour or I’m lacking in skill, but part two is harder than any other year has been on the first day. Anyway, I managed to solve it, but I absolutely hate it, and will definitely be coming back to try to clean this one up.

https://github.com/capitalpb/advent_of_code_2023/blob/main/src/solvers/day01.rs

impl Solver for Day01 {
    fn star_one(&self, input: &str) -> String {
        let mut result = 0;

        for line in input.lines() {
            let line = line
                .chars()
                .filter(|ch| ch.is_ascii_digit())
                .collect::>();
            let first = line.first().unwrap();
            let last = line.last().unwrap();
            let number = format!("{first}{last}").parse::().unwrap();
            result += number;
        }

        result.to_string()
    }

    fn star_two(&self, input: &str) -> String {
        let mut result = 0;

        for line in input.lines() {
            let mut first = None;
            let mut last = None;

            while first == None {
                for index in 0..line.len() {
                    let line_slice = &line[index..];
                    if line_slice.starts_with("one") || line_slice.starts_with("1") {
                        first = Some(1);
                    } else if line_slice.starts_with("two") || line_slice.starts_with("2") {
                        first = Some(2);
                    } else if line_slice.starts_with("three") || line_slice.starts_with("3") {
                        first = Some(3);
                    } else if line_slice.starts_with("four") || line_slice.starts_with("4") {
                        first = Some(4);
                    } else if line_slice.starts_with("five") || line_slice.starts_with("5") {
                        first = Some(5);
                    } else if line_slice.starts_with("six") || line_slice.starts_with("6") {
                        first = Some(6);
                    } else if line_slice.starts_with("seven") || line_slice.starts_with("7") {
                        first = Some(7);
                    } else if line_slice.starts_with("eight") || line_slice.starts_with("8") {
                        first = Some(8);
                    } else if line_slice.starts_with("nine") || line_slice.starts_with("9") {
                        first = Some(9);
                    }

                    if first.is_some() {
                        break;
                    }
                }
            }

            while last == None {
                for index in (0..line.len()).rev() {
                    let line_slice = &line[index..];
                    if line_slice.starts_with("one") || line_slice.starts_with("1") {
                        last = Some(1);
                    } else if line_slice.starts_with("two") || line_slice.starts_with("2") {
                        last = Some(2);
                    } else if line_slice.starts_with("three") || line_slice.starts_with("3") {
                        last = Some(3);
                    } else if line_slice.starts_with("four") || line_slice.starts_with("4") {
                        last = Some(4);
                    } else if line_slice.starts_with("five") || line_slice.starts_with("5") {
                        last = Some(5);
                    } else if line_slice.starts_with("six") || line_slice.starts_with("6") {
                        last = Some(6);
                    } else if line_slice.starts_with("seven") || line_slice.starts_with("7") {
                        last = Some(7);
                    } else if line_slice.starts_with("eight") || line_slice.starts_with("8") {
                        last = Some(8);
                    } else if line_slice.starts_with("nine") || line_slice.starts_with("9") {
                        last = Some(9);
                    }

                    if last.is_some() {
                        break;
                    }
                }
            }

            result += format!("{}{}", first.unwrap(), last.unwrap())
                .parse::()
                .unwrap();
        }

        result.to_string()
    }
}

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
}

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

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)

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

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

[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

I’m a bit late to the party. I forgot about this.

Anyways, my (lazy) C solutions: https://git.sr.ht/~aidenisik/aoc23/tree/master/item/day1

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")]))

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;