0064EasyHash TableMathTwo PointersFloyd's Cycle Finding Algorithm

Probe Reading Settles

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A field probe stores one positive integer reading and runs a self-test on it.

On each tick of the self-test the firmware throws away the stored value and writes back a new one: take every decimal digit of the old value, square each digit, and add those squares together.

The probe declares itself healthy as soon as the stored value becomes 1, because 1 maps to itself and the value can never move again. For every other starting value that never lands on 1, the firmware walks around a fixed ring of values and keeps circling it forever.

Given the starting value reading, return true when the self-test eventually declares the probe healthy, and false when the firmware circles forever.

Examples

Example 1

Input: reading = 7
Output: true

The stored value moves 7 -> 49 -> 97 -> 130 -> 10 -> 1, so the probe declares itself healthy on the fifth tick.

Example 2

Input: reading = 4
Output: false

The value walks 4 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4 and is back where it began, so it will circle that ring forever.

Example 3

Input: reading = 1000
Output: true

Only one digit is non-zero, so the very first tick stores 1 and the probe is healthy immediately.

Constraints

1 <= reading <= 2^31 - 1

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def reading_settles(reading: int) -> bool:

Java

public boolean readingSettles(int reading)

The intended approach

Time O(log reading)Space O(1)

Every value has exactly one successor, so the self-test traces a path that either hits 1 or falls into a cycle. Run two cursors over that path, one advancing a single tick per step and one advancing two ticks per step: if the fast cursor reaches 1 the probe is healthy, and if the two cursors land on the same value first the path is a closed ring.

Pythonentry point: reading_settles

def reading_settles(reading):
    def tick(value):
        total = 0
        while value > 0:
            digit = value % 10
            total += digit * digit
            value //= 10
        return total

    slow = reading
    fast = tick(reading)
    while fast != 1 and slow != fast:
        slow = tick(slow)
        fast = tick(tick(fast))
    return fast == 1

The obvious version

Record every value the firmware has stored in a set and stop as soon as a value repeats or 1 shows up.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_reading_settles(reading):
    seen = set()
    current = reading
    while current != 1 and current not in seen:
        seen.add(current)
        total = 0
        for ch in str(current):
            total += int(ch) ** 2
        current = total
    return current == 1

How this problem was checked

Reference solution executed against 10 test cases — 10 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in