Minimum Moves to Reach Target Score - Practice Coding Problems

Minimum Moves to Reach Target Score - Problem

Math Greedy Medium

Imagine you're playing a strategic number-building game! 🎮 You start with the humble integer 1 and need to reach a target number using the most efficient strategy possible.

You have two types of moves available:

Increment: Add 1 to your current number (x = x + 1) - unlimited uses ➕
Double: Multiply your current number by 2 (x = 2 × x) - limited to maxDoubles uses only! ⚡

Your mission is to find the minimum number of moves needed to transform 1 into your target number. Since doubling is more powerful but limited, you'll need to use it strategically!

Example: To reach target = 19 with maxDoubles = 2:
1 → 2 (double) → 4 (double) → 8 (increment) → 9 → ... → 19
Total: 17 moves

Input & Output

example_1.py — Basic Case

$ Input: target = 5, maxDoubles = 0

› Output: 4

💡 Note: Since we can't use any doubles, we must increment 4 times: 1 → 2 → 3 → 4 → 5. Total: 4 moves.

example_2.py — Strategic Doubling

$ Input: target = 19, maxDoubles = 2

› Output: 7

💡 Note: Optimal path: 1 → 2 (double) → 4 (double) → 8 → 9 → 10 → 11 → 12 → 13 → 14 → 15 → 16 → 17 → 18 → 19. But more efficient: working backwards gives us 7 moves total.

example_3.py — Edge Case

$ Input: target = 1, maxDoubles = 3

› Output: 0

💡 Note: We're already at the target! No moves needed.

Constraints

1 ≤ target ≤ 10⁹
0 ≤ maxDoubles ≤ 100
Target is always reachable with given constraints

Visualization

Tap to expand

Odd altitude: Must walk down (-1)🚠 Even + lifts: Take express (÷2)🚶‍♂️ Even + no lifts: Walk remaining✅ Total moves: 7 steps⚡ Time complexity: O(log n)💾 Space complexity: O(1)Walk pathExpress lift

Understanding the Visualization

Start at Summit

Begin at the target altitude and plan your descent

Odd Heights → Walk

If you're at an odd height, you must have walked up the last step, so walk down

Even Heights → Lift Decision

If you're at an even height and have lift tickets, you probably took a lift to get there

No Lifts → Walk All

When out of lift tickets, you must walk the remaining distance

Reach Base

Count total steps taken to reach base camp (altitude 1)

Key Takeaway

🎯 Key Insight: Working backwards with greedy choices (walk down from odd heights, take lifts from even heights when available) gives us the optimal O(log n) solution!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a greedy reverse-engineering approach. Instead of working forward from 1, we work backwards from the target. The key insight is: if a number is odd, we must have reached it by incrementing (subtract 1). If it's even and we have doubles left, we likely reached it by doubling (divide by 2). This gives us O(log target) time complexity and O(1) space - much more efficient than BFS approaches!

Common Approaches

Approach	Time	Space	Notes
✓ Greedy + Reverse Engineering (Optimal)	O(log target)	O(1)	Work backwards from target, greedily choosing when to use doubles
Brute Force (BFS/Dynamic Programming)	O(target × maxDoubles)	O(target × maxDoubles)	Try all possible sequences of operations using BFS or memoized recursion

Greedy + Reverse Engineering (Optimal) — Algorithm Steps

Start from the target and work backwards to 1
If current number is odd, we must have reached it by incrementing, so subtract 1
If current number is even and we have doubles left, we likely reached it by doubling, so divide by 2
If current number is even but no doubles left, we must increment backwards
Count total moves until we reach 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Target

Begin at target=19, maxDoubles=2

Odd → Subtract

19 is odd, so 19→18 (1 move)

Even + Doubles → Divide

18 is even, have doubles: 18→9 (1 move, 1 double used)

Continue Pattern

9→8→4→2→1 using optimal choices

Code -

solution.c — C

#include <stdio.h>

int minMovesToReachTarget(int target, int maxDoubles) {
    int moves = 0;
    int current = target;
    
    while (current > 1) {
        if (current % 2 == 1) {
            // Odd number - must have been reached by incrementing
            current -= 1;
            moves += 1;
        } else if (maxDoubles > 0) {
            // Even number with doubles available
            current /= 2;
            maxDoubles -= 1;
            moves += 1;
        } else {
            // No doubles left - increment backwards
            moves += current - 1;
            break;
        }
    }
    
    return moves;
}

int main() {
    int target, maxDoubles;
    scanf("%d %d", &target, &maxDoubles);
    printf("%d\n", minMovesToReachTarget(target, maxDoubles));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log target)

In the best case, we halve the target in each step. Worst case is when we can only increment, giving O(target), but typically much faster

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables to track current position, moves, and remaining doubles

✓ Linear Space

42.0K Views

High Frequency

~15 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy + Reverse Engineering (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler