Reverse digits of an integer: How to find out if the number have overflown?

Question

I am trying to solve a problem:

Given a 32-bit signed integer, reverse digits of an integer, returns 0 when the reversed integer overflows.

My solution is:

public int reverse(int x)
{
    int reversedNumber = 0;
    boolean isNumberNegative = x < 0;
    x = Math.abs(x);
    while (x >= 10)
    {
        reversedNumber = reversedNumber * 10 + (x % 10);
        x = x / 10;
    }
    reversedNumber = reversedNumber * 10 + x;
    return isNumberNegative ? -1 * reversedNumber : reversedNumber;
}

My problem is with the overflow, how do I find out if the reversedNumber have overflown without using Math utility class or long and then checking?

Answer 1

You can make use of the conversion of int to long and vice versa, as a long bigger than Integer.MAX_VALUE and smaller than Integer.MIN_VALUE will overflow when casted back to int , this can be seen in the last 2 lines:

public int reverse(int x) {
    long reversedNumber = 0;
    boolean isNumberNegative = x < 0;
    x = isNumberNegative ? -x : x;
    while (x >= 10) {
        reversedNumber = reversedNumber * 10 + (x % 10);
        x = x / 10;
    }
    reversedNumber = reversedNumber * 10 + x;
    reversedNumber = isNumberNegative ? -reversedNumber : reversedNumber;

    int result = (int) reversedNumber ;
    return reversedNumber != result ? 0 : result;
}

Answer 2

You could try to do this like that, without any casting:

public int reverse(int x) {
    int reversedNumber = 0;
    int digitCount = 1;
    x = Math.abs(x);
    while (x >= 10) {
        if(digitCount >= 9 && willOverflow(reversedNumber)){
            return 0;
        }
        reversedNumber = reversedNumber * 10 + (x % 10);
        x = x / 10;
        digitCount++;
    }
    if(willOverflow(reversedNumber)){
        return 0;
    }
    reversedNumber = reversedNumber * 10 + x;
    if(reversedNumber < 0){
        return 0;
    }

    return reversedNumber;
}

private boolean willOverflow(int reversedNumber) {
    int tmpMultiply = reversedNumber * 10;
    int tmpDivide = tmpMultiply / 10;
    return tmpDivide != reversedNumber;
}

If i believe you can check if integer will overflow, by multiplying it by 10 and then dividing it by 10. If value at the end is different than passed value, you can assume integer will overflow in next iteration (if there will be next iteration).