Divide Two Integers - Practice Coding Problems

Divide Two Integers - Problem

Divide Two Integers

Welcome to a fascinating mathematical puzzle! Your mission is to implement division without using division.

Given two integers dividend and divisor, you need to divide them without using multiplication (*), division (/), or modulo (%) operators.

Key Requirements:
• The result should truncate toward zero (remove fractional part)
• Handle 32-bit integer overflow by clamping to [-2³¹, 2³¹ - 1]
• Examples: 8.345 → 8, -2.7335 → -2

This problem tests your understanding of bit manipulation and creative mathematical thinking!

Input & Output

example_1.py — Basic Division

$ Input: dividend = 10, divisor = 3

› Output: 3

💡 Note: 10/3 = 3.333... which truncates to 3

example_2.py — Negative Result

$ Input: dividend = 7, divisor = -3

› Output: -2

💡 Note: 7/(-3) = -2.333... which truncates toward zero to -2

example_3.py — Overflow Case

$ Input: dividend = -2147483648, divisor = -1

› Output: 2147483647

💡 Note: This would result in 2147483648, but we clamp to 2^31-1 = 2147483647

Visualization

Tap to expand

Understanding the Visualization

Start Small

Begin with divisor×1, then double repeatedly

Find Maximum

Stop doubling when next value exceeds dividend

Subtract & Repeat

Subtract largest multiple and repeat with remainder

Build Result

Sum all multipliers to get final quotient

Key Takeaway

🎯 Key Insight: By doubling multiples using bit shifts, we reduce O(n) subtraction to O(log²n) by finding large chunks efficiently!

Time & Space Complexity

Time Complexity

⏱️

O((log dividend)²)

For each bit position, we do logarithmic work to find the largest multiple

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

-2³¹ ≤ dividend, divisor ≤ 2³¹ - 1
divisor ≠ 0
Cannot use multiplication, division, or mod operators
Result must be clamped to 32-bit signed integer range

Asked in

f Facebook 45 G Google 38 ⊞ Microsoft 32 a Amazon 28

The optimal solution uses bit manipulation to find the largest multiples of the divisor efficiently. Instead of subtracting one divisor at a time (O(n)), we double the divisor using bit shifts until we find the largest multiple that fits, achieving O(log²n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Bit Manipulation with Doubling (Optimal)	O((log dividend)²)	O(1)	Use bit shifting to find multiples efficiently, building quotient exponentially
Repeated Subtraction (Brute Force)	O(dividend/divisor)	O(1)	Keep subtracting divisor from dividend until remainder is smaller than divisor

Bit Manipulation with Doubling (Optimal) — Algorithm Steps

Handle edge cases and determine sign
Work with absolute values using long to prevent overflow
For each iteration, find largest multiple using bit shifting
Subtract this multiple from dividend and add to quotient
Repeat until dividend < divisor
Apply correct sign and clamp to 32-bit range

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial

dividend=22, divisor=3, quotient=0

Find Multiple

3→6→12, stop at 12 (next would be 24>22)

Subtract

22-12=10, quotient=4 (since 12=3×4)

Repeat

10-6=4, quotient=4+2=6

Final

4-3=1, quotient=6+1=7

Code -

solution.c — C

int divide(int dividend, int divisor) {
    // Handle overflow case
    if (dividend == INT_MIN && divisor == -1) {
        return INT_MAX;
    }
    
    // Determine sign
    int negative = (dividend < 0) != (divisor < 0);
    
    // Work with absolute values (use long to prevent overflow)
    long absDividend = labs((long) dividend);
    long absDivisor = labs((long) divisor);
    
    long quotient = 0;
    while (absDividend >= absDivisor) {
        // Find the largest multiple
        long tempDivisor = absDivisor;
        long multiple = 1;
        
        // Double until we exceed dividend
        while (absDividend >= (tempDivisor << 1)) {
            tempDivisor <<= 1;
            multiple <<= 1;
        }
        
        // Subtract and add to quotient
        absDividend -= tempDivisor;
        quotient += multiple;
    }
    
    // Apply sign and clamp
    long result = negative ? -quotient : quotient;
    return (int) fmax(INT_MIN, fmin(INT_MAX, result));
}

Time & Space Complexity

Time Complexity

⏱️

O((log dividend)²)

For each bit position, we do logarithmic work to find the largest multiple

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

-2³¹ ≤ dividend, divisor ≤ 2³¹ - 1
divisor ≠ 0
Cannot use multiplication, division, or mod operators
Result must be clamped to 32-bit signed integer range

89.4K Views

Medium Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bit Manipulation with Doubling (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler