Divide two integers without using multiplication, division and mod operator

Given two integers say a and b. Find the quotient after dividing a by b without using multiplication, division, and mod operator.

Example:

Input : a = 10, b = 3
Output : 3

Input : a = 43, b = -8
Output :  -5 

Approach: Keep subtracting the divisor from the dividend until the dividend becomes less than the divisor. The dividend becomes the remainder, and the number of times subtraction is done becomes the quotient. Below is the implementation of the above approach : 

C++

// C++ implementation to Divide two
// integers without using multiplication,
// division and mod operator
#include <bits/stdc++.h>
using namespace std;

// Function to divide a by b and
// return floor value of the result
long long divide(long long dividend, long long int divisor)
{

    // Calculate sign of divisor i.e.,
    // sign will be negative only if
    // either one of them is negative
    // otherwise it will be positive
    long long sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;

    // Update both divisor and
    // dividend positive
    dividend = abs(dividend);
    divisor = abs(divisor);

    // Initialize the quotient
    long long quotient = 0;
    while (dividend >= divisor) {
        dividend -= divisor;
        ++quotient;
    }

    // Return the value of quotient with the appropriate
    // sign.
    return quotient * sign;
}

// Driver code
int main()
{
    int a = -2147483648, b = -1;
    cout << divide(a, b) << "\n";

    a = 43, b = -8;
    cout << divide(a, b);

    return 0;
}

Java

/*Java implementation to Divide two
integers without using multiplication,
division and mod operator*/

import java.io.*;

class GFG {

    // Function to divide a by b and
    // return floor value it
    static long divide(long dividend, long divisor)
    {

        // Calculate sign of divisor i.e.,
        // sign will be negative only if
        // either one of them is negative
        // otherwise it will be positive
        long sign
            = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;

        // Update both divisor and
        // dividend positive
        dividend = Math.abs(dividend);
        divisor = Math.abs(divisor);

        // Initialize the quotient
        long quotient = 0;

        while (dividend >= divisor) {
            dividend -= divisor;
            ++quotient;
        }
        // if the sign value computed earlier is -1 then
        // negate the value of quotient
        if (sign == -1)
            quotient = -quotient;

        return quotient;
    }

    public static void main(String[] args)
    {
        int a = -2147483648;
        int b = -1;

        System.out.println(divide(a, b));

        a = 43;
        b = -8;

        System.out.println(divide(a, b));
    }
}

// This code is contributed by upendra singh bartwal.

Python3

# Python 3 implementation to Divide two
# integers without using multiplication,
# division and mod operator

# Function to divide a by b and
# return floor value it


def divide(dividend, divisor):

    # Calculate sign of divisor i.e.,
    # sign will be negative only if
    # either one of them is negative
    # otherwise it will be positive
    sign = -1 if ((dividend < 0) ^ (divisor < 0)) else 1

    # Update both divisor and
    # dividend positive
    dividend = abs(dividend)
    divisor = abs(divisor)

    # Initialize the quotient
    quotient = 0
    while (dividend >= divisor):
        dividend -= divisor
        quotient += 1

     # if the sign value computed earlier is -1 then negate the value of quotient

    if sign == -1:
        quotient = -quotient

    return quotient


# Driver code
a = 10
b = 3
print(divide(a, b))
a = 43
b = -8
print(divide(a, b))

# This code is contributed by
# Smitha Dinesh Semwal

C#

// C# implementation to Divide two without
// using multiplication, division and mod
// operator
using System;

class GFG {

    // Function to divide a by b and
    // return floor value it
    static int divide(int dividend, int divisor)
    {

        // Calculate sign of divisor i.e.,
        // sign will be negative only if
        // either one of them is negative
        // otherwise it will be positive
        int sign
            = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;

        // Update both divisor and
        // dividend positive
        dividend = Math.Abs(dividend);
        divisor = Math.Abs(divisor);

        // Initialize the quotient
        int quotient = 0;

        while (dividend >= divisor) {
            dividend -= divisor;
            ++quotient;
        }

        // if the sign value computed earlier is -1 then
        // negate the value of quotient
        if (sign == -1)
            quotient = -quotient;
        return quotient;
    }

    public static void Main()
    {

        int a = 10;
        int b = 3;
        Console.WriteLine(divide(a, b));

        a = 43;
        b = -8;
        Console.WriteLine(divide(a, b));
    }
}

