Welcome everyone to the 2023 advent of code! Thank you all for stopping by and participating in it in programming.dev whether youre new to the event or doing it again.

This is an unofficial community for the event as no official spot exists on lemmy but ill be running it as best I can with Sigmatics modding as well. Ill be running a solution megathread every day where you can share solutions with other participants to compare your answers and to see the things other people come up with


Day 1: Trebuchet?!


Megathread guidelines

  • Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
  • Code block support is not fully rolled out yet but likely will be in the middle of the event. Try to share solutions as both code blocks and using something such as https://topaz.github.io/paste/ or pastebin (code blocks to future proof it for when 0.19 comes out and since code blocks currently function in some apps and some instances as well if they are running a 0.19 beta)

FAQ


🔒This post will be unlocked when there is a decent amount of submissions on the leaderboard to avoid cheating for top spots

🔓 Edit: Post has been unlocked after 6 minutes

  • Malssistra@programming.dev
    link
    fedilink
    arrow-up
    8
    ·
    6 months ago

    Python 3

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

    spoiler
    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.

  • sjmulder@lemmy.sdf.org
    link
    fedilink
    arrow-up
    6
    ·
    edit-2
    6 months ago

    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;
    }
    
    • sjmulder@lemmy.sdf.org
      link
      fedilink
      arrow-up
      3
      ·
      6 months ago

      And golfed down:

      char*N[]={0,"one","two","three","four","five","six","seven","eight","nine"};p,P,
      i,c,a,b;A,B;m[10];main(){while((c=getchar())>0){c==10?p+=a*10+b,P+=A*10+B,a=b=A=
      B=0:0;c>47&&c<58?b=B=c-48,a||(a=b),A||(A=b):0;for(i=10;--i;)c!=N[i][m[i]++]?m[i]
      =c==*N[i]:!N[i][m[i]]?A||(A=i),B=i:0;}printf("%d %d\n",p,P);
      
  • Ategon@programming.devOPM
    link
    fedilink
    arrow-up
    5
    ·
    6 months ago

    [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

    • Ategon@programming.devOPM
      link
      fedilink
      arrow-up
      2
      ·
      6 months ago

      Started a bit late due to setting up the thread and monitoring the leaderboard to open it up but still got it decently quick for having barely touched rust

      Probably able to get it down shorter so might revisit it

    • BrucePotality@lemmy.dbzer0.com
      link
      fedilink
      arrow-up
      1
      ·
      6 months ago

      Ive been trying to learn rust for like a month now and I figured I’d try aoc with rust instead of typescript. Your solution is way better than mine and also pretty incomprehensible to me lol. I suck at rust -_-

        • Ategon@programming.devOPM
          link
          fedilink
          arrow-up
          2
          ·
          6 months ago

          Yeah tried to golf it a bit so its not very readable

          Seems like the site doesn’t track characters though so won’t do that for future days

          It basically just loops through every character on a line, if it’s a number it sets last to that and if its not a number it checks if theres a substring starting on that point that equals one of the 10 strings that are numbers

      • learningduck@programming.dev
        link
        fedilink
        arrow-up
        1
        ·
        edit-2
        6 months ago

        In case that this might help.

        h.chars() returns an iterator of characters. Then he concatenate chars and see if it’s a digit or a number string.

        You can swap match u.is_numeric() with if u.is_numeric and covert _ => branch to else.

  • perviouslyiner@lemm.ee
    link
    fedilink
    English
    arrow-up
    5
    ·
    edit-2
    6 months ago
    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.

  • bugsmith@programming.dev
    link
    fedilink
    arrow-up
    5
    ·
    edit-2
    6 months ago

    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
    }
    
  • 🔻Sleepless One🔻@lemmygrad.ml
    link
    fedilink
    English
    arrow-up
    5
    ·
    edit-2
    6 months ago

    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>
  • capitalpb@programming.dev
    link
    fedilink
    English
    arrow-up
    5
    ·
    edit-2
    6 months ago

    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(&amp;self, input: &amp;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(&amp;self, input: &amp;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 = &amp;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 = &amp;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()
        }
    }
    
  • mykl@lemmy.world
    link
    fedilink
    arrow-up
    4
    ·
    edit-2
    6 months ago

    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;
    
  • calvin@lemmy.calvss.com
    link
    fedilink
    arrow-up
    4
    ·
    6 months ago

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

  • Andy@programming.dev
    link
    fedilink
    arrow-up
    4
    ·
    edit-2
    5 months ago

    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 .
    ;
    
  • Jummit@lemmy.one
    link
    fedilink
    arrow-up
    4
    ·
    6 months ago

    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:

    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 &lt; 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:

    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(&amp;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 &lt; len(line); i += 1) :found {
    			for (let num = start; num &lt; len(numbers); num += 1) {
    				const start = strings::sub(line, i, strings::end);
    				if (first is void &amp;&amp; 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 &amp;&amp; strings::hasprefix(end, numbers[num].0)) {
    					last = numbers[num].1;
    				};
    				if (first is int &amp;&amp; last is int) {
    					break :found;
    				};
    			};
    		};
    		sum += first as int * 10 + last as int;
    	};
    	fmt::printfln("{}", sum)!;
    };
    
    export fn main() void = {
    	solve(9);
    	solve(0);
    };
    
  • Tom@programming.dev
    link
    fedilink
    arrow-up
    4
    ·
    edit-2
    6 months ago

    Java

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

    spoiler
    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));
        }
    }
    
    
  • sjmulder@lemmy.sdf.org
    link
    fedilink
    arrow-up
    4
    ·
    edit-2
    6 months ago

    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' &amp;&amp; *s &lt;= '9') {
    				d = *s-'0';
    				if (p1f == -1) p1f = d;
    				if (p2f == -1) p2f = d;
    				p1l = p2l = d;
    			} else for (d=0; d&lt;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;
    }