Divide Two Integers without using Multiplication, Division and Modulus Operator

You are given two integers: dividend and divisor. Your task is to divide them without using the multiplication (*), division (/) or modulus (%) operators.

You should return the quotient after dividing dividend by divisor, discarding the fractional part.

Assume both numbers are positive and the division is always valid (i.e., divisor is never zero).

Understanding the Problem

We are given two positive integers: dividend and divisor. Our goal is to compute how many times the divisor fits into the dividend — that is, perform integer division — but without using multiplication (*), division (/), or modulus (%) operators.

For example, if dividend = 15 and divisor = 3, the answer should be 5 because 3 fits exactly 5 times into 15.

We are asked to discard the fractional part, which means this is integer division. For example, 10 / 3 should return 3 — not 3.33.

Step-by-Step Solution with Example

step 1: Initialize Result

We start by initializing a variable called result = 0. This will eventually hold our answer — the number of times the divisor fits into the dividend.

step 2: Loop While Dividend ≥ Divisor

As long as the dividend is greater than or equal to the divisor, we will try to subtract some multiple of the divisor from it.

step 3: Use Doubling to Speed Up

We use two variables: temp = divisor and multiple = 1. Now, we try to double temp (i.e., temp = temp << 1) and also double multiple as long as temp << 1 is still less than or equal to the dividend.

This doubling helps us speed up the subtraction by jumping bigger steps instead of subtracting the divisor one at a time.

step 4: Subtract and Add to Result

Once we can’t double further, we subtract temp from dividend, and we add multiple to result.

step 5: Repeat Until Done

We repeat steps 2–4 until the dividend becomes smaller than the divisor.

step 6: Return Result

After the loop, result will hold our answer — the integer quotient.

Example: Divide 15 by 3

• Start with dividend = 15, divisor = 3
• First round of doubling:
  • temp = 3 → 6 → 12 (next would be 24 which is > 15, so stop)
  • multiple = 1 → 2 → 4
• Subtract 12 from 15 → new dividend = 3
• Add 4 to result → result = 4
• Next round: temp = 3, multiple = 1
• 3 ≤ 3, subtract → dividend = 0, result = 5

Final Result: 5

Edge Cases

• Dividend < Divisor: The result is 0 since the divisor doesn’t fit even once.
• Dividend == Divisor: The result is 1 because it fits exactly once.
• Large Inputs: Bit manipulation makes this method efficient even for large values of dividend.

Final Thoughts

This approach avoids the use of multiplication, division, and modulus by using subtraction and efficient bitwise operations like left shift. For beginners, understanding the intuition of "doubling the divisor" is key. It’s like subtracting in chunks — instead of one by one, we remove 2s, 4s, 8s, and so on to reach the target faster.

It's efficient and safe, and a powerful trick to add to your coding toolbox!

1. Initialize a variable result to 0. This will hold the final quotient.
2. While dividend is greater than or equal to divisor:
   • Set temp = divisor and multiple = 1.
   • Keep doubling temp (left shift) and multiple as long as dividend >= (temp << 1).
   • Subtract temp from dividend and add multiple to result.
3. Return result as the final quotient.

#include <stdio.h>

int divide(int dividend, int divisor) {
    int result = 0;
    while (dividend >= divisor) {
        int temp = divisor, multiple = 1;
        while (dividend >= (temp << 1)) {
            temp <<= 1;
            multiple <<= 1;
        }
        dividend -= temp;
        result += multiple;
    }
    return result;
}

int main() {
    int dividend = 43;
    int divisor = 8;
    int quotient = divide(dividend, divisor);
    printf("Quotient of %d / %d = %d\n", dividend, divisor, quotient);
    return 0;
}

#include <iostream>
using namespace std;

int divide(int dividend, int divisor) {
    int result = 0;
    while (dividend >= divisor) {
        int temp = divisor, multiple = 1;
        while (dividend >= (temp << 1)) {
            temp <<= 1;
            multiple <<= 1;
        }
        dividend -= temp;
        result += multiple;
    }
    return result;
}

int main() {
    int dividend = 43;
    int divisor = 8;
    int quotient = divide(dividend, divisor);
    cout << "Quotient of " << dividend << " / " << divisor << " = " << quotient << endl;
    return 0;
}

def divide(dividend, divisor):
    result = 0
    while dividend >= divisor:
        temp = divisor
        multiple = 1
        while dividend >= (temp << 1):
            temp <<= 1
            multiple <<= 1
        dividend -= temp
        result += multiple
    return result

# Example usage
quotient = divide(43, 8)
print(f"Quotient of 43 / 8 = {quotient}")

public class DivideWithoutOperators {
    public static int divide(int dividend, int divisor) {
        int result = 0;
        while (dividend >= divisor) {
            int temp = divisor, multiple = 1;
            while (dividend >= (temp << 1)) {
                temp <<= 1;
                multiple <<= 1;
            }
            dividend -= temp;
            result += multiple;
        }
        return result;
    }

    public static void main(String[] args) {
        int dividend = 43;
        int divisor = 8;
        int quotient = divide(dividend, divisor);
        System.out.println("Quotient of " + dividend + " / " + divisor + " = " + quotient);
    }
}

function divide(dividend, divisor) {
  let result = 0;
  while (dividend >= divisor) {
    let temp = divisor, multiple = 1;
    while (dividend >= (temp << 1)) {
      temp <<= 1;
      multiple <<= 1;
    }
    dividend -= temp;
    result += multiple;
  }
  return result;
}

// Example usage
const quotient = divide(43, 8);
console.log(`Quotient of 43 / 8 = ${quotient}`);

package main

import "fmt"

func divide(dividend, divisor int) int {
    result := 0
    for dividend >= divisor {
        temp := divisor
        multiple := 1
        for dividend >= (temp << 1) {
            temp <<= 1
            multiple <<= 1
        }
        dividend -= temp
        result += multiple
    }
    return result
}

func main() {
    dividend := 43
    divisor := 8
    quotient := divide(dividend, divisor)
    fmt.Printf("Quotient of %d / %d = %d\n", dividend, divisor, quotient)
}

fn divide(mut dividend: i32, divisor: i32) -> i32 {
    let mut result = 0;
    while dividend >= divisor {
        let mut temp = divisor;
        let mut multiple = 1;
        while dividend >= (temp << 1) {
            temp <<= 1;
            multiple <<= 1;
        }
        dividend -= temp;
        result += multiple;
    }
    result
}

fn main() {
    let dividend = 43;
    let divisor = 8;
    let quotient = divide(dividend, divisor);
    println!("Quotient of {} / {} = {}", dividend, divisor, quotient);
}

fun divide(dividend: Int, divisor: Int): Int {
    var result = 0
    var remaining = dividend
    while (remaining >= divisor) {
        var temp = divisor
        var multiple = 1
        while (remaining >= (temp << 1)) {
            temp <<= 1
            multiple <<= 1
        }
        remaining -= temp
        result += multiple
    }
    return result
}

fun main() {
    val dividend = 43
    val divisor = 8
    val quotient = divide(dividend, divisor)
    println("Quotient of $dividend / $divisor = $quotient")
}

func divide(_ dividend: Int, _ divisor: Int) -> Int {
    var result = 0
    var remaining = dividend
    while remaining >= divisor {
        var temp = divisor
        var multiple = 1
        while remaining >= (temp << 1) {
            temp <<= 1
            multiple <<= 1
        }
        remaining -= temp
        result += multiple
    }
    return result
}

let dividend = 43
let divisor = 8
let quotient = divide(dividend, divisor)
print("Quotient of \(dividend) / \(divisor) = \(quotient)")

function divide(dividend: number, divisor: number): number {
  let result = 0;
  while (dividend >= divisor) {
    let temp = divisor, multiple = 1;
    while (dividend >= (temp << 1)) {
      temp <<= 1;
      multiple <<= 1;
    }
    dividend -= temp;
    result += multiple;
  }
  return result;
}

// Example usage
const quotient = divide(43, 8);
console.log(`Quotient of 43 / 8 = ${quotient}`);

Time complexity

Space complexity

O(1)

Only a constant number of variables are used for computation (e.g., result, temp, multiple), and no additional space scales with the size of input. Hence, the space complexity is constant.