Divide Two Integers

Divide Two Integers - Problem

Given two integers dividend and divisor, divide two integers without using multiplication, division, and mod operator.

The integer division should truncate toward zero, which means losing its fractional part. For example, 8.345 would be truncated to 8, and -2.7335 would be truncated to -2.

Return the quotient after dividing dividend by divisor.

Note: Assume we are dealing with an environment that could only store integers within the 32-bit signed integer range: [−2³¹, 2³¹ − 1]. For this problem, if the quotient is strictly greater than 2³¹ - 1, then return 2³¹ - 1, and if the quotient is strictly less than -2³¹, then return -2³¹.

Input & Output

Example 1 — Basic Division

$ Input: dividend = 10, divisor = 3

› Output: 3

💡 Note: 10 ÷ 3 = 3.33, truncated toward zero gives 3

Example 2 — Exact Division

$ Input: dividend = 7, divisor = -3

› Output: -2

💡 Note: 7 ÷ (-3) = -2.33, truncated toward zero gives -2

Example 3 — Overflow Case

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

› Output: 2147483647

💡 Note: Result would be 2147483648, but we cap at 2³¹-1 = 2147483647

Constraints

-2³¹ ≤ dividend, divisor ≤ 2³¹ - 1
divisor ≠ 0

Visualization

Tap to expand

Asked in

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

The key insight is to avoid multiplication/division/modulo by using bit shifts to exponentially increase the divisor until we find the largest multiple that fits. The optimal approach uses exponential search with bit manipulation to achieve O(log²n) time complexity instead of O(n) with repeated subtraction.

Common Approaches

✓ Dp 2d

⏱️ Time: N/A Space: N/A

Memoization

⏱️ Time: N/A Space: N/A

Exponential Search with Bit Shifts

⏱️ Time: O(log²(dividend)) Space: O(1)

Instead of subtracting divisor one by one, we double it repeatedly using bit shifts (multiply by 2) to find the largest multiple that fits in the dividend. This reduces time complexity significantly.

Repeated Subtraction

⏱️ Time: O(dividend/divisor) Space: O(1)

Keep subtracting the divisor from the dividend and count how many times we can do this. This mimics the basic definition of division as repeated subtraction.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* solution(const char* s) {
    int n = strlen(s);
    if (n <= 1) {
        char* result = malloc(n + 1);
        strcpy(result, s);
        return result;
    }
    
    // Simplified DP approach for C
    char* result = malloc(n + 1);
    strcpy(result, s);
    
    // Try to find the best repeating pattern from the beginning
    for (int i = 1; i <= n / 2; i++) {
        int count = 1;
        int j = i;
        while (j + i <= n) {
            if (strncmp(s, s + j, i) == 0) {
                count++;
                j += i;
            } else {
                break;
            }
        }
        
        if (count > 1) {
            char pattern[501];
            strncpy(pattern, s, i);
            pattern[i] = '\0';
            
            int compressedLen = snprintf(NULL, 0, "%d[%s]", count, pattern) + 1;
            if (j < n) {
                compressedLen += (n - j);
                char* compressed = malloc(compressedLen);
                sprintf(compressed, "%d[%s]%s", count, pattern, s + j);
                
                if (strlen(compressed) < strlen(result)) {
                    free(result);
                    result = compressed;
                } else {
                    free(compressed);
                }
            } else {
                char* compressed = malloc(compressedLen);
                sprintf(compressed, "%d[%s]", count, pattern);
                
                if (strlen(compressed) < strlen(result)) {
                    free(result);
                    result = compressed;
                } else {
                    free(compressed);
                }
            }
        }
    }
    
    return result;
}

int main() {
    char s[501];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

98.0K Views

Medium Frequency

~25 min Avg. Time

4.2K 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