Advent of Code 2023: ChatGPT-4 turbo edition

Igual que la parte 1 pero convirtiendo las palabras a números.

private function lineConcat(string $line): int
{
    preg_match_all('/\d/', $line, $matches);

if (count($matches[0]) === 0) {
    return 0;
}

$firstDigit = $matches[0][0];
$lastDigit = end($matches[0]);

return (int)($firstDigit . $lastDigit);
}

use std::collections::{HashMap, VecDeque};

use crate::handler::Handler;

#[derive(Debug)]
pub struct Day01 {
    pub map: HashMap<String, u32>,
}

impl Day01 {
    fn fill_hashmap() -> HashMap<String, u32> {
        HashMap::from([
            ("one".to_string(), 1),
            ("two".to_string(), 2),
            ("three".to_string(), 3),
            ("four".to_string(), 4),
            ("five".to_string(), 5),
            ("six".to_string(), 6),
            ("seven".to_string(), 7),
            ("eight".to_string(), 8),
            ("nine".to_string(), 9),
        ])
    }

fn process_input() -> Vec<String> {
    let handler = Handler::new("./src/day01/input.txt");
    let processed_input = handler
        .handle_input()
        .unwrap()
        .lines()
        .map(|line| line.to_string())
        .collect();

    processed_input
}

pub fn part1() -> u32 {
    let input = Self::process_input();
    let result: u32 = input
        .iter()
        .map(|line| {
            let numbers_as_chars: Vec<char> = line.chars().filter(|c| c.is_numeric()).collect();

            if numbers_as_chars.is_empty() {
                return 0;
            }

            numbers_as_chars[0].to_digit(10).unwrap() * 10
                + numbers_as_chars[numbers_as_chars.len() - 1]
                    .to_digit(10)
                    .unwrap()
        })
        .sum();

    result
}

pub fn part2() -> u32 {
    let map = Self::fill_hashmap();
    let input = Self::process_input();
    let result: u32 = input
        .iter()
        .map(|line| {
            let mut numbers: Vec<u32> = vec![];
            let mut word: VecDeque<char> = VecDeque::new();

            line.chars().for_each(|c| {
                if c.is_numeric() {
                    numbers.push(c.to_digit(10).unwrap());
                    word.clear();
                } else {
                    word.push_back(c);
                    let word_as_string: String = word.iter().collect();

                    if map.keys().any(|key| key.contains(&word_as_string)) {
                        if let Some(&number) = map.get(&word_as_string) {
                            numbers.push(number);

                            let overlapping_value = word.pop_back().unwrap();
                            word.clear();
                            word.push_back(overlapping_value);
                        }
                    } else {
                        word.pop_front();
                    }
                }
            });

            if numbers.is_empty() {
                return 0;
            }

            numbers[0] * 10 + numbers[numbers.len() - 1]
        })
        .sum();

    result
}
}

#[test]
fn test1() {
    let expected = 55208;
    assert_eq!(expected, Day01::part1());
}

#[test]
fn test2() {
    let expected = 54578;
    assert_eq!(expected, Day01::part2());
}

public class Trebuchet {

private final List<String> inputs;
private final String[] numberWords = {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
private final String[] numberDigits = {"o1e", "t2o", "t3e", "f4r", "f5e", "s6x", "s7n", "e8t", "n9e"};

public Trebuchet(List<String> inputs) {
    this.inputs = inputs;
}

public int solveA() {
    return inputs.stream()
            .map(this::lineValue)
            .reduce(0,Math::addExact);
}

public int solveB() {
    return inputs.stream()
            .map(this::replaceWordsWithNumber)
            .map(this::lineValue)
            .reduce(0,Math::addExact);
}

private int lineValue(String line) {
    List<String> result = line.chars()
            .filter(Character::isDigit)
            .mapToObj(c -> (char) c)
            .map(Object::toString)
            .toList();

    String first = result.get(0);
    String last = result.get(result.size()-1);

    String number = first + last;
    return Integer.parseInt(number);
}

private String replaceWordsWithNumber(String line){
    String replaceLine = line;
    for(int i = 0; i < numberWords.length; i++) {
        replaceLine = replaceLine.replace(numberWords[i], numberDigits[i]);
    }
    return replaceLine;
}
}

Lo he visto con letras iniciales y finales, con palabras completas y hasta generando todas las posibles combinaciones de nombres solapables (por ejemplo "two" puede solapar con "one" y entonces te creas en el mapa un "twone" -> "21" y así con todas las combinaciones.