Broken Calculator

Broken Calculator - Problem

Math Greedy Medium

There is a broken calculator that has the integer startValue on its display initially. In one operation, you can:

multiply the number on display by 2, or
subtract 1 from the number on display

Given two integers startValue and target, return the minimum number of operations needed to display target on the calculator.

Input & Output

Example 1 — Basic Case

$ Input: startValue = 2, target = 3

› Output: 2

💡 Note: Use operations: 2 × 2 = 4, then 4 - 1 = 3. Total: 2 operations

Example 2 — Target Smaller

$ Input: startValue = 5, target = 8

› Output: 2

💡 Note: Use operations: 5 - 1 = 4, then 4 × 2 = 8. Total: 2 operations

Example 3 — Only Subtraction

$ Input: startValue = 3, target = 10

› Output: 3

💡 Note: Working backwards: 10÷2=5, 5+1=6, 6÷2=3. Total: 3 operations

Constraints

1 ≤ startValue, target ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is to work backwards from target using reverse operations. The optimal approach is reverse greedy: if target is even divide by 2, if odd add 1. Time: O(log target), Space: O(1)

Common Approaches

✓ BFS (Breadth-First Search)

⏱️ Time: O(target) Space: O(target)

Treat this as a graph problem where each number is a node and operations are edges. Use BFS to find the shortest path from startValue to target.

Reverse Greedy

⏱️ Time: O(log target) Space: O(1)

Instead of going forward from start to target, work backwards from target to start. If target is even, divide by 2; if odd, add 1. This greedy choice is always optimal.

BFS (Breadth-First Search) — Algorithm Steps

Start with startValue in queue
For each number, try both operations: *2 and -1
Continue until target is found
Return the number of levels traversed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with startValue in queue

Explore

Try both operations: *2 and -1

Found

Return steps when target is reached

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_SIZE 100000

typedef struct {
    int value;
    int steps;
} State;

int solution(int startValue, int target) {
    if (startValue >= target) {
        return startValue - target;
    }
    
    State queue[MAX_SIZE];
    bool visited[MAX_SIZE] = {false};
    int front = 0, rear = 0;
    
    queue[rear++] = (State){startValue, 0};
    if (startValue < MAX_SIZE) visited[startValue] = true;
    
    while (front < rear) {
        State curr = queue[front++];
        
        if (curr.value == target) {
            return curr.steps;
        }
        
        // Operation 1: multiply by 2
        if (curr.value < target && curr.value * 2 < MAX_SIZE && !visited[curr.value * 2]) {
            visited[curr.value * 2] = true;
            queue[rear++] = (State){curr.value * 2, curr.steps + 1};
        }
        
        // Operation 2: subtract 1
        if (curr.value - 1 > 0 && !visited[curr.value - 1]) {
            visited[curr.value - 1] = true;
            queue[rear++] = (State){curr.value - 1, curr.steps + 1};
        }
    }
    
    return -1;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(target)

In worst case, we might visit all numbers from startValue to target

⚡ Linearithmic

Space Complexity

O(target)

Queue can store up to target number of states in memory

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

BFS (Breadth-First Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler