#adventofcode2023 — Public Fediverse posts

Crazy how much difference the right data structure / #algorithm for a task makes.

This week I learned about #Deterministic #Finite #Automata and #Nondeterministic Finite Automata just to redo my clunky #AdventOfCode2023 day 12 challenge, written in #Rust #RustLang

Runtime for part 1 dropped from 1-2secs to milliseconds. Part 2 also milliseconds 😮

Are there any good Rust crates for DFAs/NFAs?

Many people solved that problem with #Dynamic #Programming - something else for the learn list 😉

Crazy how much difference the right data structure / #algorithm for a task makes.

This week I learned about #Deterministic #Finite #Automata and #Nondeterministic Finite Automata just to redo my clunky #AdventOfCode2023 day 12 challenge, written in #Rust #RustLang

Runtime for part 1 dropped from 1-2secs to milliseconds. Part 2 also milliseconds 😮

Are there any good Rust crates for DFAs/NFAs?

Many people solved that problem with #Dynamic #Programming - something else for the learn list 😉

Crazy how much difference the right data structure / #algorithm for a task makes.

This week I learned about #Deterministic #Finite #Automata and #Nondeterministic Finite Automata just to redo my clunky #AdventOfCode2023 day 12 challenge, written in #Rust #RustLang

Runtime for part 1 dropped from 1-2secs to milliseconds. Part 2 also milliseconds 😮

Are there any good Rust crates for DFAs/NFAs?

Many people solved that problem with #Dynamic #Programming - something else for the learn list 😉

Crazy how much difference the right data structure / #algorithm for a task makes.

This week I learned about #Deterministic #Finite #Automata and #Nondeterministic Finite Automata just to redo my clunky #AdventOfCode2023 day 12 challenge, written in #Rust #RustLang

Runtime for part 1 dropped from 1-2secs to milliseconds. Part 2 also milliseconds 😮

Are there any good Rust crates for DFAs/NFAs?

Many people solved that problem with #Dynamic #Programming - something else for the learn list 😉

Crazy how much difference the right data structure / #algorithm for a task makes.

This week I learned about #Deterministic #Finite #Automata and #Nondeterministic Finite Automata just to redo my clunky #AdventOfCode2023 day 12 challenge, written in #Rust #RustLang

Runtime for part 1 dropped from 1-2secs to milliseconds. Part 2 also milliseconds 😮

Are there any good Rust crates for DFAs/NFAs?

Many people solved that problem with #Dynamic #Programming - something else for the learn list 😉

D’éirigh liom an t-#AdventOfCode a chríochnú roimh teacht don Bhliain Úr! 🎉

Mo chuid réiteach in #Rust:

https://gitlab.com/silmeth/advent-of-code-2023

#AoC #AdventOfCode2023 #AoC2023 #RustLang

Managed to finish #AdventOfCode before the New Year! 🎉

My solutions in Rust:

https://gitlab.com/silmeth/advent-of-code-2023

#AoC #RustLang #Rust #AoC2023 #AdventOfCode2023

Feeling Advent of Code burnout. I’ve 5 stars missing (parts 2 of days 21, 23, 24, and the whole 25th day) and can’t get around to doing any of that.

(Also honestly I’ve never done any graph algorithms so not even sure how to approach 25th)

#AdventOfCode #AdventOfCode2023 #AoC #AoC2023

#AdventOfCode 2023 Day 19: Aplenty

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

That was fun. I had a small mistake in part 2. In order to debug it, I was looking for a tool to visualize the decision graph. I found that #networkx in combination with #cytoscape works fantastic. Attached are the graphs from the test input and my real input.

Code is here:
https://github.com/nharrer/AdventOfCode/blob/main/2023/day19/solve-day19.py

NetworkX: https://networkx.org/
Cytoscape: https://cytoscape.org/

#AdventOfCode2023 #AoC #Python

#AdventOfCode #AoC

I completed #Day09 of #AdventOfCode2023.

Part 1:
- Difficulty: 1/10
- Workout: 1/10

Part 2:
- Difficulty: 0/10
- Workout: 1/10

This one was too easy, done in half a hour! 2-dimension array to hold all difference sequences (including the original sequence, at index 0). No need to get to the all-zeros level, the one just above (all values are equal) is enough. Attention to index fiddling. That's it.

Since I still got time, I refactored the program to make it presentable. It's in the next post in this thread. Done in almost one hour.

#AdventOfCode #AoC

I completed #Day08 of #AdventOfCode2023.

Part 1:
- Difficulty: 3/10
- Workout: 2/10

Part 2:
- Difficulty: 3/10
- Workout: 5/10

Part 1 was a straight simulation: instructions given, parse and table moves, loop for following instructions. Barely a half-hour of work.

Part 2 extends from one start point to several; it just means a list of places mapping to a list of places, instead of place mapping to place.

Brute force, like in part 1, turned out to be not viable: 1.8e9 iterations, and nothing. I tried to find repeatable sequences of places, starting with each place and instruction position, but the volume of data generated was getting too big.

I had to resort to r/AdventOfCode for tips. At once, I found: closed cycles and LCM. It was enough. I quickly found --Z to --Z cycles, and their periods; all multiples of the same number. A quick implementation of GCD, then LCM(a, b) = a * b / GCD(a, b), reduce list of periods by LCM, and done.

Total time, programming and wasting CPU: about 7 hours.

#AdventOfCode #AoC

I completed #Day07 of #AdventOfCode2023.

Part 1:
- Difficulty: 2/10
- Workout: 4/10

Part 2:
- Difficulty: 3/10
- Workout: 4/10

Took me almost 4 hours to solve this one, mainly because of the tricky implementation for jokers in part 2. Turned out that my method was too clever by half, and introduced itself a subtle bug.

#AdventOfCode #AoC

I completed #Day06 of #AdventOfCode2023.

Part 1:
- Difficulty: 1/10
- Workout: 1/10

Part 2:
- Difficulty: 1/10
- Workout: 1/10

Completed in just over 1 hour. The implementation of part 1 was straightforward: easy parsing, map, filter, length. Part 2 would work, too, but after a few seconds running, I did the smart thing: skip the loops entirely. Immediate solution.

Big hint: solve the equation

a * (t - a) > d

For integer a.

#AdventOfCode #AoC

I (finally!) completed #Day05 of #AdventOfCode2023.

Part 1:
- Difficulty: 4/10
- Workout: 3/10

Part 2:
- Difficulty: 5/10
- Workout: 7/10

Part 1 was completed in 1 hour. Early in the game, I noticed that the mappings, with billions of elements, were too big to fit explicitly in memory. So, I created a function to pass one seed through the mapping, only checking the intervals' end points.

Then part 2 came, with billions of seeds to check. Brute forcing was a lost cause: tried it, lost 2 hours, expected another 6 to be done.

I had to resort to clever set operations (intersection and difference) over intervals: several folks had this idea. Split seed intervals over each mapping: common intervals are mapped to destination intervals, seeds not in common intervals make their own intervals and pass unchanged. The result is a list of intervals, to pass as input "seeds" to the next mapping.

Now part 2 was almost immediate, the seeds having been pulverized into just a few hundred intervals.

Total elapsed time: about 8 hours. Whew!

#AdventOfCode #AoC

I completed #Day04 of #AdventOfCode2023.

Part 1:
- Difficulty: 1/10
- Workout: 1/10

Part 2:
- Difficulty: 4/10
- Workout: 4/10

More than 2 hours of intense work!

Part 1 was straightforward: 3 splits, number conversions, array difference, a simple scoring function, and a sum.

Then, part 2 threw me a curveball: an entirely different problem! Had to read and check more than thrice to actually understand it.

After an infinite recursion, and another that ended too early (don't stop if a card has no prize!), I managed to make it run correctly, but s-l-o-w-l-y: it was allocating the cards as they were replicated. Refactoring got rid of the card allocations: a Map from card number to (# of matching numbers, card count) is enough.

BTW, my answer to the 2nd part was a number upwards of 14 million. That's *a lot* of cards! ;-P

Let me just say this, many languages exist that are better suited for code golfing than Go 🤣 #adventofcode2023 #aoc2023 #golang #codegolfing