// This code is contributed by vt_m.

PHP

<?php
// PHP implementation to Divide two
// integers without using multiplication,
// division and mod operator

// Function to divide a by b and
// return floor value it
function divide($dividend, $divisor) {

    // Calculate sign of divisor i.e.,
    // sign will be negative only if
    // either one of them is negative
    // otherwise it will be positive
    $sign = (($dividend < 0) ^
             ($divisor < 0)) ? -1 : 1;

    // Update both divisor and
    // dividend positive
    $dividend = abs($dividend);
    $divisor = abs($divisor);

    // Initialize the quotient
    $quotient = 0;
    while ($dividend >= $divisor)
    {
        $dividend -= $divisor;
        ++$quotient;
    }
    //if the sign value computed earlier is -1 then negate the value of quotient
    if($sign==-1) $quotient=-$quotient;
    return $quotient;
}

// Driver code
$a = 10;
$b = 3;
echo divide($a, $b)."\n";

$a = 43;
$b = -8;
echo divide($a, $b);

// This code is contributed by Sam007
?>

Javascript

<script>

// Javascript implementation to Divide two
// integers without using multiplication,
// division and mod operator

// Function to divide a by b and
// return floor value it
function divide(dividend, divisor) {

// Calculate sign of divisor i.e.,
// sign will be negative only if
// either one of them is negative
// otherwise it will be positive
let sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;

// Update both divisor and
// dividend positive
dividend = Math.abs(dividend);
divisor = Math.abs(divisor);

// Initialize the quotient
let quotient = 0;
while (dividend >= divisor) {
    dividend -= divisor;
    ++quotient;
}
//if the sign value computed earlier is -1 then negate the value of quotient
if(sign==-1) quotient=-quotient;
return quotient;
}

// Driver code
let a = 10, b = 3;
document.write(divide(a, b) + "<br>");

a = 43, b = -8;
document.write(divide(a, b));

// This code is contributed by Surbhi Tyagi.

</script>

Output

3
-5

Time complexity : O(a/b) 
Auxiliary space : O(1)

Efficient Approach: Use bit manipulation in order to find the quotient. The divisor and dividend can be written as 

dividend = quotient * divisor + remainder

As every number can be represented in base 2(0 or 1), represent the quotient in binary form by using the shift operator as given below: 

1. Determine the most significant bit in the divisor. This can easily be calculated by iterating on the bit position i from 31 to 1.
2. Find the first bit for which divisor << i is less than dividend and keep updating the i^th bit position for which it is true.
3. Add the result in the temp variable for checking the next position such that (temp + (divisor << i) ) is less than the dividend.
4. Return the final answer of the quotient after updating with a corresponding sign.

Below is the implementation of the above approach :  

C++

// C++ implementation to Divide two
// integers without using multiplication,
// division and mod operator
#include <bits/stdc++.h>
using namespace std;

// Function to divide a by b and
// return floor value it
long long divide(long long dividend, long long divisor) {

  // Calculate sign of divisor i.e.,
  // sign will be negative only if
  // either one of them is negative
  // otherwise it will be positive
  int sign = ((dividend < 0) ^
              (divisor < 0)) ? -1 : 1;

  // remove sign of operands
  dividend = abs(dividend);
  divisor = abs(divisor);

  // Initialize the quotient
  long long quotient = 0, temp = 0;

  // test down from the highest bit and
  // accumulate the tentative value for
  // valid bit
  for (int i = 31; i >= 0; --i) {

    if (temp + (divisor << i) <= dividend) {
      temp += divisor << i;
      quotient |= 1LL << i;
    }
  }
  //if the sign value computed earlier is -1 then negate the value of quotient
  if(sign==-1) quotient=-quotient;

  return quotient;
}

// Driver code
int main() {
  int a = -2147483648, b = -1;
  cout << divide(a, b) << "\n";

  a = 43, b = -8;
  cout << divide(a, b);

  return 0;
}

Java

// Java implementation to Divide
// two integers without using
// multiplication, division
// and mod operator
import java.io.*;
import java.util.*;

