# GeetCode Hub

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

Return the quotient after dividing `dividend` by `divisor`.

The integer division should truncate toward zero, which means losing its fractional part. For example, `truncate(8.345) = 8` and `truncate(-2.7335) = -2`.

Note: Assume we are dealing with an environment that could only store integers within the 32-bit signed integer range: `[−231, 231 − 1]`. For this problem, assume that your function returns `231 − 1` when the division result overflows.

Example 1:

```Input: dividend = 10, divisor = 3
Output: 3
Explanation: 10/3 = truncate(3.33333..) = 3.
```

Example 2:

```Input: dividend = 7, divisor = -3
Output: -2
Explanation: 7/-3 = truncate(-2.33333..) = -2.
```

Example 3:

```Input: dividend = 0, divisor = 1
Output: 0
```

Example 4:

```Input: dividend = 1, divisor = 1
Output: 1
```

Constraints:

• `-231 <= dividend, divisor <= 231 - 1`
• `divisor != 0`

class Solution { public int divide(int dividend, int divisor) { if(dividend == Integer.MIN_VALUE && divisor == -1){ return Integer.MAX_VALUE; } int sign = (dividend < 0) ^ (divisor < 0) ? -1 : 1; long absDividend = Math.abs((long) dividend); long absDivisor = Math.abs((long) divisor); long ans = 0; while(absDividend >= absDivisor){ long temp = absDivisor; long mult = 1; while((temp<<1) <= absDividend){ temp <<= 1; mult <<= 1; } ans += mult; absDividend -= temp; } return sign * (int) ans; } }

This question requires the knowledge of Bit manipulation. If you know the concept that a left shift operation in bit manipulation represents multiplication by 2 then it is simple to code the same logic.
A detailed explanation is provided in the Video.

Time Complexity: O(32) // constant time

Space Complexity: O(1)