Write a program to reverse digits of a number
Last Updated :
18 Oct, 2023
Write a program to reverse the digits of an integer.
Examples :
Input : num = 12345
Output: 54321
Input : num = 876
Output: 678
Flowchart:
ITERATIVE WAY
Algorithm:
Input: num
(1) Initialize rev_num = 0
(2) Loop while num > 0
(a) Multiply rev_num by 10 and add remainder of num
divide by 10 to rev_num
rev_num = rev_num*10 + num%10;
(b) Divide num by 10
(3) Return rev_num
Example:
num = 4562
rev_num = 0
rev_num = rev_num *10 + num%10 = 2
num = num/10 = 456
rev_num = rev_num *10 + num%10 = 20 + 6 = 26
num = num/10 = 45
rev_num = rev_num *10 + num%10 = 260 + 5 = 265
num = num/10 = 4
rev_num = rev_num *10 + num%10 = 2650 + 4 = 2654
num = num/10 = 0
Program:
C
#include <stdio.h>
int reverseDigits(int num)
{
int rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
}
int main()
{
int num = 4562;
printf("Reverse of no. is %d", reverseDigits(num));
getchar();
return 0;
}
|
C++
#include <bits/stdc++.h>
using namespace std;
int reverseDigits(int num)
{
int rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
}
int main()
{
int num = 4562;
cout << "Reverse of no. is " << reverseDigits(num);
getchar();
return 0;
}
|
Java
class GFG {
static int reverseDigits(int num)
{
int rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
}
public static void main(String[] args)
{
int num = 4562;
System.out.println("Reverse of no. is "
+ reverseDigits(num));
}
}
|
Python
n = 4562
rev = 0
while(n > 0):
a = n % 10
rev = rev * 10 + a
n = n // 10
print(rev)
|
C#
using System;
class GFG {
static int reverseDigits(int num)
{
int rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
}
public static void Main()
{
int num = 4562;
Console.Write("Reverse of no. is "
+ reverseDigits(num));
}
}
|
PHP
<?php
function reverseDigits($num)
{
$rev_num = 0;
while($num > 1)
{
$rev_num = $rev_num * 10 +
$num % 10;
$num = (int)$num / 10;
}
return $rev_num;
}
$num = 4562;
echo "Reverse of no. is ",
reverseDigits($num);
?>
|
Javascript
<script>
let num = 4562;
function reverseDigits(num) {
let rev_num = 0;
while(num > 0)
{
rev_num = rev_num * 10 + num % 10;
num = Math.floor(num / 10);
}
return rev_num;
}
document.write(reverseDigits(num));
</script>
|
Output
Reverse of no. is 2654
Time Complexity: O(log10 n), where n is the input number.
Auxiliary Space: O(1)
RECURSIVE WAY :
C
#include <stdio.h>
int reverseDigits(int num)
{
static int rev_num = 0;
static int base_pos = 1;
if (num > 0) {
reverseDigits(num / 10);
rev_num += (num % 10) * base_pos;
base_pos *= 10;
}
return rev_num;
}
int main()
{
int num = 4562;
printf("Reverse of no. is %d", reverseDigits(num));
getchar();
return 0;
}
|
C++
#include <bits/stdc++.h>
using namespace std;
int reverseDigits(int num)
{
static int rev_num = 0;
static int base_pos = 1;
if (num > 0) {
reverseDigits(num / 10);
rev_num += (num % 10) * base_pos;
base_pos *= 10;
}
return rev_num;
}
int main()
{
int num = 4562;
cout << "Reverse of no. is " << reverseDigits(num);
return 0;
}
|
Java
class GFG {
static int rev_num = 0;
static int base_pos = 1;
static int reverseDigits(int num)
{
if (num > 0) {
reverseDigits(num / 10);
rev_num += (num % 10) * base_pos;
base_pos *= 10;
}
return rev_num;
}
public static void main(String[] args)
{
int num = 4562;
System.out.println(reverseDigits(num));
}
}
|
Python3
rev_num = 0
base_pos = 1
def reverseDigits(num):
global rev_num
global base_pos
if(num > 0):
reverseDigits((int)(num / 10))
rev_num += (num % 10) * base_pos
base_pos *= 10
return rev_num
num = 4562
print("Reverse of no. is ",
reverseDigits(num))
|
C#
using System;
class GFG {
static int rev_num = 0;
static int base_pos = 1;
static int reverseDigits(int num)
{
if (num > 0) {
reverseDigits(num / 10);
rev_num += (num % 10) * base_pos;
base_pos *= 10;
}
return rev_num;
}
public static void Main()
{
int num = 4562;
Console.WriteLine(reverseDigits(num));
}
}
|
PHP
<?php
$rev_num = 0;
$base_pos = 1;
function reversDigits($num)
{
global $rev_num;
global $base_pos;
if($num > 0)
{
reverseDigits((int)($num / 10));
$rev_num += ($num % 10) *
$base_pos;
$base_pos *= 10;
}
return $rev_num;
}
$num = 4562;
echo "Reverse of no. is ",
reverseDigits($num);
?>
|
Javascript
<script>
var rev_num = 0;
var base_pos = 1;
function reversDigits(num)
{
if(num > 0)
{
reverseDigits(Math.floor(num/10));
rev_num += (num%10)*base_pos;
base_pos *= 10;
}
return rev_num;
}
let num = 4562;
document.write("Reverse of no. is "
+ reverseDigits(num));
</script>
|
Output
Reverse of no. is 2654
Time Complexity: O(log(n))
Auxiliary Space: O(log(n)), where n is the input number.
Using Recursion, without extra variable
C++
#include <iostream>
#include <math.h>
using namespace std;
int len(int number)
{
return log10(number) + 1;
}
int rev_number(int& number)
{
if ((number % 10) == number)
return number;
int last = number % 10;
int remaining = number / 10;
int l = len(remaining);
return last * pow(10, l) + rev_number(remaining);
}
int main()
{
int number = 123456;
cout << rev_number(number) << endl;
return 0;
}
|
Java
import java.lang.Math;
import java.util.*;
class GFG {
public static int len(int number)
{
return (int)(Math.log10(number)) + 1;
}
public static int rev_number(int number)
{
if (number % 10 == number) {
return number;
}
int last = number % 10;
int remaining = number / 10;
int l = len(remaining);
return last * (int)Math.pow(10, l)
+ rev_number(remaining);
}
public static void main(String[] args)
{
int number = 123456;
System.out.println(rev_number(number));
}
}
|
Python3
def number_length(num):
return len(str(num))
def rev_number(number):
if (number % 10) == number:
return number
last = number % 10
remaining = number // 10
l = number_length(remaining)
return last*pow(10, l) + rev_number(remaining)
def main():
number = 123456
print(rev_number(number))
if __name__ == "__main__":
main()
|
C#
using System;
public class GFG {
public static int length(int num)
{
return (int)Math.Log10(num) + 1;
}
static int rev_number(int num)
{
if ((num % 10) == num)
return num;
int last = num % 10;
int remaining = num / 10;
int l = length(remaining);
return last * (int)Math.Pow(10, l)
+ rev_number(remaining);
}
static public void Main()
{
int num = 123456;
Console.Write(rev_number(num));
}
}
|
Javascript
<script>
function length(number){
return ~~(Math.log10(number))+1;
}
function rev_number(num){
if ((num % 10) == num)
return num;
let last = ~~(num % 10);
let remain = ~~(num / 10);
let l = length(remain);
return last * ~~(Math.pow(10, l)) + rev_number(remain);
}
let num = 123456;
document.write(rev_number(num));
</script>
|
PHP
<?php
function length($num){
return (int)(log10($num))+1;
}
function rev_number($num){
if (($num % 10) == $num)
return $num;
$last = ($num % 10);
$remain = (int)($num / 10);
$l = length($remain);
return $last * (int)(pow(10, $l)) + rev_number($remain);
}
$num = 123456;
echo rev_number($num);
?>
|
Time Complexity: O(log10n) where n is the given input number.
Auxiliary Space: O(log10n) for recursive stack space.
Using String in java
We will convert the number to a string using StringBuffer after this, we will reverse that string using the reverse() method
corner case
Input: 32100
So for the above input if we try to solve this by reversing the string, then the output will be 00123.
So to deal with this situation we again need to convert the string to integer so that our output will be 123
C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void reverse(char* begin, char* end)
{
char temp;
while (begin < end) {
temp = *begin;
*begin++ = *end;
*end-- = temp;
}
}
void reverseWords(char* s)
{
char* word_begin = s;
char* temp = s;
while (*temp) {
temp++;
if (*temp == '\0') {
reverse(word_begin, temp - 1);
}
else if (*temp == ' ') {
reverse(word_begin, temp - 1);
word_begin = temp + 1;
}
}
reverse(s, temp - 1);
}
int reverseDigits(int num)
{
char strin[100];
sprintf(strin, "%d", num);
reverseWords(strin);
num = atoi(strin);
return num;
}
int main()
{
int num = 123456;
printf("Reverse of no. is %d", reverseDigits(num));
return 0;
}
|
C++
#include <bits/stdc++.h>
using namespace std;
int reverseDigits(int num)
{
string strin = to_string(num);
reverse(strin.begin(), strin.end());
num = stoi(strin);
return num;
}
int main()
{
int num = 4562;
cout << "Reverse of no. is " << reverseDigits(num);
return 0;
}
|
Java
public class GFG {
static int reversDigits(int num)
{
StringBuffer string
= new StringBuffer(String.valueOf(num));
string.reverse();
num = Integer.parseInt(String.valueOf(string));
return num;
}
public static void main(String[] args)
{
int num = 4562;
System.out.println("Reverse of no. is "
+ reversDigits(num));
}
}
|
Python3
def reversDigits(num):
string = str(num)
string = list(string)
string.reverse()
string = ''.join(string)
num = int(string)
return num
if __name__ == "__main__":
num = 4562
print("Reverse of no. is ", reversDigits(num))
|
C#
using System;
public class GFG {
public static string ReverseString(string s)
{
char[] array = s.ToCharArray();
Array.Reverse(array);
return new string(array);
}
static int reversDigits(int num)
{
string strin = num.ToString();
strin = ReverseString(strin);
num = int.Parse(strin);
return num;
}
static public void Main()
{
int num = 4562;
Console.Write("Reverse of no. is "
+ reversDigits(num));
}
}
|
Javascript
<script>
function reversDigits(num)
{
let str
= num.toString().split("").reverse().join("");
num = parseInt(str);
return str;
}
let num = 4562;
document.write("Reverse of no. is "
+ reversDigits(num));
</script>
|
PHP
<?php
function reverseDigits($num)
{
$strin = strval($num);
$strin = strrev($strin);
$num = (int)($strin);
return $num;
}
$num = 123456;
echo "Reverse of no. is ". reverseDigits($num);
?>
|
Output
Reverse of no. is 123456
Time Complexity: O(log10n) where n is the input number
Auxiliary Space: O(1)
Reverse digits of an integer with overflow handled
Note that the above program doesn’t consider leading zeroes. For example, for 100 programs will print 1. If you want to print 001 then see this comment from Maheshwar.
Using Slicing in Python:
C++
#include <bits/stdc++.h>
using namespace std;
int reverseDigits(int num)
{
string str = to_string(num);
reverse(str.begin(), str.end());
num = stoll(str);
return num;
}
int main()
{
int num = 4562;
cout << "Reverse of no. is " << reverseDigits(num);
return 0;
}
|
Java
import java.util.*;
class GFG {
static int reversDigits(int num)
{
String str = String.valueOf(num);
str = new StringBuilder(str).reverse().toString();
num = Integer.valueOf(str);
return num;
}
public static void main(String[] args)
{
int num = 4562;
System.out.println("Reverse of no. is "
+ reversDigits(num));
}
}
|
Python3
def reversDigits(num):
string = str(num)
string = string[::-1]
num = int(string)
return num
if __name__ == "__main__":
num = 4562
print("Reverse of no. is ", reversDigits(num))
|
C#
using System;
class GFG {
static int reversDigits(int num)
{
string str = Convert.ToString(num);
char[] charArray = str.ToCharArray();
Array.Reverse(charArray);
str = new string(charArray);
num = Convert.ToInt32(str);
return num;
}
public static void Main(string[] args)
{
int num = 4562;
Console.Write("Reverse of no. is "
+ reversDigits(num));
}
}
|
Javascript
function reversDigits(num){
let str = num.toString().split("");
str.reverse();
num = parseInt(str.join(""))
return num;
}
let num = 4562;
console.log("Reverse of no. is " + reversDigits(num));
|
Output
Reverse of no. is 2654
Time Complexity: O(n), where n is the input number
Auxiliary Space: O(1)
Try extensions of above functions that should also work for floating-point numbers.
Divide and Conquer:
Algorithm:
Input: n
(1) Initialize rev1=0, rev2=0
(2) Compute no of digits in given input n and store it in size variable.
(3) Divide the number n into two parts i.e first_half and second_half.
(4) Loop for i in range(mid):
(a) Remainder of first_half by 10 add it to the multiplication of 10 and rev1.
rem=first_half%10
rev1=10*rev1+rem
(b) Remainder of second_half by 10 add it to the multiplication of 10 and rev2.
rem=second_half%10
rev2=10*rev2+rem
(c) Divide first_half and second_half with 10.
first_half=first_half//10
second_half=second_half//10
(5)if size is even.
return rev2*10**mid+rev1
otherwise
return (rev2*10**mid+rev1)*10+first_half
C++
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
long int n,first_half,second_half,rem,rev1,rev2,size,mid;
n=1234;
rev1=0,rev2=0;
size=floor(log10(n)+1);
mid=size/2;
first_half=n/pow(10,mid);
second_half=n%(long int)(pow(10,mid)+0.5);
for(int i=0; i<mid; i++)
{
rem=first_half%10;
rev1=10*rev1+rem;
rem=second_half%10;
rev2=10*rev2+rem;
first_half=first_half/10;
second_half=second_half/10;
}
cout<<"Original no: "<<n<<endl;
if(size%2==0)
{
cout<<"Reversed no: "<<rev2*(long int)(pow(10,mid)+0.5)+rev1;
}
else{
cout<<"Reversed no: "<<(rev2*(long int)(pow(10,mid)+0.5)+rev1)*10+first_half;
}
return 0;
}
|
Java
import java.lang.Math;
class Main
{
public static void main (String[] args)
{
int n,first_half,second_half,rem,rev1=0,rev2=0,size,mid;
n=1234;
size=(int) Math.log10(n)+1;
mid=(int) size/2;
first_half=(int) (n/Math.pow(10,mid));
second_half=n%(int) (Math.pow(10,mid));
for(int i=0; i<mid; i++)
{
rem=first_half%10;
rev1=10*rev1+rem;
rem=second_half%10;
rev2=10*rev2+rem;
first_half=first_half/10;
second_half=second_half/10;
}
System.out.println("Original no: "+n);
if(size%2==0)
{
System.out.println("Reversed no: "+(rev2*(int)(Math.pow(10,mid))+rev1));
}
else{
System.out.println("Reversed no: "+((rev2*(int)(Math.pow(10,mid)+0.5)+rev1)*10+first_half));
}
}
}
|
Python3
import math
n = 1234
rev1 = 0
rev2 = 0
size = int(math.log10(n))+1
mid = size//2
first_half = n//10**mid
second_half = n % 10**mid
for i in range(mid):
rem = first_half % 10
rev1 = 10*rev1+rem
rem = second_half % 10
rev2 = 10*rev2+rem
first_half = first_half//10
second_half = second_half//10
print('Original no:', n)
if(size % 2 == 0):
print('Reversed no:', rev2*10**mid+rev1)
else:
print('Reversed no:', (rev2*10**mid+rev1)*10+first_half)
|
C#
using System;
class Program
{
static void Main(string[] args)
{
int first_Half, second_Half, rem, rev1 = 0, rev2 = 0, size, mid;
int n = 1234;
size = (int)Math.Log10(n) + 1;
mid = size / 2;
first_Half = (int)(n / Math.Pow(10, mid));
second_Half = n % (int)(Math.Pow(10, mid));
for (int i = 0; i < mid; i++)
{
rem = first_Half % 10;
rev1 = 10 * rev1 + rem;
rem = second_Half % 10;
rev2 = 10 * rev2 + rem;
first_Half /= 10;
second_Half /= 10;
}
Console.WriteLine("Original no: " + n);
if (size % 2 == 0)
{
Console.WriteLine("Reversed no: " + (rev2 * (int)(Math.Pow(10, mid)) + rev1));
}
else
{
Console.WriteLine("Reversed no: " + ((rev2 * (int)(Math.Pow(10, mid) + 0.5) + rev1) * 10 + first_Half));
}
}
}
|
Javascript
let n = 1234;
let rev1 = 0;
let rev2 = 0;
let size = Math.floor(Math.log10(n)) + 1;
let mid = Math.floor(size / 2);
let firstHalf = Math.floor(n / 10 ** mid);
let secondHalf = n % 10 ** mid;
for (let i = 0; i < mid; i++) {
let rem = firstHalf % 10;
rev1 = rev1 * 10 + rem;
let rem2 = secondHalf % 10;
rev2 = rev2 * 10 + rem2;
firstHalf = Math.floor(firstHalf / 10);
secondHalf = Math.floor(secondHalf / 10);
}
console.log("Original no:", n);
if (size % 2 == 0) {
console.log("Reversed no:", rev2 * 10 ** mid + rev1);
}
else {
console.log("Reversed no:",
(rev2 * 10 ** mid + rev1) * 10 + firstHalf);
}
|
Output
Original no: 1234
Reversed no: 4321
Time Complexity: O(log10(half no of digits in number)), the number indicates given input.
Auxiliary Space: O(1).
using divide and conquer:
We will divide the given number into two parts after this, reverse the first half and second half and join them.
