this post was submitted on 01 Dec 2023
18 points (100.0% liked)

NotAwfulTech

465 readers
1 users here now

a community for posting cool tech news you don’t want to sneer at

non-awfulness of tech is not required or else we wouldn’t have any posts

founded 2 years ago
MODERATORS
 

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.

(page 2) 50 comments
sorted by: hot top controversial new old
[–] swlabr@awful.systems 3 points 1 year ago* (last edited 1 year ago) (3 children)

Day 20: Pulse Propagation

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

a,bA

So following from yesterday where I was punished by not going full OO, I decided, hey, this is a problem in which I can do some OOP, so I did. This took very long to do but I regret nothing. If you look at my code, feel free to click your tongue and shake your head at every opportunity I missed to use a design pattern.

Anyway, after a slight snafu with misunderstanding the FF logic and not spotting that some modules can be dummy modules, it all just worked, and I got my answer.

B

This was a bit of a headscratcher, but the answer was surprisingly simple.

First, the answer. Here's how to do it:

  • Look for the "rx" module in your input.
  • If the module that outputs to rx is a conjunction, keep track of how many button presses it takes for each input of the conjunction to change. The answer is the LCM of all those numbers.
  • If the module is a FF, you can also work backwards to get it, but this was not my input so I didn't need to try this.

Getting here was a bit weird. I hoped that I could just run the code from A and spit out the answer when rx went low, but as of time of writing I've been running it now on a separate machine for about an hour and still no result.

My next instinct was to simply work it out from pen and paper. I thought it might be possible (it probably is) but decided to at least experimentally see if the states of the modules connected to rx were cyclic first. I did, and that was enough for me to get to the answer.

My answer was about 230 trillion BPs, which, extrapolating on how long execution is taking on my other machine, might take just under 137 years to calculate naively. Fun!

[–] zogwarg@awful.systems 3 points 1 year ago

[Language: jq]https://github.com/zogwarg/advent-of-code/blob/main/2023/jq/20-b.jq

Completed when waiting for the second leg of my Christmas holidays flight. (It was a long wait, can I blame jet-lag?).

Have a more compact implementation of LCM/GCD, something tells me it will come in handy In future editions. (I’ve also progressively been doing past years)

load more comments (2 replies)
[–] swlabr@awful.systems 3 points 1 year ago* (last edited 1 year ago) (4 children)

21 Step Counter

Starting this thread having only solved a.

APretty straightforward. Could probably be done in a few lines with the right syntactic sugar.

BThis is some game of life thing that I've never implemented or seen an implementation of, so I am altogether lost.

