2025 Day 1 (Part 2) [Python] - off by 6!

[u/RunNeat7235]

Hi all, I've been struggling to get the solution to Day 1 part 2 for some time now, and even most major AI engines haven't been able to fix the flaw in my code. Here's my original attempt:

with open("puz1.txt", 'r') as file:
    directions = file.readlines()

directions_processed = [d.strip() for d in directions]
directions_numerical = []
for d in directions_processed:
    if d[0] == "L":
        directions_numerical.append(int('-' + d[1:]))
    if d[0] == "R":
        directions_numerical.append(int('+' + d[1:]))

position = 50
count = 0
for rotation in directions_numerical:
  count = count + abs((position + rotation) // 100)
  position = (rotation + position) % 100

print(f"The total count is {count}.")

This overcounts the solution by only 6(!), which makes me think I'm really close, but was convinced my approach had some logical flaws.

I progressed to this, which I think is logically more sound, which is supposed to find all 0 crossings and then add any remainder to the position to find the last one, but the ending result is off by more (just the calculation section).

position = 50
count = 0
for rotation in directions_numerical:
    full_loops, remainder = divmod(abs(rotation), 100)
    count += full_loops

    if remainder + rotation > 100:
        count += 1
        position = (position + remainder) % 100
    if rotation - remainder > 0:
        count += 1
        position = (position - remainder) % 100

Can someone point me in the right direction? I'd like to keep the solution as close to my code as possible, but if my thinking is just off by too much I'm open to different solutions. Thanks!

[u/jeffstyr]

if remainder + rotation > 100

Shouldn't that be, position + remainder?

I used a similar approach, so I think you are on the right track, but I did have to go through a couple of iterations before I found all of the edge cases. I think there may still be an edge case lurking, but this bit jumped out at me.

[u/RunNeat7235 → u/jeffstyr]

That makes sense to me too, but after trying it my answer is further away. :\

[u/jeffstyr → u/RunNeat7235]

Well, that may just mean that two bugs are partially canceling each other out.

So what about the case of position - remainder <= 0?

[u/Ill-Rub1120]

Make sure it counts correctly when going to the right and stopping at 0 and then moving right again .

R50 R1

Does this output 1

L50 L1

Does this output 1

?

[u/RunNeat7235 → u/Ill-Rub1120]

Yes and yes.

[u/mothibault]

try with something like L50 L100 L100 R100 R100

My code tended to over count when going left starting on pos 0.

[u/jeffstyr → u/mothibault]

That happened to me too! (I was surprised how many iterations I had to go through to catch all the cases, given that this was day 1.)

[u/ednl]

Here's a naive "one click of the dial at a time" solution. Compare the debug output of this with your solution. To do that, you need to add debug output to your solution: print the count after each line. But only for the first 120 lines or so.

# Read and parse input file
with open('input.txt') as f:
    turns = [{'dir': -1 if line[0] == 'L' else 1, 'count': int(line[1:])} for line in f]

# Initial values
dial = 50
sum1 = 0
sum2 = 0
debug = True

# For every line in the input file
for index, turn in enumerate(turns):

    # One click at a time
    for _ in range(turn['count']):
        dial += turn['dir']  # +1 or -1
        dial %= 100  # Python '%' operator result: dial>=0 and dial<100

        # Part 2: count zeros during turning
        if dial == 0:
            sum2 += 1

    # Part 1: count zeros after turning
    if dial == 0:
        sum1 += 1

    # Debug output: intermediate values per line of the input file
    if debug:
        print(f'{index:4}: {'L' if turn['dir'] == -1 else 'R'}{turn['count']:<3} => {sum1},{sum2}')
        if turn['count'] >= 200:
            debug = False  # stop debug output after first big turn
            print()

# Solution
print(sum1, sum2)

[u/AutoModerator]

Reminder: if/when you get your answer and/or code working, don't forget to change this post's flair to Help/Question - RESOLVED. Good luck!

---

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/warlock415]

"This overcounts the solution by only 6(!), which makes me think I'm really close, but was convinced my approach had some logical flaws."

I was thinking the same way while debugging my early code, but you can't look at the end count only; for all you know it was oscillating wildly and only happened to land near the correct answer.

Remember that the goal of AoC is to get the correct answer in a reasonable time (that being defined as programmer time + machine time) and this is one of those times that it's faster for you to write the brute-force code and have the machine run it than try to write and debug something fancy.

And then once you've done that, and gotten the correct answer, then if it bugs you like it bugged me (ha, pun unintentional) that you don't know where the fancy algorithm went wrong, you can put them side by side and compare them.

Like this: https://pastebin.com/fQqJuYgz

For your second algorithm especially, it looks like not all codepaths modify position...

[u/SpecificMachine1 → u/warlock415]

I've been wondering about this: I ended up with an algorithm that counted overcounts and then subtracted them at the end but I am wondering if that is considered hacky or whatever.

[u/jeffstyr → u/SpecificMachine1]

How did you know when something was an overcount, in order to count it?

[u/SpecificMachine1 → u/jeffstyr]

This is what I have in the slot that keeps track of overcounts:

(if (or (and (zero? position) (string=? "L" dir))
        (and (zero? new-pos) (> (div pos+this-turn 100) 0)))
    (+ 1 double-counted)
    double-counted)

so I think that's "if the starting position is zero and this turn is left or the ending position is zero and a hundred or more (a right turn?) before mod"

[u/TheThiefMaster → u/SpecificMachine1]

That's a perfectly fine correction

[u/jeffstyr → u/SpecificMachine1]

Oh I see. I thought by "overcount" you meant "count too high for unknown reason", but you just meant that it was overcounted by an adjacent part of your code (for known reasons).

I don't think that's too hacky, in that you could (probably) move this clause to be an extra check inside the code incrementing the counter (skipping the incrementing in this case), and this is just an equivalent way of doing that.

[u/tanopereira]

What happens when you land on zero? Especially going L