Reverse digits of an integer with overflow handled

Last Updated : 23 Apr, 2025

Write a program to reverse an integer assuming that the input is a 32-bit integer. If the reversed integer overflows, print -1 as the output.

Let us see a simple approach to reverse digits of an integer.

C++

// A simple C program to reverse digits of
// an integer.
#include <bits/stdc++.h>
using namespace std;

int reversDigits(int num)
{
    int rev_num = 0;
    while (num != 0) {
        rev_num = rev_num * 10 + num % 10;
        num = num / 10;
    }
    return rev_num;
}

/* Driver program to test reversDigits */
int main()
{
    int num = 5896;
    cout << "Reverse of no. is " << reversDigits(num);
    return 0;
}

// This code is contributed by Sania Kumari Gupta (kriSania804)
// This code is improved by Md. Owais Ashraf (professor_011)

 
// A simple C program to reverse digits of
// an integer.#include <bits/stdc++.h>using namespace std;​int reversDigits(int num){    int rev_num = 0;    while (num != 0) {        rev_num = rev_num * 10 + num % 10;        num = num / 10;    }    return rev_num;}​/* Driver program to test reversDigits */int main(){    int num = 5896;    cout << "Reverse of no. is " << reversDigits(num);    return 0;}​// This code is contributed by Sania Kumari Gupta (kriSania804)// This code is improved by Md. Owais Ashraf (professor_011)

// A simple C program to reverse digits of
// an integer.
#include <stdio.h>

int reversDigits(int num)
{
    int rev_num = 0;
    while (num != 0) {
        rev_num = rev_num * 10 + num % 10;
        num = num / 10;
    }
    return rev_num;
}

/* Driver program to test reversDigits */
int main()
{
    int num = 5896;
    printf("Reverse of no. is %d", reversDigits(num));
    return 0;
}

// This code is contributed by Sania Kumari Gupta (kriSania804)
// This code is improved by Md. Owais Ashraf (professor_011)

Java

// Java program to reverse a number 

class GFG
{
    /* Iterative function to reverse
    digits of num*/
    static int reversDigits(int num)
    {
        int rev_num = 0;
        while(num!=0)
        {
            rev_num = rev_num * 10 + num % 10;
            num = num / 10;
        }
        return rev_num;
    }
    
    // Driver code
    public static void main (String[] args) 
    {
        int num = 5896;
        System.out.println("Reverse of no. is " 
                           + reversDigits(num));
    }
}

// This code is contributed by Anant Agarwal.
// This code is improved by Md. Owais Ashraf (professor_011)
// This code is improved by Jeet Purohit  (jeetpurohit989)

Python

# Python program to reverse a number 

n = 5896;
rev = 0

while(n != 0):
    a = n % 10
    rev = rev * 10 + a
    n = n // 10
    
print(rev)

# This code is contributed by Shariq Raza 
# This code is improved by Jeet Purohit  (jeetpurohit989)

// C# program to reverse a number 
using System;

class GFG
{
    // Iterative function to 
    // reverse digits of num
    static int reversDigits(int num)
    {
        int rev_num = 0;
        while(num != 0)
        {
            rev_num = rev_num * 10 + num % 10;
            num = num / 10;
        }
        return rev_num;
    }
    
    // Driver code
    public static void Main() 
    {
        int num = 5896;
        Console.Write("Reverse of no. is "
                        + reversDigits(num));
    }
}

// This code is contributed by Sam007
// This code is improved by Md. Owais Ashraf (professor_011)

JavaScript

<script>

// A simple Javascript program to reverse digits of 
// an integer. 

function reversDigits(num) 
{ 
    let rev_num = 0; 
    while (num != 0) 
    { 
        rev_num = rev_num*10 + num%10; 
        num = Math.floor(num/10); 
    } 
    return rev_num; 
} 

/* Driver program to test reversDigits */
 
    let num = 5896; 
    document.write("Reverse of no. is "+ reversDigits(num)); 
    