My current code (https://github.com/Fluxward/aoc2023/blob/main/21.dart) has a memoisation based approach but my current ailments are preventing me from really thinking about this properly so I am bowing out until I have the wherewithal.

[–] gerikson@awful.systems 3 points 1 year ago (1 children)

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

load more comments (1 replies)
[–] zogwarg@awful.systems 3 points 1 year ago

Only solved by receving heavy hints from other's solution, and it still took me forever. By far the hardest this year.

load more comments (2 replies)
[–] swlabr@awful.systems 3 points 1 year ago (2 children)

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.

[–] gerikson@awful.systems 3 points 1 year ago (1 children)

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!

load more comments (1 replies)
[–] zogwarg@awful.systems 3 points 1 year ago

Happy holidays!

[–] froztbyte@awful.systems 3 points 2 years ago (1 children)

rule 5: one code enters, 7 codes leave

[–] froztbyte@awful.systems 3 points 2 years ago* (last edited 2 years ago) (1 children)

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:

spoiler

import re

pattern = '\d'
cmp = re.compile(pattern)

# extremely lazy, of the ungood kind
datapath = 'data'
lines = open(datapath, 'r').read().split('\n')
candidates = []
values = []
for l in lines:
    if l != '':
        r = cmp.findall(l)
        candidates.append(r)
        values.append(int(''.join([r[0], r[-1]])))

print(candidates)
print(values)
print(sum(values))

(I really wasn't kidding about the badly)

part2:

spoilermissed the eightwo case

changes:

mapping = {...} # name/int pairs
pattern = f'(?=(\d|{"|".join(mapping.keys())}))'
lines = open(datapath, 'r').read().split('\n').remove('')
values = []
for l in lines:
    r = cmp.findall(l)
    equivs = [str(mapping.get(x, x)) for x in r]
    head, tail = [equivs[0], equivs[-1]]
    values.append(int(f"{head}{tail}"))
print(sum(values))

load more comments (1 replies)
[–] gerikson@awful.systems 3 points 2 years ago
[–] gerikson@awful.systems 3 points 2 years ago* (last edited 2 years ago) (6 children)

Day 5: If You Give A Seed A Fertilizer

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

Leaderboard completion time: 26m37s, so it's the toughest problem this year so far.

load more comments (6 replies)
[–] zogwarg@awful.systems 3 points 2 years ago* (last edited 2 years ago) (1 children)

Day 6: Wait For It

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

Alternate spoiler name - for part 2~~Do you remember highschool algebra?~~ Can you (or your compiler) remember highschool algebra fast enough to beat out a naïve implementation?

[–] gerikson@awful.systems 3 points 2 years ago

nice cleanser after yesterday

spoilerit would have taken me longer to figure out the algebra than to just mush the inputs together and get the solution that way (16s runtime)

[–] sailor_sega_saturn@awful.systems 3 points 2 years ago* (last edited 2 years ago) (1 children)

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

load more comments (1 replies)
[–] gerikson@awful.systems 3 points 2 years ago (1 children)

Day 7: Camel Cards

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.

[–] zogwarg@awful.systems 3 points 2 years ago* (last edited 2 years ago) (7 children)

Day 8: Haunted Wasteland

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

Not so easy at least for part two.

spoilerDo you remember high school math, like lowest common multiple, part 2 electric boogaloo.

load more comments (7 replies)
[–] gerikson@awful.systems 3 points 2 years ago (1 children)

Day 9: Mirage Maintenance

My solution: https://github.com/gustafe/aoc2023/blob/main/d09-Mirage-Maintenance.pl

discussionWhat can I say. Shockingly simple.

I just literally followed the instructions, and got a solution in 20ms. This despite literally creating each intermediate array yet only using the ends. I'm sure I used way to much memory but you know? I'm using a $5/mo VPS for everything and unless I'm barking totally up the wrong tree I've never exceeded its memory limits.

On the subreddit I see people discussing recursion and "dynamic programming" (which is an empty signifier imho) but I really don't see the need, unless you wanna be "elegant"

[–] swlabr@awful.systems 3 points 2 years ago (1 children)

spoilerDP to me is when you use memoisation and sometimes recursion and you want to feel smarter about what you did.

I also struggle to think of the need for DP, even in a more “elegant” approach. Maybe if you wanted to do an O(n) memory solution instead of n^2, or something. Not saying this out of derision. I do like looking at elegant code, sometimes you learn something.

I feel like there’s an unreadable Perl one line solution to this problem, wanna give that a go, @gerikson?

[–] zogwarg@awful.systems 3 points 2 years ago (2 children)

spoilerPart 2 only, but Part 1 is very similar.

#!/usr/bin/env jq -n -R -f
[
  # For each line, get numbers eg: [ [1,2,3] ]
  inputs / " " | map(tonumber) | [ . ] |

  # Until latest row is all zeroes
  until (.[-1] | [ .[] == 0] | all;
   . += [
     # Add next row, where for element(i) = prev(i+1) - prev(i)
     [ .[-1][1:] , .[-1][0:-1] ] | transpose | map(.[0] - .[1])
    ]
  )
  # Get extrapolated previous element for first row
  |  [ .[][0] ] | reverse | reduce .[] as $i (0; $i - . )
]

# Output sum of extapolations for all lines
| add

I'm pretty sure you could make this one line and unreadable ^^.

[–] swlabr@awful.systems 3 points 2 years ago

Now this is content

[–] swlabr@awful.systems 3 points 2 years ago

Here's where I landed in dart

no comments

d9(bool s) {
  print(getLines().fold(0, (p, e) {
    int pre(List h, bool s) {
      return h.every((e) => e == 0)
          ? 0
          : (pre(List.generate(h.length - 1, (i) => h[i + 1] - h[i]), s)) *
                  (s ? -1 : 1) +
              (s ? h.first : h.last);
    }

    return p + pre(stois(e), s);
  }));
}

[–] swlabr@awful.systems 3 points 2 years ago* (last edited 2 years ago) (17 children)

Starting a new comment thread for my solutions to 10-19. Double digits, baby! Code here: https://github.com/Fluxward/aoc2023/

[–] swlabr@awful.systems 3 points 2 years ago (1 children)

11

a,ba: 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.

[–] gerikson@awful.systems 2 points 2 years ago (1 children)

Love ur premature optimization

load more comments (1 replies)
[–] swlabr@awful.systems 3 points 2 years ago (2 children)
  1. I have contracted some kind of sinus infection, so rn I have a -20 IQ debuff.

a,bpart a: nothing to say here.

part b: Before diving into the discussion, I timed how long 1000 cycles takes to compute, and apparently, it would take 1643175 seconds or just over 19 days to compute 1 billion cycles naively. How fun!

So, how do you cut down that number? First, that number includes a sparse map representation, so you can tick that box off.

Second is intuiting that the result of performing a cycle is cyclical after a certain point. You can confirm this after you've debugged whatever implementation you have for performing cycles- run it a few times on the sample input and you'll find that the result has a cycle length of 7 after the second interaction.

Once you've got that figured out, it's a matter of implementing some kind of cycle detection and modular arithmetic to get the right answer without having to run 1000000000 cycles. For the record, mine took about 400 cycles to find the loop.

load more comments (2 replies)
[–] swlabr@awful.systems 3 points 2 years ago (3 children)

a,b, not much to sayThe hardest part has finding the right dart ascii library to use (by default dart treats everything as UTF-16, which is horrible for this sort of thing) and the right data structure (linked hash map, which is a map that remembers insertion order.)

load more comments (3 replies)
[–] swlabr@awful.systems 2 points 2 years ago* (last edited 2 years ago) (2 children)

16So, as I've been doing the AoC things, I've been creating small libraries of convenience functions to reuse, hopefully. This time, I reused some things I wrote for problem 10, which was vindicating.

a. was a fun coding exercise. Not much more to say.

b. I lucked out by making a recursive traversal function for a), which let me specify the entry and direction of where my traversal would start. Besides that, similar to a., this was a fun coding exercise. I was surprised that my code (which just ran the function from a) on every edge tile) It only took 2s to run; I thought I might need to memoize some of the results.

load more comments (2 replies)
load more comments (13 replies)
[–] swlabr@awful.systems 3 points 1 year ago (1 children)

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 :)

[–] gerikson@awful.systems 3 points 1 year ago (1 children)

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?

load more comments (1 replies)
load more comments
view more: ‹ prev next ›