Reverse digits of an integer with overflow handled | Set 2
Given a 32-bit integer N. The task is to reverse N, if the reversed integer overflows, print -1 as the output.
Examples
Input: N = 123
Output: 321Input: N = -123
Output: -321Input: N = 120
Output: 21
Approach: Unlike approaches Set 1 of the article, this problem can be solved simply by using a 64-bit data structure and range of int data type [-2^31, 2^31 – 1]
- Copy the value of the given number N in a long variable
- Check if it is negative
- Now reverse the long number digit by digit, and if at any step, its value goes out of range the int type, return 0.
- Make the resultant number negative if the given number is negative
- Again check for the number to be in int range. If yes return 0, else return the reversed number.
Below is the implementation of the above approach.
C++
// C++ program for above approach #include <bits/stdc++.h> // Function to reverse digits in a number int reverseDigits( int N) { // Taking a long variable // to store the number long m = N; int neg = m < 0 ? -1 : 1; if (m * neg < pow (-2, 31) || m * neg >= pow (2, 31)) return 0; m = m * neg; long n = 0; while (m > 0) { if (n * 10 < pow (-2, 31) || n * 10 >= pow (2, 31)) return 0; n = n * 10 + m % 10; m = m / 10; } if (n * neg < pow (-2, 31) || n * neg >= pow (2, 31)) return 0; n = n * neg; return n; } // Driver Code int main() { int N = 5896; printf ( "Reverse of no. is %d" , reverseDigits(N)); return 0; } |
Java
// Java program for above approach class GFG { // Function to reverse digits in a number static int reverseDigits( int N) { // Taking a long variable // to store the number long m = N; int neg = m < 0 ? - 1 : 1 ; if (m * neg < Math.pow(- 2 , 31 ) || m * neg >= Math.pow( 2 , 31 )) return 0 ; m = m * neg; long n = 0 ; while (m > 0 ) { if (n * 10 < Math.pow(- 2 , 31 ) || n * 10 >= Math.pow( 2 , 31 )) return 0 ; n = n * 10 + m % 10 ; m = m / 10 ; } if (n * neg < Math.pow(- 2 , 31 ) || n * neg >= Math.pow( 2 , 31 )) return 0 ; n = n * neg; return ( int ) n; } // Driver Code public static void main(String args[]) { int N = 5896 ; System.out.println( "Reverse of no. is " + reverseDigits(N)); } } // This code is contributed by Saurabh Jaiswal |
Python3
# Python code for the above approach # Function to reverse digits in a number def reverseDigits(N): # Taking a long variable # to store the number m = N neg = - 1 if m < 0 else 1 if (m * neg < ( - 2 * * 31 ) or m * neg > = ( 2 * * 31 )): return 0 m = m * neg n = 0 while (m > 0 ): if (n * 10 < ( - 2 * * 31 ) or n * 10 > = ( 2 * * 31 )): return 0 n = n * 10 + m % 10 m = (m / / 10 ) if (n * neg < ( - 2 * * 31 ) or n * neg > = ( 2 * * 31 )): return 0 n = n * neg return n # Driver Code N = 5896 print (f "Reverse of no. is {reverseDigits(N)}" ) # This code is contributed by gfgking |
C#
// C# program for above approach using System; class GFG { // Function to reverse digits in a number static int reverseDigits( int N) { // Taking a long variable // to store the number long m = N; int neg = m < 0 ? -1 : 1; if (m * neg < Math.Pow(-2, 31) || m * neg >= Math.Pow(2, 31)) return 0; m = m * neg; long n = 0; while (m > 0) { if (n * 10 < Math.Pow(-2, 31) || n * 10 >= Math.Pow(2, 31)) return 0; n = n * 10 + m % 10; m = m / 10; } if (n * neg < Math.Pow(-2, 31) || n * neg >= Math.Pow(2, 31)) return 0; n = n * neg; return ( int )n; } // Driver Code public static void Main() { int N = 5896; Console.Write( "Reverse of no. is " + reverseDigits(N)); } } // This code is contributed by Samim Hossain Mondal. |
Javascript
<script> // JavaScript code for the above approach // Function to reverse digits in a number function reverseDigits(N) { // Taking a long variable // to store the number let m = N; let neg = m < 0 ? -1 : 1; if (m * neg < Math.pow(-2, 31) || m * neg >= Math.pow(2, 31)) return 0; m = m * neg; let n = 0; while (m > 0) { if (n * 10 < Math.pow(-2, 31) || n * 10 >= Math.pow(2, 31)) return 0; n = n * 10 + m % 10; m = Math.floor(m / 10); } if (n * neg < Math.pow(-2, 31) || n * neg >= Math.pow(2, 31)) return 0; n = n * neg; return n; } // Driver Code let N = 5896; document.write(`Reverse of no. is ${reverseDigits(N)}`); // This code is contributed by Potta Lokesh </script> |
Reverse of no. is 6985
Time Complexity: O(D), where D is the number of digits in N.
Auxiliary Space: O(1)
Another Approach:
- Define a function “reverse” that takes an integer “n” as input.
- Initialize a variable “rev” to 0 to store the reversed integer.
- Iterate through each digit of the input integer by dividing it by 10 until it becomes 0.
- In each iteration, find the remainder of the input integer when divided by 10, which gives the current digit.
- Check if the current value of “rev” will cause an overflow or underflow when multiplied by 10 and added to the current digit.
- If it will cause an overflow or underflow, return -1 to indicate that the reversed integer has overflowed.
- Otherwise, multiply the current value of “rev” by 10 and add the current digit to it to reverse the integer.
- After reversing the integer, print the value of “rev”.
Below is the implementation of the above approach:
C++
// C++ program for the above approach #include <iostream> // required for INT_MAX and INT_MIN constants #include <limits.h> using namespace std; // Function to reverse the digit int reverse( int n) { int rev = 0; while (n != 0) { int rem = n % 10; // overflow condition if (rev > INT_MAX / 10 || (rev == INT_MAX / 10 && rem > 7)) { return -1; } // underflow condition if (rev < INT_MIN / 10 || (rev == INT_MIN / 10 && rem < -8)) { return -1; } rev = rev * 10 + rem; n /= 10; } return rev; } // Driver Code int main() { int n = 5896; int rev = reverse(n); if (rev == -1) { cout << "-1" << endl; } else { cout << rev << endl; } return 0; } |
Java
import java.util.*; public class Main { // Function to reverse the digit public static int reverse( int n) { int rev = 0 ; while (n != 0 ) { int rem = n % 10 ; // overflow condition if (rev > Integer.MAX_VALUE / 10 || (rev == Integer.MAX_VALUE / 10 && rem > 7 )) { return - 1 ; } // underflow condition if (rev < Integer.MIN_VALUE / 10 || (rev == Integer.MIN_VALUE / 10 && rem < - 8 )) { return - 1 ; } rev = rev * 10 + rem; n /= 10 ; } return rev; } // Driver Code public static void main(String[] args) { int n = 5896 ; int rev = reverse(n); if (rev == - 1 ) { System.out.println( "-1" ); } else { System.out.println(rev); } } } // This code is contributed by rudra1807raj |
Python3
def reverse(n): rev = 0 while n ! = 0 : rem = n % 10 # Overflow condition if rev > 2 * * 31 / / 10 or (rev = = 2 * * 31 / / 10 and rem > 7 ): return - 1 # Underflow condition if rev < - 2 * * 31 / / 10 or (rev = = - 2 * * 31 / / 10 and rem < - 8 ): return - 1 rev = rev * 10 + rem n / / = 10 return rev # Driver Code n = 5896 rev = reverse(n) if rev = = - 1 : print ( "-1" ) else : print (rev) |
C#
using System; public class GFG { // Function to reverse the digit public static int Reverse( int n) { int rev = 0; while (n != 0) { int rem = n % 10; // overflow condition if (rev > int .MaxValue / 10 || (rev == int .MaxValue / 10 && rem > 7)) { return -1; } // underflow condition if (rev < int .MinValue / 10 || (rev == int .MinValue / 10 && rem < -8)) { return -1; } rev = rev * 10 + rem; n /= 10; } return rev; } public static void Main() { int n = 5896; int rev = Reverse(n); if (rev == -1) { Console.WriteLine( "-1" ); } else { Console.WriteLine(rev); } } } |
Javascript
// JavaScript program for the above approach // Function to reverse the digit function reverse(n) { let rev = 0; while (n !== 0) { let rem = n % 10; // overflow condition if (rev > Number.MAX_SAFE_INTEGER / 10 || (rev === Number.MAX_SAFE_INTEGER / 10 && rem > 7)) { return -1; } // underflow condition if (rev < Number.MIN_SAFE_INTEGER / 10 || (rev === Number.MIN_SAFE_INTEGER / 10 && rem < -8)) { return -1; } rev = rev * 10 + rem; n = Math.trunc(n / 10); } return rev; } // Driver Code let n = 5896; let rev = reverse(n); if (rev === -1) { console.log( "-1" ); } else { console.log(rev); } // This code is contributed by rudra1807raj |
6985
Time Complexity: The reverse() function iterates through each digit of the input integer n, so the time complexity of the function is O(log n), where n is the magnitude of the input integer.
Auxiliary Space: The space complexity is O(1)