Reverse Integer - Practice Coding Problems

Reverse Integer - Problem

Math Medium

Reverse Integer is a classic mathematical manipulation problem that tests your understanding of integer overflow handling.

You're given a signed 32-bit integer x, and your task is to reverse its digits while being mindful of integer overflow constraints.

Key Requirements:
• If the reversed integer exceeds the 32-bit signed integer range [-2³¹, 2³¹ - 1], return 0
• Handle both positive and negative numbers correctly
• The environment doesn't allow 64-bit integers

Examples:
• 123 → 321
• -123 → -321
• 120 → 21 (trailing zeros disappear)
• 1534236469 → 0 (overflow case)

Input & Output

example_1.py — Basic Positive Number

$ Input: x = 123

› Output: 321

💡 Note: Reverse the digits: 1-2-3 becomes 3-2-1, which is 321. No overflow occurs.

example_2.py — Negative Number

$ Input: x = -123

› Output: -321

💡 Note: Reverse the digits while preserving the negative sign: -1-2-3 becomes -3-2-1, which is -321.

example_3.py — Trailing Zeros

$ Input: x = 120

› Output: 21

💡 Note: Reverse the digits: 1-2-0 becomes 0-2-1. Since leading zeros are dropped in integers, the result is 21.

example_4.py — Overflow Case

$ Input: x = 1534236469

› Output: 0

💡 Note: Reversing gives 9646324351, which exceeds 2³¹-1 = 2147483647, so we return 0 due to overflow.

Visualization

Tap to expand

Understanding the Visualization

Input Processing

The machine receives a number and separates the sign from the digits

Digit Extraction

Using modulo operation, extract the rightmost digit (like pulling the last LEGO block)

Safety Check

Before adding the digit, check if the result would overflow the 32-bit limit

Build Result

Multiply current result by 10 and add the extracted digit

Continue Process

Remove the processed digit and repeat until no digits remain

Key Takeaway

🎯 Key Insight: By checking for overflow BEFORE it happens (result > INT_MAX/10), we can safely reverse integers without using 64-bit arithmetic, making this both efficient and mathematically elegant.

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We process each digit exactly once, and there are log₁₀(n) digits in the number.

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra variables regardless of input size.

✓ Linear Space

Constraints

-2³¹ ≤ x ≤ 2³¹ - 1
Environment does not allow 64-bit integers
Return 0 if reversed integer overflows 32-bit signed integer range

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 25 f Meta 22 B Bloomberg 18

The optimal solution uses mathematical digit extraction with modulo and division operations. Extract digits using x % 10, build the reversed number with result = result * 10 + digit, and check for overflow before it happens by comparing with INT_MAX/10. Time: O(log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Digit Extraction (Optimal)	O(log n)	O(1)	Extract digits using modulo and division while checking overflow mathematically

Mathematical Digit Extraction (Optimal) — Algorithm Steps

Initialize result to 0 and extract sign
Use modulo 10 to get the last digit
Check if adding next digit would cause overflow
Update result: result = result * 10 + digit
Remove last digit using integer division by 10
Repeat until all digits are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

x = 123, result = 0

Extract Digit

digit = 123 % 10 = 3, result = 0 * 10 + 3 = 3, x = 123 / 10 = 12

Next Digit

digit = 12 % 10 = 2, result = 3 * 10 + 2 = 32, x = 12 / 10 = 1

Final Digit

digit = 1 % 10 = 1, result = 32 * 10 + 1 = 321, x = 1 / 10 = 0

Code -

solution.c — C

#include <stdio.h>
#include <limits.h>

int reverse(int x) {
    int result = 0;
    
    while (x != 0) {
        // Get last digit
        int digit = x % 10;
        
        // Check for overflow before it happens
        if (result > INT_MAX / 10 || 
            (result == INT_MAX / 10 && digit > INT_MAX % 10)) {
            return 0;
        }
        if (result < INT_MIN / 10 || 
            (result == INT_MIN / 10 && digit < INT_MIN % 10)) {
            return 0;
        }
        
        result = result * 10 + digit;
        x /= 10;
    }
    
    return result;
}

int main() {
    int x;
    scanf("%d", &x);
    printf("%d\n", reverse(x));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We process each digit exactly once, and there are log₁₀(n) digits in the number.

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra variables regardless of input size.

✓ Linear Space

Constraints

-2³¹ ≤ x ≤ 2³¹ - 1
Environment does not allow 64-bit integers
Return 0 if reversed integer overflows 32-bit signed integer range

89.3K Views

High Frequency

~15 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

Mathematical Digit Extraction (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler