The official awful.systems Advent of Code 2023 thread
Rules: no spoilers.
The other rules are made up as we go along.
Share code by link to a forge, home page, pastebin (Eric Wastl has one here) or code section in a comment.
Just when I think I'm out, awful systems pulls me right back in.
C++, Horrifying C++ for day 1b check it out ;)
Day 1: https://www.animeprincess.net/blog/?p=55
One day is enough for me though, writing deliberately off-the-wall code is surprisingly mentally taxing, and normally I make sure to never program outside of work.
I am using dart to develop my dart chops. All code for all days here:
Nice, I’ll be reading :D
(Possibly have some dart coming up on a thing soon)
I'll be honest: so far, Dart is pretty rubbish for this kind of exercise for the simple reason that their Strings aren't just arrays of chars. There's no native isDigit, for example. Otherwise, I've been using it with Flutter and have been happy with my experience.
I'm only posting code when I think I've done something interesting or if there's a notable language feature to show off, but so far, no dice.
7 Camel Cards
9
8
I only managed part 1 today. My enthusiasm for index fiddling is waning rapidly.
How about not fiddling with indices?
Similarly tired with index fiddling, I was pretty happy with my approach, which led to satisfying transpose cancelling in part 2. Not the fastest code out there, but it works. Day 14 was actually my favorite one so far ^^.
Back to a more straightfoward day, do they make them harder on the weekends?
Historically problems on Sat/Sun have been more challenging than weekdays. However given that the first 7 days are usually “warmup” problems, I’d say this years edition of AoC is more challenging than at least since 2019.
I liked today's puzzle. It was meaty but not frustrating.
Late to the party and never done advents before, I liked how this problem reminded me that tree traversal is thing, almost as much as I don't that so much of my career involves powershell now.
I'm putting everything up at https://github.com/SpaceAntelope/advent-of-code-2023 except the input files.
Using command abbreviations like % and ? to keep the horizontal length friendly to lemmy post areas, they are expanded in git. ::: spoiler Part 2 in Powershell
function calculate([string]$data) {
# code for parsing data and calculating matches from pt1 here, check the github link if you like banal regexps
# returns objects with the relevant fields being the card index and the match count
}
function calculateAccumulatedCards($data) {
$cards = calculate $data # do pt1 calculations
$cards
| ? MatchCount -gt 0 # otherwise the losing card becomes its own child and the search cycles to overflow
| % {
$children = ($_.Index + 1) .. ($_.Index + $_.MatchCount) # range of numbers corresponding to indices of cards won
| % { $cards[$_ - 1] } # map to the actual cards
| ? { $null -ne $_ } # filter out overflow when index exceeds input length
$_ | Add-Member -NotePropertyName Children -NotePropertyValue $children # add cards gained as children property
}
# do depth first search on every card and its branching children while counting every node
# the recursive function is inlined in the foreach block because it's simpler than referencing it
# from outside the parallel scope
$cards | % -Parallel {
function traverse($card) {
$script:count++
foreach ($c in $card.Children) { traverse($c) }
}
$script:count = 0 # script: means it's basically globally scoped
traverse $_
$script:count # pass node count to pipeline
}
| measure -sum
| % sum
}
:::
https://adventofcode.com/2023/day/2
Parsing the puzzle (both instructions and input) was the hardest this time for me.
Perl solution, nothing special: https://github.com/gustafe/aoc2023/blob/main/d02-Cube-Conundrum.pl
https://adventofcode.com/2023/day/11
Have been mostly using jq for fun.
First part was easy, and very suited to jq
Second part was harder than expected, i had to resort to regex.
Not too much trickery in this example.
Satisifyingly straightfoward edit form part one.
Took More time than i expected, glad i had the idea early to search by the indices of the symbols and not the digits. Not super well suited to jq, unless I'm missing a better solution.
Not too far of an edit from part one.
Let's do this.
https://adventofcode.com/2023/day/3
Writeup of my solution: https://github.com/gustafe/aoc2023#day-3-gear-ratios
Sorry for the necropost: I have completed all the problems! One of them completely stumped me and I had to cheat. Not going to do a writeup unless requested :)
congrats! I have officially checked out of the competition for the time being. Maybe if I get some spare energy later.
What problem had you stumped?
24b, sort of. The problem came down to “hey do you remember how to do linear algebra?” and the answer was: dawg, I barely know normal algebra. I had solved the vibes of the problem but none of the details, though.
No-one should begrudge or judge you for taking a day off.
rule 5: one code enters, 7 codes leave
okay yeah so
p1 part 1 submitted, runs fine. part 2 says "wrong answer for you but right for someone else". doing a debug-print-everything run on the intermediate stages of the data after my regex all seems correct, but it's also 23h50 and it's been a looooong week. so I guess I'll take a look a fresh look at that one in the morning over coffee
part1, badly:
(I really wasn't kidding about the badly)
part2:
Starting a new comment thread for my solutions to 10-19. Double digits, baby! Code here: https://github.com/Fluxward/aoc2023/
b. Pretty much just changed the input parsing and ran the same algorithm. Thought that it might be too slow, but I put in some stopwatch ticks and found out that it should take about 5 minutes to run my a) algorithm to get the answer.
The actual time elapsed was 5m50s.
I miiiiight try make a faster version but my head is too fucked up to care right now, hence me letting the slow algorithm run. :::
11 ::: spoiler a,b a: So, I've been in the habit of skipping the flavour text and glossing over the prompt. This time, it hurt me badly.
I read the problem as follows: for N galaxies, find N/2 pairings such that the sum of distances is minimal.
At this point, I was like, wow, the difficulty has ramped up. A DP? That will probably run out of memory with most approaches, requiring a BitSet. I dove in, eager to implement a janky data structure to solve this humdinger.
I wrote the whole damn thing. The bitset, the DP, everything. I ran the code, and WOAH, that number was much smaller than the sample answer. I reread the prompt and realised I had it all wrong.
It wasn't all for naught, though. A lot of the convenience stuff I'd written was fine. Also, I implemented a sparse parser, which helped for b.
b: I was hoping they were asking for what I had accidentally implemented for a. My hopes were squandered.
Anyway, this was pretty trivial with a sparse representation of the galaxies. :::
The code I have up as of this comment is pretty long and boring, I might try clean it up later.
10! ::: spoiler a, b a was relatively straightforward - again, an implementation test.
b was interesting- luckily, I remembered how to test if a point lives inside a curve. The line-crossing count algorithm was a little tricky to write from scratch, but I finally got there. Also, I screwed up for like an hour when I didn't realise you were supposed to count junk pipes as part of the territory. Code wise it got messy, and I've thrown something up on my github, but might try clean it up a little later. :::
Update: I've cleaned up my code and made it "dartier" i.e. I use more neat dart syntactic sugar at the cost of readability.
17, We’re in the back third now, folks! ::: spoiler a, b A and B were roughly the same difficulty.
So in my first year in university, in my intro DSA class, we learned A*. Have I learned any other ways to search since? Not really. So I used A* here.
It took way longer than it should have to solve, which I blame on my ongoing illness. The main sticking point was that I implemented a class to represent the search state, and since I was going to use it as a key to a map, I implemented a hashcode for it. The rest of the A* code freely flowed from my brain (really the wikipedia pseudocode).
Cue like 40 mins plus of wondering how the test input was searching over millions of states, wondering if I’d fucked up the A* implementation, wondering if the problem was too big for A*, and wondering if it was finally time to take a days break from all the aoc nonsense.
Anyway at some point I realised I forgot to implement the corresponding equals method to my hashcode. Once I had that my code ran in seconds and everything was fine. This sickness is the worst!!! :::
12
Happy Holidays everyone. I’ve decided I am going to take a break from aoc to properly rest and recover from my mystery illness. Perhaps I will attempt solves again in the new year.
Happy holidays!
Happy holidays to you too! I decided this morning that I'm not gonna work myself up missing days, so they are on hold until after xmas for me!
Get well soon!
Thanks dawg. AOC has occupied the working part of my brain but now that it requires more brain wrinklies than usual I’m gonna go back to writing sneers.
https://adventofcode.com/2023/day/5
Leaderboard completion time: 26m37s, so it's the toughest problem this year so far.
I liked the slight trickiness of part 2, that the naive implementation would never complete in time.
As always doing a JQ implementation:
Replaced less-than (and greater-than for symmetry) symbols with full-width version, since lemmy apparently doesn't handle them well within a code block: replacing less than with lt;
I have to punt on part 2 for now, generally shitty day precludes fun coding.
Update done, nothing special
https://github.com/gustafe/aoc2023/blob/main/d05-If-You-Give-A-Seed-A-Fertilizer.pl
Starting this thread having only solved a.
This is the hardest problem of the year so far, based on leaderboard completion times. I'm busy wrapping up work for this year, and looking for a new job, so this will have to be put on the TODO pile
At this point I have officially given up and started looking at other people’s code. I’ll work on it after Imm fully better, it’s too much for me right now.
Only solved by receving heavy hints from other's solution, and it still took me forever. By far the hardest this year.
Update on B:
Update to the update: now fully recovered, I am now trying to finish the last problems.
Solved 21 B!
https://adventofcode.com/2023/day/6
nice cleanser after yesterday
I have come up with a more horrifying way to solve Day 1 Part 1 involving C++ implementation defined behavior, but it requires launching two subprocesses for every test case so I'm not sure I have the motivation right now.
Proof of concept: https://www.animeprincess.net/blog/?p=60
I believe you've posted in the wrong thread. This is the awful systems thread, not the awesome systems thread.
https://adventofcode.com/2023/day/7
So far, my favorite puzzle. Challenging but fair. Also plays to Perl's strengths.
Leaderboard completion time: 16 minutes flat, so not a pushover.
Comments and code: https://github.com/gustafe/aoc2023/tree/main#day-7-camel-cards
It feels weird to kick one of these threads off, but hey, here we go.
Code as always: https://github.com/Fluxward/aoc2023/blob/main/20.dart
I'm having a hard time modeling the network at the moment, there's too much shit to keep track of. Objects might be the solution!
Yeah, I mean it’s always possible to do without all the OO stuff, I just didn’t want to mentally keep tabs on what each variable or method did what. That’s what the code is for!
https://adventofcode.com/2023/day/8
Not so easy at least for part two.
Cleaned up version of code used to solve part 2 in jq.
Seeing you implement gcd/lcm makes me think about the people who are gunning for the AoC leaderboards. What do they have that I don’t?
Asking out of general interest and not any sort of feelings of inadequacy (I swear, behind a face of gritted teeth and obvious seethe).
Like, do they have cron scripts to scrape the prompt and input as soon as it comes out? Libraries of util functions accrued from years of AoC participation? That’s all I’ve thought of and honestly it doesn’t sound implausible if you are hypercompetitive. Like I imagine they just have a raiders of the lost ark warehouse of boilerplate indexed in their memory palace to draw from. And I don’t have that and I am totally not envious at all.
My solution: https://github.com/gustafe/aoc2023/blob/main/d09-Mirage-Maintenance.pl
https://adventofcode.com/2023/day/12
Where a curse the fact I decided to use JQ and not a "real" programming language.
A nice workaround to jq single threadedness, since this is maq reduce and safe to parallelize. 17m10s -> 20s !!! ::: spoiler Spoiler link to commit. https://github.com/zogwarg/advent-of-code/commit/fef153411fe0bfe0e7d5f2d07da80bcaa18c952c :::
Not really spoilery details: Revolves around spawing mutiple jq instances and filtering the inputs bassed on a modulo of number of instances:
# Option to run in parallel using xargs
# Eg: ( seq 0 9 | \
# xargs -P 10 -n 1 ./2023/jq/12-b.jq input.txt --argjson s 10 --argjson i \
# ) | jq -s add
# Execution time 17m10s -> 20s
if $ARGS.named.s and $ARGS.named.i then #
[inputs] | to_entries[] | select(.key % $ARGS.named.s == $ARGS.named.i) | .value / " "
else
inputs / " "
end
I use JQ at work, and never really needed this, i guess this trick is nice to have under the belt just in case.
19 was a real pain in dart.
Intimidating at first, so I went shopping for christmas presents first, which engaged my brain juices.
My part b code ran slower :(
day 1
part 1
part 2
Also Lemmy is eating my < characters inside code blocks, which seems wrong. Pretend the "&lt;>" part says "<>", lol
lemme is an incredibly hungry little shit, it eats so much
day 2
Found this much easier than day 1 honestly...