Finding minimum number of required operations to reach n from m in JavaScript

We are required to write a JavaScript function that takes in two numbers, m and n, as the first and the second argument.

Our function is supposed to count the number of minimum operations required to reach n from m, using only these two operations:

• Double ? Multiply the number on the display by 2, or;

• Decrement ? Subtract 1 from the number on the display.

Problem Example

For example, if we need to reach 8 from 5:

const m = 5;
const n = 8;
console.log("Start:", m, "Target:", n);

Start: 5 Target: 8

The minimum operations would be: 5 ? 4 (decrement) ? 8 (double), requiring 2 operations total.

Approach: Reverse Engineering

The key insight is to work backwards from n to m. Instead of doubling or decrementing from m, we can:

• Divide n by 2 (reverse of doubling)
• Add 1 to n (reverse of decrementing)

Algorithm Implementation

const findOperations = (m, n) => {
    let operations = 0;
    
    // Work backwards from n to m
    while (n > m) {
        if (n % 2 === 0) {
            // If n is even, divide by 2 (reverse of double operation)
            n = n / 2;
        } else {
            // If n is odd, add 1 (reverse of decrement operation)
            n = n + 1;
        }
        operations++;
    }
    
    // Add remaining operations to reach exact target
    return operations + (m - n);
};

// Test with the example
const m = 5;
const n = 8;
console.log("Operations needed:", findOperations(m, n));

Operations needed: 2

Step-by-Step Trace

Let's trace through the algorithm with m = 5 and n = 8:

const findOperationsWithTrace = (m, n) => {
    let operations = 0;
    let current = n;
    
    console.log("Starting from", current, "to reach", m);
    
    while (current > m) {
        if (current % 2 === 0) {
            current = current / 2;
            console.log("Step", operations + 1 + ": Divide by 2 ?", current);
        } else {
            current = current + 1;
            console.log("Step", operations + 1 + ": Add 1 ?", current);
        }
        operations++;
    }
    
    const remaining = m - current;
    if (remaining > 0) {
        console.log("Additional operations needed:", remaining);
    }
    
    return operations + remaining;
};

console.log("Total operations:", findOperationsWithTrace(5, 8));

Starting from 8 to reach 5
Step 1: Divide by 2 ? 4
Additional operations needed: 1
Total operations: 2

Testing with Different Examples

const testCases = [
    [5, 8],   // Expected: 2
    [2, 3],   // Expected: 2
    [3, 10],  // Expected: 3
    [1, 1024] // Expected: 10
];

testCases.forEach(([m, n]) => {
    const result = findOperations(m, n);
    console.log(`From ${m} to ${n}: ${result} operations`);
});

From 5 to 8: 2 operations
From 2 to 3: 2 operations
From 3 to 10: 3 operations
From 1 to 1024: 10 operations

Time and Space Complexity

• Time Complexity: O(log n) - We divide n by 2 in most iterations
• Space Complexity: O(1) - Only using a few variables

Conclusion

The reverse engineering approach efficiently finds the minimum operations by working backwards from the target. This greedy strategy always chooses the optimal move at each step, ensuring the minimum number of operations.