// Function to divide a by b
// and return floor value it
class GFG
{
public static long divide(long dividend,
                        long divisor)
{

// Calculate sign of divisor
// i.e., sign will be negative
// only if either one of them
// is negative otherwise it
// will be positive
long sign = ((dividend < 0) ^
            (divisor < 0)) ? -1 : 1;

// remove sign of operands
dividend = Math.abs(dividend);
divisor = Math.abs(divisor);

// Initialize the quotient
long quotient = 0, temp = 0;

// test down from the highest
// bit and accumulate the
// tentative value for
// valid bit
// 1<<31 behaves incorrectly and gives Integer
// Min Value which should not be the case, instead
  // 1L<<31 works correctly.
for (int i = 31; i >= 0; --i)
{

    if (temp + (divisor << i) <= dividend)
    {
        temp += divisor << i;
        quotient |= 1L << i;
    }
}

//if the sign value computed earlier is -1 then negate the value of quotient
if(sign==-1)
  quotient=-quotient;
return quotient;
}

// Driver code
public static void main(String args[])
{
int a = 10, b = 3;
System.out.println(divide(a, b));

int a1 = 43, b1 = -8;
System.out.println(divide(a1, b1));


}
}

// This code is contributed
// by Akanksha Rai(Abby_akku)

Python3

# Python3 implementation to
# Divide two integers
# without using multiplication,
# division and mod operator

# Function to divide a by
# b and return floor value it
def divide(dividend, divisor):

    # Calculate sign of divisor
    # i.e., sign will be negative
    # either one of them is negative
    # only if otherwise it will be
    # positive

    sign = (-1 if((dividend < 0) ^
                  (divisor < 0)) else 1);

    # remove sign of operands
    dividend = abs(dividend);
    divisor = abs(divisor);

    # Initialize
    # the quotient
    quotient = 0;
    temp = 0;

    # test down from the highest
    # bit and accumulate the
    # tentative value for valid bit
    for i in range(31, -1, -1):
        if (temp + (divisor << i) <= dividend):
            temp += divisor << i;
            quotient |= 1 << i;
    #if the sign value computed earlier is -1 then negate the value of quotient
    if sign ==-1 :
      quotient=-quotient;
    return quotient;

# Driver code
a = 10;
b = 3;
print(divide(a, b));

a = 43;
b = -8;
print(divide(a, b));

# This code is contributed by mits

C#

// C# implementation to Divide
// two integers without using
// multiplication, division
// and mod operator
using System;

// Function to divide a by b
// and return floor value it
class GFG
{
public static long divide(long dividend,
                          long divisor)
{

// Calculate sign of divisor
// i.e., sign will be negative
// only if either one of them
// is negative otherwise it
// will be positive
long sign = ((dividend < 0) ^
             (divisor < 0)) ? -1 : 1;

// remove sign of operands
dividend = Math.Abs(dividend);
divisor = Math.Abs(divisor);

// Initialize the quotient
long quotient = 0, temp = 0;

// test down from the highest
// bit and accumulate the
// tentative value for
// valid bit
for (int i = 31; i >= 0; --i)
{

    if (temp + (divisor << i) <= dividend)
    {
        temp += divisor << i;
        quotient |= 1LL << i;
    }
}
//if the sign value computed earlier is -1 then negate the value of quotient
  if(sign==-1)
    quotient=-quotient;
return quotient;
}

// Driver code
public static void Main()
{
int a = 10, b = 3;
Console.WriteLine(divide(a, b));

int a1 = 43, b1 = -8;
Console.WriteLine(divide(a1, b1));

}
}

// This code is contributed by mits

PHP

<?php
// PHP implementation to
// Divide two integers
// without using multiplication,
// division and mod operator

// Function to divide a by
// b and return floor value it
function divide($dividend,
                $divisor)
{

// Calculate sign of divisor
// i.e., sign will be negative
// either one of them is negative
// only if otherwise it will be
// positive
$sign = (($dividend < 0) ^
         ($divisor < 0)) ? -1 : 1;

// remove sign of operands
$dividend = abs($dividend);
$divisor = abs($divisor);

// Initialize
// the quotient
$quotient = 0;
$temp = 0;

// test down from the highest
// bit and accumulate the
// tentative value for valid bit
for ($i = 31; $i >= 0; --$i)
{

    if ($temp + ($divisor << $i) <= $dividend)
    {
        $temp += $divisor << $i;
        $quotient |= (double)(1) << $i;
    }
}
//if the sign value computed earlier is -1 then negate the value of quotient
if($sign==-1)
  $quotient=-$quotient;
return $quotient;
}

