Performing the subtraction operation without the subtraction operator in JavaScript

We are required to write a JavaScript function that takes in two numbers and returns their difference but without using the (-) sign.

This problem can be solved using bitwise operations. The key insight is that subtraction can be performed using XOR (^) and AND (&) operations combined with bit shifting.

How It Works

The algorithm uses these bitwise operations:

• XOR (^): Performs subtraction without handling borrows
• AND (&): Identifies positions where borrowing is needed
• Left shift ( Moves borrow positions to the left
• NOT (~): Converts subtraction to addition by negating the second number

Example

Here's the implementation of subtraction without using the minus operator:

const num1 = 56;
const num2 = 78;

const subtractWithoutMinus = (num1, num2) => {
    if(num2 === 0){
        return num1;
    }
    return subtractWithoutMinus(num1 ^ num2, (~num1 & num2) << 1);
};

console.log(subtractWithoutMinus(num2, num1));

22

Step-by-Step Process

Let's trace through how 78 - 56 = 22 works:

const traceSubtraction = (a, b, step = 1) => {
    console.log(`Step ${step}: a=${a}, b=${b}`);
    if(b === 0){
        console.log(`Result: ${a}`);
        return a;
    }
    const xor = a ^ b;
    const borrow = (~a & b) << 1;
    console.log(`  XOR: ${a} ^ ${b} = ${xor}`);
    console.log(`  Borrow: (~${a} & ${b}) << 1 = ${borrow}`);
    return traceSubtraction(xor, borrow, step + 1);
};

traceSubtraction(78, 56);

Step 1: a=78, b=56
  XOR: 78 ^ 56 = 118
  Borrow: (~78 & 56) << 1 = 96
Step 2: a=118, b=96
  XOR: 118 ^ 96 = 22
  Borrow: (~118 & 96) << 1 = 0
Step 3: a=22, b=0
Result: 22

Alternative Approach Using Addition

Another way is to convert subtraction to addition by negating the second number:

const addWithoutPlus = (a, b) => {
    if(b === 0) return a;
    return addWithoutPlus(a ^ b, (a & b) << 1);
};

const negateNumber = (num) => {
    return addWithoutPlus(~num, 1);
};

const subtractUsingAddition = (a, b) => {
    return addWithoutPlus(a, negateNumber(b));
};

console.log(subtractUsingAddition(78, 56)); // 78 - 56
console.log(subtractUsingAddition(100, 25)); // 100 - 25

22
75

Comparison of Methods

Conclusion

Subtraction without the minus operator can be achieved using bitwise operations through recursive XOR and borrow handling. While complex, this demonstrates the fundamental bitwise arithmetic that processors use internally.