0128MediumMathRecursion

Zoom Stage Multiplier

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 microscope has a motorised zoom stage. One click forward scales the magnification by factor, and one click backward undoes a forward click, so it divides the magnification by factor.

Given factor and a click count clicks, return the multiplier the stage applies overall. A positive clicks means that many clicks forward, a negative clicks means that many clicks backward, and zero clicks leave the magnification alone.

Report the multiplier rounded to 5 decimal places. The click count reaches into the billions, so a routine that turns the stage one click at a time is too slow: the number of multiplications you perform must grow with the logarithm of the click count, not with the count itself.

Examples

Example 1

Input: factor = 3.0, clicks = 4
Output: 81.0

Four forward clicks multiply by 3 four times over, giving 81.

Example 2

Input: factor = 2.5, clicks = -3
Output: 0.064

Three backward clicks divide by 2.5 three times, and 1 / 15.625 is 0.064.

Example 3

Input: factor = -1.5, clicks = 0
Output: 1.0

The stage never moves, so the magnification is untouched and the multiplier is 1.

Constraints

-100.0 < factor < 100.0
-2^31 <= clicks <= 2^31 - 1
clicks is an integer
factor is non-zero, or clicks > 0
-10^4 <= the exact multiplier <= 10^4
The returned value is rounded to 5 decimal places

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 zoom_multiplier(factor: float, clicks: int) -> float:

Java

public double zoomMultiplier(double factor, int clicks)

The intended approach

Time O(log |clicks|)Space O(1)

Work with the click count in binary. Keep a running base that starts at `factor` and squares on each step, so after k steps it holds the multiplier of 2^k forward clicks. Fold the base into the answer exactly on the steps where the count has a one bit, which spends about log2 of the count multiplications. Backward clicks are handled by solving for the same magnitude forward and taking one reciprocal at the end, and the last squaring is skipped so a huge count cannot blow the base up needlessly.

Pythonentry point: zoom_multiplier

def zoom_multiplier(factor, clicks):
    steps = clicks if clicks >= 0 else -clicks
    total = 1.0
    base = float(factor)
    while steps:
        if steps & 1:
            total *= base
        steps >>= 1
        if steps:
            base *= base
    if clicks < 0:
        total = 1.0 / total
    return round(total, 5)

The obvious version

Turn the stage one click at a time, multiplying by `factor` on every step, then invert once if the clicks were backward. Linear in the click count, so it is only usable on small counts, but it needs no binary reasoning at all.

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_zoom_multiplier(factor, clicks):
    steps = clicks if clicks >= 0 else -clicks
    total = 1.0
    for _ in range(steps):
        total *= factor
    if clicks < 0:
        total = 1.0 / total
    return round(total, 5)

How this problem was checked

Reference solution executed against 12 test cases — 12 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