// Driver code
$a = 10;
$b = 3;
echo divide($a, $b). "\n";

$a = 43;
$b = -8;
echo divide($a, $b);

// This code is contributed by mits
?>

Javascript

<script>

// JavaScript implementation to Divide
// two integers without using
// multiplication, division
// and mod operator

// Function to divide a by b
// and return floor value it

function divide(dividend, divisor)
{

// Calculate sign of divisor
// i.e., sign will be negative
// only if either one of them
// is negative otherwise it
// will be positive
var sign = ((dividend < 0)?1:0 ^
             (divisor < 0)?1:0) ? -1 : 1;

// remove sign of operands
dividend = Math.abs(dividend);
divisor = Math.abs(divisor);

// Initialize the quotient
var quotient = 0, temp = 0;

// test down from the highest
// bit and accumulate the
// tentative value for
// valid bit
while (dividend >= divisor) {
    dividend -= divisor;
    ++quotient;
}
//if the sign value computed earlier is -1 then negate the value of quotient
if(sign==-1) quotient=-quotient;
return quotient;
}

// Driver code

var a = 10, b = 3;
document.write(divide(a, b) + "<br>");

var a1 = 43, b1 = -8;
document.write(divide(a1, b1) + "<br>");



</script>

Output

3
-5

Time complexity : O(log(a)) 
Auxiliary space : O(1)

Another Efficient Approach : Using the Logarithms

The idea here is to use the following identity:

Basic Idea : a/b = e ^ln(a) / e ^ln(b) = e^{( ln(a) – ln(b) )}

C++

#include <bits/stdc++.h>
using namespace std;
long long int divide(long long int dividend, long long int divisor)
{
    if (dividend == 0)
        return 0;
    if (divisor == 0)
    {
        cout << "Division by 0 is impossible\n";
        return 0;
    }

    // Calculate sign of answer i.e.,
    // Sign will be negative only if
    // Either one of them is negative
    // Otherwise it will be positive
    long long int sign = (dividend < 0) ^ (divisor < 0);

    // abs() : function used to get the absolute values
    dividend = abs(dividend);
    divisor = abs(divisor);
    if (divisor == 1)
        return ((sign == 0) ? dividend : -dividend);

    // log() : function used to get the logarithmic value of the entered value [Gives the natural log of the entered number]
    // exp() : Return the e^(entered value)
    long long int ans = exp(log(dividend) - log(divisor)) + 0.0000000001;
    /*
     adding 0.0000000001 to compensate for the precision errors
     like for a = 18 and b = -6,
     result after exponentiation will be 2.999999999...
     adding 0.0000000001, sets it right
    */
    return ((sign == 0) ? ans : -ans);
}
int main()
{
    int a = 10, b = 3;
    cout << divide(a, b) << '\n';
    a = 41, b = -8;
    cout << divide(a, b) << '\n';
    return 0;
}
// This Code is contributed by Alok Khansali (TheCodeAlpha)

Java

class GFG {
    static long divide(long dividend, long divisor) {
        if (dividend == 0)
            return 0;
        if (divisor == 0) {
            System.out.println("Division by 0 is impossible");
            return Integer.MAX_VALUE;
        }

        // Calculate sign of divisor i.e.,
        // sign will be negative only if
        // either one of them is negative
        // otherwise it will be positive
        boolean sign = (dividend < 0) ^ (divisor < 0);
        // Math.abs() : function used to get the absolute values
        dividend = Math.abs(dividend);
        divisor = Math.abs(divisor);
        if (divisor == 1)
            return ((sign == false) ? dividend : -dividend);
        // Math.abs() : function used to get the absolute values
        // Math.log() : function used to get the logarithmic value of the entered value
        // [Gives the natural log of the entered number]
        // Math.exp() : Return the e^(entered value)
        long ans = (long) (Math.exp(Math.log(dividend) - Math.log(divisor)) + 0.0000000001);
        /*
         * adding 0.0000000001 to compensate for the precision errors
         * like for a = 18 and b = -6,
         * result after exponentiation will be 2.999999999...
         * adding 0.0000000001, sets it right
         */
        return ((sign == false) ? ans : -ans);
    }

    public static void main(String[] args) {
        int a = 10, b = 3;
        System.out.println(divide(a, b));
        a = 41;
        b = -8;
        System.out.println(divide(a, b));
    }
}
// This Code is contributed by Alok Khansali (TheCodeAlpha)

Python3

import math


def divide(dividend, divisor):
    if dividend == 0:
        return 0
    if divisor == 0:
        # If divisor is 0, return the maximum integer value (4 byte)
        print("Division by 0 is impossible\n")
        return 2**31 - 1
    """
     Calculate sign of divisor i.e.,
     sign will be negative only if
     either one of them is negative
     otherwise it will be positive
    """
    sign = (divisor < 0) ^ (dividend < 0)
    # abs() : function used to get the absolute values for divisor and dividend
    dividend = abs(dividend)
    divisor = abs(divisor)

    # Ternary way to write a condition in python
    if divisor == 1:
        return dividend if(sign == 0) else -dividend

    """
    log() : function used to get the logarithmic value of the entered value [Gives the natural log of the entered number]
    exp() : Return the e^(entered value)
    """
    ans = math.exp(math.log(abs(dividend)) - math.log(abs(divisor)))
    """
    adding 0.0000000001 to compensate for the precision errors
    like for a = 18 and b = -6,
    result after exponentiation will be 2.999999999...
    adding 0.0000000001, sets it right
    """
    return ans if(sign == 0) else -ans


dividend, divisor = 10, 3
print(divide(dividend, divisor))
dividend, divisor = 41, -8
print(divide(dividend, divisor))

C#

using System;

public class GFG {

  static long divide(long dividend, long divisor)
  {
    if (dividend == 0)
      return 0;
    if (divisor == 0) {
      Console.WriteLine(
        "Division by 0 is impossible");
      return Int32.MaxValue;
    }

    // Calculate sign of divisor i.e.,
    // sign will be negative only if
    // either one of them is negative
    // otherwise it will be positive
    bool sign = (dividend < 0) ^ (divisor < 0);

    // Math.abs() : function used to get the absolute
    // values
    dividend = Math.Abs(dividend);
    divisor = Math.Abs(divisor);
    if (divisor == 1)
      return ((sign == false) ? dividend : -dividend);

    // Math.abs() : function used to get the absolute
    // values Math.log() : function used to get the
    // logarithmic value of the entered value [Gives the
    // natural log of the entered number] Math.exp() :
    // Return the e^(entered value)
    long ans = (long)(Math.Exp(Math.Log(dividend)
                               - Math.Log(divisor))
                      + 0.0000000001);
    /*
         * adding 0.0000000001 to compensate for the
         * precision errors like for a = 18 and b = -6,
         * result after exponentiation will
         * be 2.999999999... adding 0.0000000001, sets it
         * right
         */
    return ((sign == false) ? ans : -ans);
  }

  static public void Main()
  {

    // Code
    int a = 10, b = 3;
    Console.WriteLine(divide(a, b));
    a = 41;
    b = -8;
    Console.WriteLine(divide(a, b));
  }
}

// This Code is contributed by lokeshmvs21.

Javascript

function divide( dividend, divisor)
{
    if (dividend == 0)
        return 0;
    if (divisor == 0)
    {
       document.write("Division by 0 is impossible");
        return 0;
    }

    // Calculate sign of answer i.e.,
    // Sign will be negative only if
    // Either one of them is negative
    // Otherwise it will be positive
    let sign = (dividend < 0) ^ (divisor < 0);

    // abs() : function used to get the absolute values
    dividend = Math.abs(dividend);
    divisor = Math.abs(divisor);
    if (divisor == 1)
        return ((sign == 0) ? dividend : -dividend);

    // log() : function used to get the logarithmic value
    //of the entered value [Gives the natural log of the entered number]
    // exp() : Return the e^(entered value)

    let ans = Math.exp(Math.log(dividend) - Math.log(divisor)) + 0.0000000001;

    /*
     adding 0.0000000001 to compensate for the precision errors
     like for a = 18 and b = -6,
     result after exponentiation will be 2.999999999...
     adding 0.0000000001, sets it right
    */
    ans= Math.round(ans);
    return ((sign == 0) ? ans : -ans);
}

    let a = 10, b = 3;
    console.log( divide(a, b));
    a = 41, b = -8;
    console.log( divide(a, b));

Output

3
-5

Time Complexity: O(1) as the time taken to perform the division is constant.

Space Complexity: O(1) as no extra space is required.