// This code is contributed by Mayank Tyagi
// This code is improved by Md. Owais Ashraf (professor_011)
// This code is improved by Jeet Purohit  (jeetpurohit989)
</script>

PHP

<?php
// Iterative function to 
// reverse digits of num
function reversDigits($num)
{
    $rev_num = 0;
    while($num != 0)
    {
        $rev_num = $rev_num * 10 + 
                        $num % 10;
        $num = (int)$num / 10;
    }
    return $rev_num/10;
}

// Driver Code
$num = 5896;
echo "Reverse of no. is ", 
       reversDigits($num);

// This code is contributed by aj_36
// This code is improved by Md. Owais Ashraf (professor_011)
// This code is improved by Jeet Purohit  (jeetpurohit989)

?>

Output

Reverse of no. is 6985

Time Complexity: O(log(num))
Auxiliary Space: O(1)

Optimized Approach:

However, if the number is large such that the reverse overflows, the output is some garbage value. If we run the code above with input as any large number say 1000000045, then the output is some garbage value like 1105032705 or any other garbage value.
How to handle overflow?
The idea is to store the previous value of the sum can be stored in a variable that can be checked every time to see if the reverse overflowed or not.

Below is the implementation to deal with such a situation.

C++

// C++ program to reverse digits 
// of a number
#include <bits/stdc++.h>

using namespace std;

/* Iterative function to reverse 
digits of num*/
int reversDigits(int num)
{
    // Handling negative numbers
    bool negativeFlag = false;
    if (num < 0)
    {
        negativeFlag = true;
        num = -num ;
    }

    int prev_rev_num = 0, rev_num = 0;
    while (num != 0)
    {
        int curr_digit = num % 10;

        rev_num = (rev_num * 10) + curr_digit;

        // checking if the reverse overflowed or not.
        // The values of (rev_num - curr_digit)/10 and
        // prev_rev_num must be same if there was no
        // problem.
        if ((rev_num - curr_digit) / 
               10 != prev_rev_num)
        {
            cout << "WARNING OVERFLOWED!!!"
                 << endl;
            return 0;
        }

        prev_rev_num = rev_num;
        num = num / 10;
    }

    return (negativeFlag == true) ?
                         -rev_num : rev_num;
}

// Driver Code
int main()
{
    int num = 12345;
    cout << "Reverse of no. is " 
         << reversDigits(num) << endl;

    num = 1000000045;
    cout << "Reverse of no. is " 
         << reversDigits(num) << endl;

    return 0;
}

// This code is contributed 
// by Akanksha Rai(Abby_akku)

 
// C++ program to reverse digits 
// of a number#include <bits/stdc++.h>​using namespace std;​/* Iterative function to reverse digits of num*/int reversDigits(int num){    // Handling negative numbers    bool negativeFlag = false;    if (num < 0)    {        negativeFlag = true;        num = -num ;    }​    int prev_rev_num = 0, rev_num = 0;    while (num != 0)    {        int curr_digit = num % 10;​        rev_num = (rev_num * 10) + curr_digit;​        // checking if the reverse overflowed or not.        // The values of (rev_num - curr_digit)/10 and        // prev_rev_num must be same if there was no        // problem.        if ((rev_num - curr_digit) /                10 != prev_rev_num)        {            cout << "WARNING OVERFLOWED!!!"                 << endl;            return 0;        }​        prev_rev_num = rev_num;        num = num / 10;    }​    return (negativeFlag == true) ?                         -rev_num : rev_num;}​// Driver Codeint main(){    int num = 12345;    cout << "Reverse of no. is "          << reversDigits(num) << endl;​    num = 1000000045;    cout << "Reverse of no. is "          << reversDigits(num) << endl;​    return 0;}​// This code is contributed // by Akanksha Rai(Abby_akku)

// C program to reverse digits of a number
#include <stdio.h>

