在不使用除法运算符的情况下找到两个整数的商和余数

给定两个正整数除数和除数，我们的任务是找到商和余数。不允许使用除法或mod运算符。

例子：

Input : dividend = 10, divisor = 3 
Output : 3, 1 
Explanation: 
The quotient when 10 is divided by 3 is 3 and the remainder is 1.

Input : dividend = 11, divisor = 5 
Output : 2, 1 
Explanation: 
The quotient when 11 is divided by 5 is 2 and the remainder is 1. 
 

方法：
为了解决上述问题，我们将使用二进制搜索技术。我们可以在1到N的范围内实现搜索方法，其中N是股息。在这里，我们将使用乘法来确定范围。一旦我们脱离了二分查找的while循环，就得到了商，可以使用乘法和减法运算符找到余数。当除数小于或等于除数时，处理特殊情况，而不使用二进制搜索。

下面是上述方法的实现：

C++

// C++ implementation to Find Quotient
// and Remainder of two integer without
// using / and % operator using Binary search
 
#include 
using namespace std;
 
// Function to the quotient and remainder
pair find(int dividend, int divisor,
                    int start, int end)
{
 
    // Check if start is greater than the end
    if (start > end)
        return { 0, dividend };
 
    // Calculate mid
    int mid = start + (end - start) / 2;
 
    int n = dividend - divisor * mid;
 
    // Check if n is greater than divisor
    // then increment the mid by 1
    if (n > divisor)
        start = mid + 1;
 
    // Check if n is less than 0
    // then decrement the mid by 1
    else if (n < 0)
        end = mid - 1;
 
    else {
        // Check if n equals to divisor
        if (n == divisor) {
            ++mid;
            n = 0;
        }
 
        // Return the final answer
        return { mid, n };
    }
 
    // Recursive calls
    return find(dividend, divisor, start, end);
}
 
pair divide(int dividend, int divisor)
{
    return find(dividend, divisor, 1, dividend);
}
 
// Driver code
int main(int argc, char* argv[])
{
    int dividend = 10, divisor = 3;
 
    pair ans;
 
    ans = divide(dividend, divisor);
 
    cout << ans.first << ", ";
    cout << ans.second << endl;
 
    return 0;
}

Java

// JAVA implementation to Find Quotient
// and Remainder of two integer without
// using / and % operator using Binary search
 
class GFG{
  
// Function to the quotient and remainder
static int[] find(int dividend, int divisor,
                    int start, int end)
{
  
    // Check if start is greater than the end
    if (start > end)
        return new int[] { 0, dividend };
  
    // Calculate mid
    int mid = start + (end - start) / 2;
  
    int n = dividend - divisor * mid;
  
    // Check if n is greater than divisor
    // then increment the mid by 1
    if (n > divisor)
        start = mid + 1;
  
    // Check if n is less than 0
    // then decrement the mid by 1
    else if (n < 0)
        end = mid - 1;
  
    else {
        // Check if n equals to divisor
        if (n == divisor) {
            ++mid;
            n = 0;
        }
  
        // Return the final answer
        return new int[] { mid, n };
    }
  
    // Recursive calls
    return find(dividend, divisor, start, end);
}
  
static int[]  divide(int dividend, int divisor)
{
    return find(dividend, divisor, 1, dividend);
}
  
// Driver code
public static void main(String[] args)
{
    int dividend = 10, divisor = 3;
   
    int []ans = divide(dividend, divisor);
  
    System.out.print(ans[0]+ ", ");
    System.out.print(ans[1] +"\n");
  
}
}
 
// This code contributed by sapnasingh4991

Python3

# Python3 implementation to Find Quotient
# and Remainder of two integer without
# using / and % operator using Binary search
 
# Function to the quotient and remainder
def find(dividend, divisor,  start,  end) :
 
    # Check if start is greater than the end
    if (start > end) :
        return ( 0, dividend );
 
    # Calculate mid
    mid = start + (end - start) // 2;
 
    n = dividend - divisor * mid;
 
    # Check if n is greater than divisor
    # then increment the mid by 1
    if (n > divisor) :
        start = mid + 1;
 
    # Check if n is less than 0
    # then decrement the mid by 1
    elif (n < 0) :
        end = mid - 1;
 
    else :
        # Check if n equals to divisor
        if (n == divisor) :
            mid += 1;
            n = 0;
 
        # Return the final answer
        return ( mid, n );
     
    # Recursive calls
    return find(dividend, divisor, start, end);
 
def divide(dividend, divisor) :
 
    return find(dividend, divisor, 1, dividend);
 
# Driver code
if __name__ == "__main__" :
 
    dividend = 10; divisor = 3;
 
    ans = divide(dividend, divisor);
 
    print(ans[0],", ",ans[1])
 
# This code is contributed by Yash_R

C#

// C# implementation to Find Quotient
// and Remainder of two integer without
// using / and % operator using Binary search
  
using System;
 
public class GFG{
   
// Function to the quotient and remainder
static int[] find(int dividend, int divisor,
                    int start, int end)
{
   
    // Check if start is greater than the end
    if (start > end)
        return new int[] { 0, dividend };
   
    // Calculate mid
    int mid = start + (end - start) / 2;
   
    int n = dividend - divisor * mid;
   
    // Check if n is greater than divisor
    // then increment the mid by 1
    if (n > divisor)
        start = mid + 1;
   
    // Check if n is less than 0
    // then decrement the mid by 1
    else if (n < 0)
        end = mid - 1;
   
    else {
        // Check if n equals to divisor
        if (n == divisor) {
            ++mid;
            n = 0;
        }
   
        // Return the readonly answer
        return new int[] { mid, n };
    }
   
    // Recursive calls
    return find(dividend, divisor, start, end);
}
   
static int[]  divide(int dividend, int divisor)
{
    return find(dividend, divisor, 1, dividend);
}
   
// Driver code
public static void Main(String[] args)
{
    int dividend = 10, divisor = 3;
    
    int []ans = divide(dividend, divisor);
   
    Console.Write(ans[0]+ ", ");
    Console.Write(ans[1] +"\n");
   
}
}
// This code contributed by Princi Singh

Javascript

 
// Javascript implementation to Find Quotient
// and Remainder of two integer without
// using / and % operator using Binary search
 
// Function to the quotient and remainder
function find(dividend, divisor, start, end)
{
     
    // Check if start is greater than the end
    if (start > end)
        return [0, dividend];
 
    // Calculate mid
    var mid = start + parseInt((end - start) / 2);
 
    var n = dividend - divisor * mid;
 
    // Check if n is greater than divisor
    // then increment the mid by 1
    if (n > divisor)
        start = mid + 1;
 
    // Check if n is less than 0
    // then decrement the mid by 1
    else if (n < 0)
        end = mid - 1;
 
    else
    {
         
        // Check if n equals to divisor
        if (n == divisor)
        {
            ++mid;
            n = 0;
        }
 
        // Return the final answer
        return [ mid, n];
    }
 
    // Recursive calls
    return find(dividend, divisor, start, end);
}
 
function divide(dividend, divisor)
{
    return find(dividend, divisor, 1, dividend);
}
 
// Driver code
var dividend = 10, divisor = 3;
var ans = divide(dividend, divisor);
 
document.write(ans[0] + ", ");
document.write(ans[1] + "\n");
 
// This code is contributed by gauravrajput1
 

输出：

3, 1

时间复杂度： O(logN)
空间复杂度： O(n)
相似的文章：在不使用乘法，除法和mod运算符的情况下除以两个整数