How to reverse a number as an integer and not as a string?

Reversing an Integer: A C# Algorithm Guide

Learn how to reverse the digits of an integer programmatically in C#, focusing on mathematical operations rather than string conversions. This article covers the core logic, edge cases, and provides a clear, efficient solution.

Reversing the digits of a number is a common programming challenge. While it might seem straightforward to convert the number to a string, reverse the string, and then convert it back to an integer, this approach has limitations. It can be inefficient for very large numbers and might not be allowed in certain problem constraints. This article will guide you through a robust, mathematical approach to reverse an integer in C#, handling various scenarios including negative numbers and potential overflows.

The Core Logic: Iterative Division and Modulo

The fundamental idea behind reversing an integer mathematically involves repeatedly extracting the last digit of the number and building the reversed number from these extracted digits. This process uses two primary arithmetic operations: the modulo operator (%) and integer division (/).

1. Extracting the Last Digit: The modulo operator (number % 10) gives you the last digit of an integer.
2. Building the Reversed Number: To construct the reversed number, you multiply the current reversedNumber by 10 and add the extracted lastDigit. This effectively shifts the existing digits to the left and appends the new digit.
3. Removing the Last Digit: Integer division (number / 10) removes the last digit from the original number, preparing it for the next iteration.

flowchart TD
    A[Start] --> B{Initialize reversedNum = 0, originalNum = inputNum}
    B --> C{Is originalNum == 0?}
    C -- Yes --> D[Return reversedNum]
    C -- No --> E[lastDigit = originalNum % 10]
    E --> F{Check for Overflow}
    F -- Overflow --> G[Return 0 (or throw exception)]
    F -- No Overflow --> H[reversedNum = reversedNum * 10 + lastDigit]
    H --> I[originalNum = originalNum / 10]
    I --> C

Flowchart of the integer reversal algorithm

Handling Edge Cases and Overflow

When reversing integers, several edge cases need careful consideration:

• Negative Numbers: The algorithm should correctly handle negative numbers, typically by preserving the sign. One common approach is to store the sign, perform the reversal on the absolute value, and then reapply the sign.
• Trailing Zeros: Numbers like 120 should reverse to 21. The modulo/division approach naturally handles this, as trailing zeros become leading zeros in the reversed number, which are then implicitly dropped by the integer type.
• Integer Overflow: This is the most critical edge case. When reversedNumber * 10 + lastDigit exceeds the maximum or falls below the minimum value that an int (or long) can hold, an overflow occurs. This can lead to incorrect results or runtime errors. It's crucial to check for potential overflow before performing the multiplication and addition. For C#, int.MaxValue and int.MinValue are your friends here.

public class Solution {
    public int Reverse(int x) {
        long reversedNum = 0;
        while (x != 0) {
            int lastDigit = x % 10;
            reversedNum = reversedNum * 10 + lastDigit;
            
            // Check for overflow before the next iteration
            if (reversedNum > int.MaxValue || reversedNum < int.MinValue) {
                return 0; // Or throw an exception, depending on requirements
            }
            
            x /= 10;
        }
        return (int)reversedNum;
    }
}

C# implementation of integer reversal with overflow check

Detailed Overflow Detection Logic

The overflow check is paramount. Consider the reversedNum just before the multiplication by 10. If reversedNum is already greater than int.MaxValue / 10, then multiplying by 10 will definitely cause an overflow. Similarly for int.MinValue / 10. You also need to account for the lastDigit when reversedNum is exactly int.MaxValue / 10 or int.MinValue / 10.

Let's refine the overflow check within the loop:

public class Solution {
    public int Reverse(int x) {
        int reversedNum = 0;
        while (x != 0) {
            int lastDigit = x % 10;
            
            // Check for overflow before updating reversedNum
            // If reversedNum is already too large/small, multiplying by 10 will overflow
            // Or if it's at the limit and lastDigit pushes it over
            if (reversedNum > int.MaxValue / 10 || (reversedNum == int.MaxValue / 10 && lastDigit > 7)) {
                return 0; // Overflow for positive numbers
            }
            if (reversedNum < int.MinValue / 10 || (reversedNum == int.MinValue / 10 && lastDigit < -8)) {
                return 0; // Overflow for negative numbers
            }
            
            reversedNum = reversedNum * 10 + lastDigit;
            x /= 10;
        }
        return reversedNum;
    }
}

Refined C# implementation with precise integer overflow checks