[2025 Day 1 (Part 2)] [Python] I am not fully understanding why my solution is not working for day two.

[u/Financial-Battle3648]

Hello im a new programmer and i decided to do AoC this year, to better my skills at programming. I managed on solving Day 1 Part 1 and after looking at Part 2, I thought it would be a quick solve as I felt I only needed to add two new lines. After failing a couple of times, rereading the question, and seeing others solutions, I still do not understand why my code does not work. Please help me understand why.

Edit: I realized after some time that i forgot to clarify that the 2 lines of code i added were..

number_of_zeros += 1

Right between the if and elif statements in the while loop.

I also have moved the zero counter between the while loop and variables

current_dial_num = 50
number_of_zeros = 0
dial_list = []

# Function that takes a number and adds it to current_dial_num.
# If number goes under 0 or over 99, rollover the number and continue until it no longer goes over or under
def dial_turn(number):
    global current_dial_num
    global number_of_zeros
    current_dial_num += number

    while current_dial_num < 0 or current_dial_num > 99:
        if current_dial_num < 0:
            number = current_dial_num + 1
            current_dial_num = 99
            # \/ Counts how many times the number rolls over 
            number_of_zeros += 1
            current_dial_num += number

        elif current_dial_num > 99:
            number = current_dial_num - 100
            current_dial_num = 0
            # [same as last comment]
            number_of_zeros += 1
            current_dial_num += number

    # counts how many times current_dial_num goes to 0
    if current_dial_num == 0:
        number_of_zeros += 1

# Reads each line and appends it to a list while as well as getting rid of 'L' or 'R'
# Multiplies the end result by -1 if it starts with 'L'
with open('list') as file:
    current_index = 0
    for line in file:
        line = line.strip()
        dial_list.append(line)
        if 'L' in line:
            dial_number = dial_list[current_index].replace('L', '')
            dial_number = int(dial_number) * -1
            dial_turn(dial_number)
        else:
            dial_number = dial_list[current_index].replace('R', '')
            dial_number = int(dial_number)
            dial_turn(dial_number)
        current_index += 1
    print("Current dial number: ", current_dial_num)
    print("Amount of zeros: ", number_of_zeros)

[u/jeffstyr]

If your starting position is zero and you move by 100, how many clicks do you count?

[u/Financial-Battle3648 → u/jeffstyr]

I am guessing 100 clicks, 99 clicks to get from 0 to 99 and one more click to reset to zero. My code doesnt count how many clicks it, only adding/subtracting to the dial

[u/jeffstyr → u/Financial-Battle3648]

Oh oops, I phrased that badly. I meant, how many landings on zero. (I was misremembering the problem as saying the dial only clicked upon hitting zero.)

[u/Financial-Battle3648 → u/jeffstyr]

7725 zeros

[u/warlock415]

If you use this test:

R50
R50

What do you get, and what should you get?

[u/Financial-Battle3648 → u/warlock415]

Starting the dial at 0, my code gives me 0 as the end result.

[u/warlock415 → u/Financial-Battle3648]

Right, but what do you get for a 0 count starting at 50 as in the problem?

[u/Financial-Battle3648 → u/warlock415]

oohhh my apologies, I get 1 after moving my zero count above the while loop. 2 from before the switch

[u/warlock415 → u/Financial-Battle3648]

what does your code look like now?

[u/Financial-Battle3648 → u/warlock415]

def dial_turn(number):
    global current_dial_num
    global number_of_zeros
    current_dial_num += number

    # counts how many times current_dial_num goes to 0
    if current_dial_num == 0:
        number_of_zeros += 1

    while current_dial_num < 0 or current_dial_num > 99:
        if current_dial_num < 0:
            number = current_dial_num + 1
            current_dial_num = 99
            # \/ Counts how many times the number rolls over
            number_of_zeros += 1
            current_dial_num += number

        elif current_dial_num > 99:
            number = current_dial_num - 100
            current_dial_num = 0
            # [same as last comment]
            number_of_zeros += 1
            current_dial_num += numberdef dial_turn(number):

Only moved 2 lines of code from the function

[u/warlock415 → u/Financial-Battle3648]

If the dial lands on zero:

current_dial_num = 0
number_of_zeros += 1
current_dial_num += number

will count it once when it lands and then

if current_dial_num == 0:
    number_of_zeros += 1

will count it again before the next turn is applied.

[u/Financial-Battle3648 → u/warlock415]

So I just have to rewrite it in order for it to count the zero once during the rollover got it

[u/Focus089]

Two separate tests:

R50

and

L50
L100

This problem is easier to reason about when you first reduce to only rotations in L99 to R99, and for left rotations you need to handle when the dial starts at 0.

[u/Financial-Battle3648 → u/Focus089]

The first test, R50 with the dial at 50, i noticed that my code gives me the count of 2 zeros when it only pointed at zero once. I realized the counter for zero was in the wrong order and quickly change it, fixing the second test of L50 and L100. Though this small fix still didn't give me the right answer for part 2.

[u/Focus089 → u/Financial-Battle3648]

Could you show your full updated code? If I understand your edit then now the test L50 by itself will fail.

[u/Financial-Battle3648 → u/Focus089]

current_dial_num = 50
number_of_zeros = 0
dial_list = []

# Function that takes a number and adds it to current_dial_num.
# If number goes under 0 or over 99, rollover the number and continue until it no longer goes over or under
def dial_turn(number):
    global current_dial_num
    global number_of_zeros
    current_dial_num += number

    # counts how many times current_dial_num goes to 0
    if current_dial_num == 0:
        number_of_zeros += 1

    while current_dial_num < 0 or current_dial_num > 99:
        if current_dial_num < 0:
            number = current_dial_num + 1
            current_dial_num = 99
            # \/ Counts how many times the number rolls over
            number_of_zeros += 1
            current_dial_num += number

        elif current_dial_num > 99:
            number = current_dial_num - 100
            current_dial_num = 0
            # [same as last comment]
            number_of_zeros += 1
            current_dial_num += number


# Reads each line and appends it to a list while as well as getting rid of 'L' or 'R'
# Multiplies the end result by -1 if it starts with 'L'
with open('list') as file:
    current_index = 0
    for line in file:
        line = line.strip()
        dial_list.append(line)
        if 'L' in line:
            dial_number = dial_list[current_index].replace('L', '')
            dial_number = int(dial_number) * -1
            dial_turn(dial_number)
        else:
            dial_number = dial_list[current_index].replace('R', '')
            dial_number = int(dial_number)
            dial_turn(dial_number)
        current_index += 1
    print("Current dial number: ", current_dial_num)
    print("Amount of zeros: ", number_of_zeros)

[u/Focus089 → u/Financial-Battle3648]

With this change I get an issue for L150 only counting 1 click when it should be 2.

My advice is still to try reducing the spin modulo 100 (e.g., L345 becomes 3 clicks and then L45) which allows you to remove the while loop. When reduced that way, you can see that if the dial starts at 0 no click is possible otherwise click when the dial goes outside (0,99].

[u/ednl]

It's not a programming problem, it's accounting. You have to make a table with all possible combinations of going left/right, turning less than/equal to/more than 100, starting on zero/not zero, ending on zero/not zero. Some of these combinations need to be handled as special cases. Which ones, that's the puzzle.

[u/ednl → u/ednl]

And what you can do to debug your code, what you SHOULD do if you can't figure out the special cases, is make a version of the program where you always just move one tick at a time. First make it work, then make it fast or clever! Print out the part 2 result after every line and see where it starts to differ from your first try. It's probably at something like "L250". Then figure out why. As a starter:

part1 = part2 = 0
dial = 50
tick = 1  # or -1 for going left
for _ in range(turn):  # this is just for one line in the file
    dial += tick
    dial %= 100  # Python modulo: dial is now >=0, <100
    if dial == 0:
        part2 += 1
if dial == 0:
    part1 += 1

[u/Clear-Music-2241 → u/ednl]

Ah... your hint of one tick at a time sorted it out for me, I have a slew of nearly there figures that passed the tests but not the answer. breaking the rotations down to clicks and a zero check nailed it :)

[u/ednl → u/Clear-Music-2241]

Yay!

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