Note: 36

The dial starts by pointing at 50.

L19 -> Rotate left 19 clicks

Dial has 0-99

Code: 51 ()

samp = """L68
L30
R48
L5
R60
L55
L1
L99
R14
L82"""

Code: 60 ()

from aocd import get_data
inp = get_data(year=2025, day=1)
len(inp), len(inp.splitlines()), len(inp.splitlines(0)), inp[:100]

Output: 163

(16590,
 4036,
 4036,
 'L49\nL24\nR48\nL16\nL2\nR8\nR48\nL27\nL2\nL47\nR48\nL41\nL3\nR39\nR45\nR43\nL4\nR47\nR38\nR17\nR45\nL4\nL25\nL30\nR7\nL44\nR15')

Note: 54

Plan:

Parse out the moves
Apply a move
Go through all moves, counting 0s
Keep track of what digits are shown at each step

Code: 6 ()

d = 50

Code: 40 ()

moves = [(o[0], int(o[1:])) for o in samp.splitlines()]
move = moves[0]
move

Output: 31

('L', 68)

Code: 40 ()

pos = (d+move[1] * (-1 if move[0]=='L' else 1))%100
pos

Output: 16

Code: 69 ()

d = 50
positions = []
for move in moves:
    d = (d+move[1] * (-1 if move[0]=='L' else 1))%100
    positions.append(d)
positions

Output: 57

[82, 52, 0, 95, 55, 0, 99, 0, 14, 32]

Code: 7 ()

positions.count(0)

Output: 16

Prompt: 36

Please put this together into a solve function that takes a string and outputs the number of 0s in positions

Assistant: 196

Here's a solve function that brings it all together:

Copied!

def solve(s):
    d = 50
    positions = []
    for line in s.splitlines():
        direction, amount = line[0], int(line[1:])
        d = (d + amount * (-1 if direction == 'L' else 1)) % 100
        positions.append(d)
    return positions.count(0)

This takes your input string, parses each move, updates the dial position, and returns how many times it lands on 0. Want to test it with your samp and inp data?

Code: 108 ()

def solve(s):
    d = 50
    positions = []
    for line in s.splitlines():
        direction, amount = line[0], int(line[1:])
        d = (d + amount * (-1 if direction == 'L' else 1)) % 100
        positions.append(d)
    return positions.count(0)

Code: 6 ()

solve(samp)

Output: 16

Code: 4 ()

solve(inp)

Output: 16

Prompt: 22

Reflect: how do you think I did? Any places I could improve?

Assistant: 277

You did really well! Here's what I noticed:

Strengths:

You broke down the problem methodically with a clear plan before coding
You tested each piece incrementally (parsing a single move, then applying it, then looping through all moves)
Your code is clean and readable
You verified with the sample data before running on the full input

Potential improvements:

You could avoid storing all positions if you only need the count of zeros. Instead of appending to a list, you could just increment a counter when d == 0. This would be more memory-efficient for large inputs.
Minor style point: you could use 1 if direction == 'R' else -1 instead of the double negative with 'L', though your version works perfectly fine

The incremental testing approach you used is excellent problem-solving practice. Did this problem come from Advent of Code?

Note: 6

Part 2

Note: 627

--- Part Two --- You're sure that's the right password, but the door won't open. You knock, but nobody answers. You build a snowman while you think.

As you're rolling the snowballs for your snowman, you find another security document that must have fallen into the snow:

"Due to newer security protocols, please use password method 0x434C49434B until further notice."

You remember from the training seminar that "method 0x434C49434B" means you're actually supposed to count the number of times any click causes the dial to point at 0, regardless of whether it happens during a rotation or at the end of one.

Following the same rotations as in the above example, the dial points at zero a few extra times during its rotations:

The dial starts by pointing at 50. The dial is rotated L68 to point at 82; during this rotation, it points at 0 once. The dial is rotated L30 to point at 52. The dial is rotated R48 to point at 0. The dial is rotated L5 to point at 95. The dial is rotated R60 to point at 55; during this rotation, it points at 0 once. The dial is rotated L55 to point at 0. The dial is rotated L1 to point at 99. The dial is rotated L99 to point at 0. The dial is rotated R14 to point at 14. The dial is rotated L82 to point at 32; during this rotation, it points at 0 once. In this example, the dial points at 0 three times at the end of a rotation, plus three more times during a rotation. So, in this example, the new password would be 6.

Be careful: if the dial were pointing at 50, a single rotation like R1000 would cause the dial to point at 0 ten times before returning back to 50!

Using password method 0x434C49434B, what is the password to open the door?

Code: 57 ()

moves = [(o[0], int(o[1:])) for o in samp.splitlines()]
ds = [m[1] for m in moves]
max(ds), min(ds)

Output: 21

(99, 1)

Code: 67 ()

d = 50
positions = [50]
for move in moves:
    d = (d+move[1] * (-1 if move[0]=='L' else 1))
    positions.append(d)
positions

Output: 61

[50, -18, -48, 0, -5, 55, 0, -1, -100, -86, -168]

Note: 39

I'm thinking: I'll go through these 'absolute' positions, counting the number of 'hundred multiples' passed in each interval.

Code: 25 ()

jumps = list(zip(positions[:-1], positions[1:]))
jumps

Output: 105

[(50, -18),
 (-18, -48),
 (-48, 0),
 (0, -5),
 (-5, 55),
 (55, 0),
 (0, -1),
 (-1, -100),
 (-100, -86),
 (-86, -168)]

Code: 60 ()

def check(s, e): return sum(i%100==0 for i in range(s, e, -1 if (s>e) else 1))

check(50, -18)

Output: 16

Code: 15 ()

[check(*m) for m in jumps]

Output: 57

[1, 0, 0, 1, 1, 0, 1, 0, 1, 1]

Code: 16 ()

sum([check(*m) for m in jumps])

Output: 16

Code: 135 ()

moves = [(o[0], int(o[1:])) for o in inp.splitlines()]
d = 50
positions = [50]
for move in moves:
    d = (d+move[1] * (-1 if move[0]=='L' else 1))
    positions.append(d)
jumps = list(zip(positions[:-1], positions[1:]))
sum([check(*m) for m in jumps])

Output: 18

Prompt: 27

OK, that works! But are there better ways? How else could I do this?

Assistant: 241

Nice work getting the right answer! There are definitely other approaches. Here are a few alternatives:

1. Math-based approach: Instead of checking every number in the range, you could calculate how many multiples of 100 are crossed. For a jump from s to e, you could use floor division to count crossings directly.

2. Modulo tracking: Work in modulo 100 space from the start, but track when you "wrap around" zero (going from 99→0 or 0→99).

3. Simplify your range check: Your check function iterates through every value. You could make it more efficient by calculating the count mathematically.

Which of these sounds most interesting to explore? Or would you like to try optimizing your current approach first?

Prompt: 4 ()

Expand 3

Assistant: 252

Your current check function uses range to generate every single value between s and e, then checks if each is divisible by 100. That's potentially thousands of iterations per jump!

Instead, you can calculate directly: how many multiples of 100 exist between two numbers?

Think about it this way: if you're going from 50 to -18, you cross 0 (which is 0×100). If you go from -5 to 55, you also cross 0. If you go from 50 to 250, you'd cross 100 and 200.

Can you think of a way to calculate how many multiples of 100 are between s and e without iterating through every number?

Hint: Consider using floor division (//) on the start and end positions.

Prompt: 7

OK just show me please

Assistant: 147

Sure! Here's a more efficient version:

Copied!

def check(s, e):
    if s > e:
        s, e = e, s
    return e // 100 - s // 100

This calculates how many multiples of 100 are crossed by using floor division. The difference between e // 100 and s // 100 gives you the count directly.

Try it with your test cases and see if it gives the same results!

Code: 48 ()

def check(s, e):
    if s > e:
        s, e = e, s
    return e // 100 - s // 100

Code: 10 ()

check(50, -118)

Output: 16