/* Iterative function to reverse digits of num*/
int reversDigits(int num)
{
    // Handling negative numbers
    bool negativeFlag = false;
    if (num < 0)
    {
        negativeFlag = true;
        num = -num ;
    }

    int prev_rev_num = 0, rev_num = 0;
    while (num != 0)
    {
        int curr_digit = num%10;

        rev_num = (rev_num*10) + curr_digit;

        // checking if the reverse overflowed or not.
        // The values of (rev_num - curr_digit)/10 and
        // prev_rev_num must be same if there was no
        // problem.
        if ((rev_num - curr_digit)/10 != prev_rev_num)
        {
            printf("WARNING OVERFLOWED!!!\n");
            return 0;
        }

        prev_rev_num = rev_num;
        num = num/10;
    }

    return (negativeFlag == true)? -rev_num : rev_num;
}

/* Driver program to test reverse Digits */
int main()
{
    int num = 12345;
    printf("Reverse of no. is %d\n", reversDigits(num));

    num = 1000000045;
    printf("Reverse of no. is %d\n", reversDigits(num));

    return 0;
}

Java

// Java program to reverse digits of a number

class ReverseDigits
{
    /* Iterative function to reverse digits of num*/
    static int reversDigits(int num)
    {
        // Handling negative numbers
        boolean negativeFlag = false;
        if (num < 0)
        {
            negativeFlag = true;
            num = -num ;
        }
     
        int prev_rev_num = 0, rev_num = 0;
        while (num != 0)
        {
            int curr_digit = num%10;
     
            rev_num = (rev_num*10) + curr_digit;
     
            // checking if the reverse overflowed or not.
            // The values of (rev_num - curr_digit)/10 and
            // prev_rev_num must be same if there was no
            // problem.
            if ((rev_num - curr_digit)/10 != prev_rev_num)
            {
                System.out.println("WARNING OVERFLOWED!!!");
                return 0;
            }
     
            prev_rev_num = rev_num;
            num = num/10;
        }
     
        return (negativeFlag == true)? -rev_num : rev_num;
    }
    
    public static void main (String[] args) 
    {
        int num = 12345;
        System.out.println("Reverse of no. is " + reversDigits(num));
     
        num = 1000000045;
        System.out.println("Reverse of no. is " + reversDigits(num));
    }
}

Python

# Python program to reverse digits 
# of a number 

""" Iterative function to reverse 
digits of num"""
def reversDigits(num): 

    # Handling negative numbers 
    negativeFlag = False
    if (num < 0):
    
        negativeFlag = True
        num = -num 
    

    prev_rev_num = 0
    rev_num = 0
    while (num != 0): 
    
        curr_digit = num % 10

        rev_num = (rev_num * 10) + curr_digit 

        # checking if the reverse overflowed or not. 
        # The values of (rev_num - curr_digit)/10 and 
        # prev_rev_num must be same if there was no 
        # problem.
        if (rev_num >= 2147483647 or 
            rev_num <= -2147483648):
            rev_num = 0
        if ((rev_num - curr_digit) // 10 != prev_rev_num):
        
            print("WARNING OVERFLOWED!!!") 
            return 0
        

        prev_rev_num = rev_num 
        num = num //10
    

    return -rev_num if (negativeFlag == True) else rev_num 




# Driver code 
if __name__ =="__main__":
    num = 12345
    print("Reverse of no. is ",reversDigits(num)) 

    num = 1000000045
    print("Reverse of no. is ",reversDigits(num)) 
        
    
# This code is contributed
# Shubham Singh(SHUBHAMSINGH10)

// C# program to reverse digits
// of a number
using System;

class GFG
{

/* Iterative function to reverse
   digits of num*/
static int reversDigits(int num) 
{ 
    // Handling negative numbers 
    bool negativeFlag = false; 
    if (num < 0) 
    { 
        negativeFlag = true; 
        num = -num ; 
    } 

    int prev_rev_num = 0, rev_num = 0; 
    while (num != 0) 
    { 
        int curr_digit = num % 10; 

        rev_num = (rev_num * 10) + 
                   curr_digit; 

        // checking if the reverse overflowed 
        // or not. The values of (rev_num - 
        // curr_digit)/10 and prev_rev_num must 
        // be same if there was no problem. 
        if ((rev_num - curr_digit) / 10 != prev_rev_num) 
        { 
            Console.WriteLine("WARNING OVERFLOWED!!!"); 
            return 0; 
        } 

        prev_rev_num = rev_num; 
        num = num / 10; 
    } 

    return (negativeFlag == true) ?
                         -rev_num : rev_num; 
} 

// Driver Code
static public void Main ()
{
    int num = 12345; 
    Console.WriteLine("Reverse of no. is " + 
                         reversDigits(num)); 

    num = 1000000045; 
    Console.WriteLine("Reverse of no. is " + 
                         reversDigits(num)); 
}
}

// This code is contributed by ajit

JavaScript

<script>
// JavaScript program to reverse digits
// of a number

/* Iterative function to reverse
digits of num*/
function reversDigits(num)
{
    // Handling negative numbers
    let negativeFlag = false;
    if (num < 0)
    {
        negativeFlag = true;
        num = -num ;
    }

    let prev_rev_num = 0, rev_num = 0;
    while (num != 0)
    {
        let curr_digit = num % 10;

        rev_num = (rev_num * 10) + curr_digit;

        // checking if the reverse overflowed or not.
        // The values of (rev_num - curr_digit)/10 and
        // prev_rev_num must be same if there was no
        // problem.
        if (rev_num >= 2147483647 ||
            rev_num <= -2147483648)
            rev_num = 0;
        if (Math.floor((rev_num - curr_digit) / 10) != prev_rev_num)
        {
            document.write("WARNING OVERFLOWED!!!"
                + "<br>");
            return 0;
        }

        prev_rev_num = rev_num;
        num = Math.floor(num / 10);
    }

    return (negativeFlag == true) ?
                        -rev_num : rev_num;
}

// Driver Code
    let num = 12345;
    document.write("Reverse of no. is "
        + reversDigits(num) + "<br>");

    num = 1000000045;
    document.write("Reverse of no. is "
        + reversDigits(num) + "<br>");





// This code is contributed by Surbhi Tyagi.
</script>

Output

Reverse of no. is 54321
WARNING OVERFLOWED!!!
Reverse of no. is 0

Time Complexity: O(log(num))
Auxiliary Space: O(1)

Efficient Approach:

The above approach won't work if we are given a signed 32-bit integer x, and return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0. So we cannot multiply the number*10 and then check if the number overflows or not.
We must check the overflow condition before multiplying by 10 by using the following logic :
You are checking the boundary case before you do the operation. (reversed >INT_MAX ) wouldn't work because reversed will overflow and become negative if it goes past MAX_VALUE. Dividing MAX_VALUE by 10 lets you check the condition without overflowing INT_MAX is equal 2147483647. INT_MIN is equal -2147483648. The last digits are 7 and 8. This is the reason why we also check rem > 7 and rem < -8 conditions

Implementation:

C++

// C++ program to reverse digits 
// of a number
#include <bits/stdc++.h>

using namespace std;
int reversDigits(int num) {
    
    int rev = 0  ;
    
    while(num != 0){         
        int rem = num % 10 ;
        num /= 10 ;
        
        if(rev > INT_MAX/10 || rev < INT_MIN/10){
            return 0 ;
        }
        
        rev = rev*10 + rem ;
    }
    
    return rev ;
    
}

// Driver Code
int main()
{
    int num = 12345;
    cout << "Reverse of no. is " 
         << reversDigits(num) << endl;

    num = 1000000045;
    cout << "Reverse of no. is " 
         << reversDigits(num) << endl;

    return 0;
}

 
// C++ program to reverse digits 
// of a number#include <bits/stdc++.h>​using namespace std;int reversDigits(int num) {        int rev = 0  ;        while(num != 0){                 int rem = num % 10 ;        num /= 10 ;                if(rev > INT_MAX/10 || rev < INT_MIN/10){            return 0 ;        }                rev = rev*10 + rem ;    }        return rev ;    }​// Driver Codeint main(){    int num = 12345;    cout << "Reverse of no. is "          << reversDigits(num) << endl;​    num = 1000000045;    cout << "Reverse of no. is "          << reversDigits(num) << endl;​    return 0;}

Java

// Java program to reverse digits
// of a number
public class GFG
{

  static int reversDigits(int num)
  {
    int rev = 0  ;

    while(num != 0){        
      int rem = num % 10 ;
      num /= 10 ;

      if(rev > Integer.MAX_VALUE/10 || rev == Integer.MAX_VALUE/10 && rem > 7){
        return 0 ;
      }

      if(rev < Integer.MIN_VALUE/10 || rev == Integer.MIN_VALUE/10 && rem < -8){
        return 0 ;
      }

      rev = rev*10 + rem ;
    }

    return rev ;
  }

  // Driver code
  public static void main (String[] args)
  {
    int num = 12345;
    System.out.println("Reverse of no. is " + reversDigits(num) );

    num = 1000000045;
    System.out.println("Reverse of no. is " + reversDigits(num) );
  }
}

// This code is contributed by jana_sayantan.

Python

def reverse_digits(num):
    # Initialize reverse number as 0
    rev = 0

    # Check sign of the number
    sign = -1 if num < 0 else 1

    # Take absolute value of the number
    num = abs(num)

    # Reverse the digits
    while num != 0:
        # Get the last digit
        rem = num % 10

        # Remove the last digit from the number
        num = num // 10

        # Check if the reverse number will overflow 32-bit integer
        if rev > 2**31//10 or (rev == 2**31//10 and rem > 7):
            return 0

        # Check if the reverse number will underflow 32-bit integer
        if rev < -2**31//10 or (rev == -2**31//10 and rem < -8):
            return 0

        # Update the reverse number
        rev = rev * 10 + rem

    # Return the reverse number with the original sign
    return sign * rev

if __name__ == '__main__':
    num = 12345
    print("Reverse of no. is", reverse_digits(num))

    num = 1000000045
    print("Reverse of no. is", reverse_digits(num))

// C# program to reverse digits
// of a number
using System;

public class GFG
{

  static int reversDigits(int num)
  {
    int rev = 0  ;

    while(num != 0){        
      int rem = num % 10 ;
      num /= 10 ;

      if(rev > Int32.MaxValue/10 || rev == Int32.MaxValue/10 && rem > 7){
        return 0 ;
      }

      if(rev < Int32.MinValue/10 || rev == Int32.MinValue/10 && rem < -8){
        return 0 ;
      }

      rev = rev*10 + rem ;
    }

    return rev ;
  }

  // Driver code
  public static void Main (string[] args)
  {
    int num = 12345;
    Console.WriteLine("Reverse of no. is " + reversDigits(num) );

    num = 1000000045;
    Console.WriteLine("Reverse of no. is " + reversDigits(num) );
  }
}

// This code is contributed by phasing17

JavaScript

<script>

// JavaScript program to reverse digits 
// of a number

const INT_MAX = 2147483647;
const INT_MIN = -2147483648;

function reversDigits(num) {
    
    let rev = 0;
    
    while(num > 0){         
        let rem = num % 10 ;
        num = Math.floor(num/10) ;
        
        if(rev > INT_MAX/10 || rev == INT_MAX/10 && rem > 7){
            return 0 ;
        }
        
        if(rev < INT_MIN/10 || rev == INT_MIN/10 && rem < -8){
            return 0 ;
        }
        
        rev = rev*10 + rem ;

    }
    
    return rev ;
    
}

// Driver Code

let num = 12345;
document.write(`Reverse of no. is ${reversDigits(num)}`,"</br>");

num = 1000000045;
document.write(`Reverse of no. is ${reversDigits(num)}`,"</br>");

// This code is contributed by shinjanpatra

</script>

Output

Reverse of no. is 54321
Reverse of no. is 0

Time Complexity: O(log(num))
Auxiliary Space: O(1)

Approach using slice method:

We convert the integer to a string, reverse the string using the slice operator, and then convert the reversed string back to an integer.

Steps:

Convert the integer to a string using the str() function
Use the slice operator [::-1] to reverse the string
Convert the reversed string back to an integer using the int() function

Implementation:

C++

#include <iostream>
#include <string>

int reverseNumStringSlice(int num)
{
    // Convert the integer to a string
    std::string numStr = std::to_string(num);

    // Reverse the string using the slice operator
    std::string reversedStr(numStr.rbegin(), numStr.rend());

    // Convert the reversed string back to an integer
    int reversedNum = std::stoi(reversedStr);

    return reversedNum;
}

int main()
{
    int num = 12345;
    int revNumStringSlice = reverseNumStringSlice(num);
    std::cout << "Reverse of " << num << " is "
              << revNumStringSlice << std::endl;

    return 0;
}

 
#include <iostream>
#include <string>​int reverseNumStringSlice(int num){    // Convert the integer to a string    std::string numStr = std::to_string(num);​    // Reverse the string using the slice operator    std::string reversedStr(numStr.rbegin(), numStr.rend());​    // Convert the reversed string back to an integer    int reversedNum = std::stoi(reversedStr);​    return reversedNum;}​int main(){    int num = 12345;    int revNumStringSlice = reverseNumStringSlice(num);    std::cout << "Reverse of " << num << " is "              << revNumStringSlice << std::endl;​    return 0;}

Java

public class ReverseNumStringSlice {
    // Function to reverse an integer using string slice
    static int reverseNumStringSlice(int num)
    {
        // Convert the integer to a string
        String numStr = Integer.toString(num);

        // Reverse the string using the substring method
        String reversedStr = new StringBuilder(numStr)
                                 .reverse()
                                 .toString();

        // Convert the reversed string back to an integer
        int reversedNum = Integer.parseInt(reversedStr);

        return reversedNum;
    }

    // Main method
    public static void main(String[] args)
    {
        // Example integer
        int num = 12345;

        // Call the reverseNumStringSlice function
        int revNumStringSlice = reverseNumStringSlice(num);

        // Output the result
        System.out.println("Reverse of " + num + " is "
                           + revNumStringSlice);
    }
}

Python

def reverse_num_string_slice(num):
    return int(str(num)[::-1])

num = 12345
rev_num_string_slice = reverse_num_string_slice(num)
print(f"Reverse of {num} is {rev_num_string_slice}")

using System;

class Program {
    static int ReverseNumStringSlice(int num)
    {
        // Convert the integer to a string
        string numStr = num.ToString();

        // Reverse the string using the slice operator
        char[] charArray = numStr.ToCharArray();
        Array.Reverse(charArray);
        string reversedStr = new string(charArray);

        // Convert the reversed string back to an integer
        int reversedNum = int.Parse(reversedStr);

        return reversedNum;
    }

    static void Main()
    {
        int num = 12345;
        int revNumStringSlice = ReverseNumStringSlice(num);
        Console.WriteLine("Reverse of " + num + " is "
                          + revNumStringSlice);
    }
}

JavaScript

function GFG(num) {
    // Convert the integer to a string
    const numStr = num.toString();
    // Reverse the string using slice operator
    const reversedStr = numStr.split('').reverse().join('');
    // Convert the reversed string back to an integer
    const reversedNum = parseInt(reversedStr, 10);
    return reversedNum;
}
// Main function
function main() {
    const num = 12345;
    // Call the function to the reverse the number
    const revNumStringSlice = GFG(num);
    // Display the result
    console.log(`Reverse of ${num} is ${revNumStringSlice}`);
}
main();

Output

Reverse of 12345 is 54321

Time complexity: O(n), where n is the number of digits in the integer.
Space complexity: O(n), where n is the number of digits in the integer, since we need to create a string of length n to store the reversed integer.

Reverse digits of an integer with overflow handled

MAZHAR IMAM KHAN

Improve

Article Tags :

Practice Tags :

Mathematical

Reverse digits of an integer with overflow handled

Similar Reads

Thank You!

What kind of Experience do you want to share?

Log in

Create Account