Open In App

# Reverse digits of an integer with overflow handled

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 ``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)`

## C

 `// A simple C program to reverse digits of``// an integer.``#include ` `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)`

## Python3

 `# 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#

 `// 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)`

## PHP

 ``

## Javascript

 ``

Output

`Reverse of no. is 6985`

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

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. See this for the output.
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 ` `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

 `// C program to reverse digits of a number``#include ` `/* 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));``    ``}``}`

## Python3

 `# 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#

 `// 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

 ``

Output

```Reverse of no. is 54321
Reverse of no. is 1105032705```

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

## C++

 `// C++ program to reverse digits``// of a number``#include ` `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_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``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;``}`

## 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.`

## Python3

 `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#

 `// 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

 ``

Output

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

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

This article is contributed by MAZHAR IMAM KHAN. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

METHOD 4:Using the slice approach

APPROACH:

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

ALGORITHM:

1. Convert the integer to a string using the str() function

2.Use the slice operator [::-1] to reverse the string

3. Convert the reversed string back to an integer using the int() function

## Python3

 `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}"``)`

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.