# 7. Reverse Integer

# Problem statement:

[Link to question](https://leetcode.com/problems/reverse-integer/)

Given a signed 32-bit integer `x`, return `x` *with its digits reversed*. If reversing `x` causes the value to go outside the signed 32-bit integer range `[-2**31, 2**31 - 1]`, then return `0`.

**Assume the environment does not allow you to store 64-bit integers (signed or unsigned).**

**Example 1:**

```cpp
Input: x = 123
Output: 321
```

**Example 2:**

```c
Input: x = -123
Output: -321
```

**Example 3:**

```cpp
Input: x = 120
Output: 21
```

# Code:

```cpp
class Solution {
public:
    int reverse(int N) {
        long rev_num = 0, digit, temp;

        while(N){
            digit = N % 10;
            //Extracting unit digit and joining from the end by multiplying with 10.
            temp = (rev_num * 10) + digit;
            if (temp / 10 != rev_num)
                return 0;
            if ((rev_num > 0 && rev_num > (INT_MAX - digit)/10) || (rev_num < 0 && rev_num < (INT_MIN - digit)/10)) 
                return 0;
            rev_num = temp;
            N /= 10;
        }
        return rev_num;
    }
};
```

## Explanation:

Here is a detailed explanation of each step:

1. Initialize a long-type variable `rev_num` to store the reversed integer.
    
2. The while loop continues as long as `N` is not 0.
    
3. In each iteration, the last digit of `N` is extracted using the modulo operator `% 10`.
    
4. The extracted digit is added to the `rev_num` by multiplying it by 10 and then adding the extracted digit. This is done by first creating a temporary variable `temp` equal to `rev_num * 10 + N % 10`.
    
5. The code checks for overflow by comparing `temp / 10` with `rev_num`. If they are not equal, it means the reversed integer has overflowed the range of the int type, and the function returns 0.
    
6. If there is no overflow, `rev_num` is updated to `temp` and `N` is updated to `N / 10` to remove the last digit.
    
7. The while loop continues until `N` becomes 0.
    
8. Finally, the reversed integer is returned as the result of the function.
    

**Note:** It's important to use a long type variable to store the reversed integer as the int type may overflow if the input integer is very large.

## Summary:

The code uses a while loop to extract the last digit of the input integer `N` by using the modulo operator `% 10` and adds it to the result `rev_num` after multiplying by 10. It checks for overflow by comparing `temp / 10` with `rev_num` and returns 0 if they are not equal. After each iteration, `N` is updated to `N / 10` to remove the last digit.

### Thank you for taking the time to read my article. I look forward to continuing to share my writing with you and hearing more of your thoughts and opinions.

### Happy learning!