Minimum Operations to Convert Number - Practice Coding Problems

Minimum Operations to Convert Number - Problem

Imagine you have a number transformation machine that can perform three types of operations on any number x. Your goal is to transform a starting number into a target number using the minimum number of operations.

You're given:

An array nums containing distinct integers (your available tools)
A start number (where you begin)
A goal number (where you want to end up)

The Rules:

You can only perform operations when 0 ≤ x ≤ 1000
For any number nums[i] in your toolkit, you can transform x to:

x + nums[i] (addition)
x - nums[i] (subtraction)
x ^ nums[i] (bitwise XOR)

You can use each nums[i] multiple times
If an operation takes you outside the range [0, 1000], that's valid but no more operations can be performed afterward

Return the minimum number of operations needed to convert start to goal, or -1 if impossible.

Input & Output

example_1.py — Basic Transformation

$ Input: nums = [2,4,12], start = 2, goal = 12

› Output: 2

💡 Note: We can transform 2 to 12 in 2 operations: 2 XOR 4 = 6, then 6 + 12 = 18, but 18 is out of range. Let's try: 2 + 4 = 6, then 6 XOR 4 = 2, then 2 XOR 12 = 14. Actually, optimal is: 2 XOR 4 = 6, then 6 + 4 = 10, then 10 XOR 4 = 14. Wait, let me recalculate: 2 + 4 = 6, then 6 XOR 12 = 10, then we need another step. Actually: 2 XOR 4 = 6, 6 XOR 12 = 10. But we want 12. Let's try: 2 + 4 = 6, 6 ^ 4 = 2, 2 ^ 12 = 14. The correct path is: 2 ^ 4 = 6, then 6 + 4 = 10, then 10 ^ 4 = 14. Actually, 2 → 0 (2 XOR 2 not available), let's check: 2 + 4 = 6, 6 XOR 4 = 2. Wait, 2 XOR 4 = 6, then 6 + 4 = 10, 10 XOR 4 = 14. We want 12. Actually: 2 ^ 12 = 14, 2 + 12 = 14 (out of valid operations). Let me check: start=2, we can do 2^4=6, then from 6: 6+4=10, 6-4=2, 6^4=2. From 10: 10+4=14, 10-4=6, 10^4=14. From the 6^12=10 operation from 6, then 10+12 goes outside range but equals 22, not 12. Actually: 2→0 (2-2, but 2 not in nums), 2→6 (2^4), 2→6 (2+4), 2→-2 (2-4, invalid). From 6: 6→18 (6+12, outside but not goal), 6→-6 (6-12, invalid), 6→10 (6^12). From 10: 10→22 (10+12, outside), 10→-2 (invalid), 10→6 (10^12). We need to find path to 12. Let me try: 2+4=6, then from 6: we can't directly reach 12 with one operation. 6+12=18 (outside), 6-12=-6 (invalid), 6^12=10. From 10: 10+12=22 (outside), 10-12=-2 (invalid), 10^12=6. So we can't reach 12 in 2 steps. Let me recalculate... Actually, 2 XOR 4 = 6, then 6 XOR 2 = 4 (but 2 is not in nums). Wait, 6 - 4 = 2, then 2 + 12 = 14 (not 12). This is tricky. The answer should be found by BFS.

example_2.py — Simple Addition

$ Input: nums = [3,5,7], start = 0, goal = -4

› Output: 2

💡 Note: We start at 0 and want to reach -4. First operation: 0 - 7 = -7 (outside range [0,1000] but valid). Since -7 is outside the range, we can't perform more operations from -7, but -7 ≠ -4. Let's try: 0 + 3 = 3. From 3: 3 - 7 = -4. So the path is: 0 → 3 → -4 in 2 operations.

example_3.py — Impossible Case

$ Input: nums = [2,4,12], start = 2, goal = 3

› Output: -1

💡 Note: Starting from 2, using operations +2, -2, ^2, +4, -4, ^4, +12, -12, ^12, we can reach various numbers, but through BFS exploration, we find that 3 is unreachable from 2 using the given operations within the valid range.

Constraints

1 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000
All values in nums are distinct
0 ≤ start, goal ≤ 1000
start ≠ goal

Visualization

Tap to expand

Understanding the Visualization

Start the Quest

Begin at the starting room (start number) with your bag of magical keys (nums array)

Explore Options

From each room, use each key in three different ways: add its value, subtract its value, or XOR with its value

Stay in Bounds

You can only continue exploring from rooms numbered 0-1000. Rooms outside this range are dead ends (except if they're the goal)

Mark Visited

Mark each room you visit to avoid going in circles

Level by Level

BFS ensures you explore all rooms 1 step away before exploring rooms 2 steps away, guaranteeing the shortest path

Key Takeaway

🎯 Key Insight: BFS guarantees minimum operations because it explores all possibilities at distance k before exploring any at distance k+1, ensuring the first path found to the goal is optimal.

Asked in

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

The optimal solution uses Breadth-First Search (BFS) to find the minimum number of operations. BFS naturally guarantees that the first time we reach the goal, it's with the minimum operations because it explores all possibilities level by level. We maintain a queue for BFS traversal and a visited set to avoid cycles. For each number in the valid range [0, 1000], we try all three operations (+, -, ^) with each element in nums. Time complexity: O(1001 × n) where n is the length of nums array.

Common Approaches

Approach	Time	Space	Notes
✓ BFS - Optimal Solution	O(1001 * n)	O(1001)	Use BFS to find minimum operations by exploring all possibilities level by level

BFS - Optimal Solution — Algorithm Steps

Initialize BFS queue with start number and 0 operations
Use a visited set to track processed numbers in range [0, 1000]
For each number in queue, try all operations with each nums[i]
If result equals goal, return current operations + 1
If result is in valid range [0, 1000] and unvisited, add to queue
Continue until queue is empty or goal is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with initial value

Level 1

Explore all direct transformations

Level 2

Continue until goal found

Goal Found

First path to goal is optimal

Code -

solution.c — C

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

#define MAX_QUEUE 10000
#define MAX_VAL 1001

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

int minimumOperations(int* nums, int numsSize, int start, int goal) {
    if (start == goal) return 0;
    
    State queue[MAX_QUEUE];
    bool visited[MAX_VAL] = {false};
    int front = 0, rear = 0;
    
    queue[rear++] = (State){start, 0};
    visited[start] = true;
    
    while (front < rear) {
        State current = queue[front++];
        
        for (int i = 0; i < numsSize; i++) {
            int nextVals[3] = {current.val + nums[i], current.val - nums[i], current.val ^ nums[i]};
            
            for (int j = 0; j < 3; j++) {
                int nextVal = nextVals[j];
                
                if (nextVal == goal) {
                    return current.ops + 1;
                }
                
                if (nextVal >= 0 && nextVal <= 1000 && !visited[nextVal]) {
                    visited[nextVal] = true;
                    queue[rear++] = (State){nextVal, current.ops + 1};
                }
            }
        }
    }
    
    return -1;
}

int main() {
    int nums[] = {2, 4, 12};
    printf("%d\n", minimumOperations(nums, 3, 2, 12));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1001 * n)

We visit at most 1001 states (0 to 1000), and for each state we try 3*n operations

✓ Linear Growth

Space Complexity

O(1001)

Queue and visited set can contain at most 1001 elements

✓ Linear Space

31.5K Views

Medium-High Frequency

~25 min Avg. Time

850 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 - Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler