Minimum Number of Operations to Make X and Y Equal

Minimum Number of Operations to Make X and Y Equal - Problem

You are given two positive integers x and y. Your goal is to transform x into y using the minimum number of operations.

In each operation, you can perform exactly one of the following actions on x:

Divide by 11: If x is divisible by 11, you can set x = x / 11
Divide by 5: If x is divisible by 5, you can set x = x / 5
Decrement: Set x = x - 1
Increment: Set x = x + 1

Return the minimum number of operations required to make x equal to y.

Example: If x = 26 and y = 1, you could: increment to 27, divide by 3 (not allowed), or decrement to 25, divide by 5 to get 5, decrement to 4, 3, 2, 1. But there might be a shorter path!

Input & Output

example_1.py — Basic Case

$ Input: [26, 1]

› Output: 5

💡 Note: 26 → 25 (decrement) → 5 (divide by 5) → 4 (decrement) → 3 (decrement) → 2 (decrement) → 1 (decrement). Total: 5 operations. Alternative paths exist but this is optimal.

example_2.py — Division by 11

$ Input: [54, 2]

› Output: 4

💡 Note: 54 → 55 (increment) → 5 (divide by 11) → 4 (decrement) → 3 (decrement) → 2 (decrement). Total: 4 operations using the divide by 11 operation.

example_3.py — Simple Case

$ Input: [25, 30]

› Output: 5

💡 Note: Since x < y, we can only increment. 25 → 26 → 27 → 28 → 29 → 30. Total: 5 operations (simple increments).

Constraints

1 ≤ x, y ≤ 10⁴
x and y are positive integers
At most one operation per step

Visualization

Tap to expand

Understanding the Visualization

Start at room X

Begin your journey at the starting number

Explore neighbors

Use all available moves: divide (if possible) or increment/decrement

Mark visited rooms

Avoid revisiting the same number to prevent infinite loops

Find target Y

Return the number of moves when you first reach the target

Key Takeaway

🎯 Key Insight: BFS guarantees the shortest path because it explores all possibilities at distance k before exploring distance k+1. The division operations act as 'express routes' that can dramatically reduce the number of steps needed.

Asked in

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

The optimal solution uses BFS (Breadth-First Search) to find the shortest transformation path. Since each operation has equal cost, BFS guarantees we find the minimum number of operations. The key insight is treating this as a shortest path problem in an unweighted graph where states are numbers and edges are operations. We optimize by limiting the search space and using a visited set to avoid cycles.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Shortest Path (Optimal)	O(V + E)	O(V)	Use breadth-first search to find the shortest transformation sequence

BFS Shortest Path (Optimal) — Algorithm Steps

Initialize a queue with starting value x and distance 0
Use a set to track visited states to avoid cycles
For each state, try all four operations and add valid results to queue
Return the distance when we first reach target y
Optimize by limiting search space to reasonable bounds

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize queue

Start with x at distance 0

Process level 1

All states reachable in 1 operation

Process level 2

All states reachable in 2 operations

Find target

Return distance when target is found

Code -

solution.c — C

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

#define MAX_QUEUE 100000
#define HASH_SIZE 50000

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

State queue[MAX_QUEUE];
int front = 0, rear = 0;
bool visited[HASH_SIZE];

void enqueue(int value, int ops) {
    queue[rear].value = value;
    queue[rear].ops = ops;
    rear++;
}

State dequeue() {
    return queue[front++];
}

bool isEmpty() {
    return front >= rear;
}

int hash_function(int key) {
    return abs(key) % HASH_SIZE;
}

int minimumOperationsToMakeEqual(int x, int y) {
    if (x <= y) return y - x;
    
    // Initialize
    front = rear = 0;
    for (int i = 0; i < HASH_SIZE; i++) {
        visited[i] = false;
    }
    
    enqueue(x, 0);
    visited[hash_function(x)] = true;
    
    while (!isEmpty()) {
        State current = dequeue();
        
        if (current.value == y) return current.ops;
        
        int candidates[4];
        int count = 0;
        
        if (current.value % 11 == 0) {
            candidates[count++] = current.value / 11;
        }
        
        if (current.value % 5 == 0) {
            candidates[count++] = current.value / 5;
        }
        
        candidates[count++] = current.value + 1;
        candidates[count++] = current.value - 1;
        
        int maxBound = (x > y ? x : y) + 20;
        
        for (int i = 0; i < count; i++) {
            int nextVal = candidates[i];
            int hash_idx = hash_function(nextVal);
            
            if (nextVal >= 0 && nextVal <= maxBound && !visited[hash_idx]) {
                visited[hash_idx] = true;
                enqueue(nextVal, current.ops + 1);
            }
        }
    }
    
    return -1;
}

int main() {
    int x, y;
    scanf("[%d,%d]", &x, &y);
    printf("%d\n", minimumOperationsToMakeEqual(x, y));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Where V is the number of reachable states and E is the number of transitions. In practice, bounded by our search space optimization.

✓ Linear Growth

Space Complexity

O(V)

Space for queue and visited set, proportional to number of unique states explored

✓ Linear Space

43.4K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 Shortest Path (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler