Write a program to reverse digits of a number

Try it on GfG Practice

Given an Integer n, find the reverse of its digits.

Examples:  

Input: n = 122
Output: 221
Explanation: By reversing the digits of number, number will change into 221.

Input: n = 200
Output: 2
Explanation: By reversing the digits of number, number will change into 2.

Input: n = 12345
Output: 54321
Explanation: By reversing the digits of number, number will change into 54321.

Reversing Digit by Digit

This idea for this approach is to repeatedly extract the last digit of n using the modulus operator (n % 10) and appending it to the reverse number (revNum). After extracting the digit, the number n is reduced by dividing it by 10 (n = n / 10). This process continues until n becomes 0. Finally, the reversed number (revNum) is returned.

#include <bits/stdc++.h>

using namespace std;

int reverseDigits(int n) {
    int revNum = 0;
    while (n > 0) {
        revNum = revNum * 10 + n % 10;
        n = n / 10;
    }
    return revNum;
}

int main() {
    int n = 4562;
    cout << reverseDigits(n);
    return 0;
}

#include <stdio.h>

int reverseDigits(int n) {
    int revNum = 0;
    while (n > 0) {
        revNum = revNum * 10 + n % 10;
        n = n / 10;
    }
    return revNum;
}

int main() {
    int n = 4562;
    printf("%d",reverseDigits(n));
    getchar();
    return 0;
}

// Java program to reverse a number
class GfG {
    static int reverseDigits(int n) {
        int revNum = 0;
        while (n > 0) {
            revNum = revNum * 10 + n % 10;
            n = n / 10;
        }
        return revNum;
    }
  
    public static void main(String[] args) {
        int num = 4562;
        System.out.println(reverseDigits(num));
    }
}

n = 4562
rev = 0

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

print(rev)

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

class GfG {
    static int reverseDigits(int n) {
        int revNum = 0;
        while (n > 0) {
            revNum = revNum * 10 + n % 10;
            n = n / 10;
        }
        return revNum;
    }

    public static void Main() {
        int num = 4562;
        Console.Write(reverseDigits(num));
    }
}

    let num = 4562;

    function reverseDigits(n) {
        let revNum = 0;
        while(n > 0)
        {
            revNum = revNum * 10 + n % 10;
            n = Math.floor(n / 10);
        }
        return revNum;
    }
    
 // function call   
    console.log(reverseDigits(num));

2654

Time Complexity - O(log n)
Space Complexity - O(1)

Using Recursion

This approach uses a recursive function reverseDigits called with the number n and an accumulator variable revNum to store the reversed number, and basePos to keep track of the place value (ones, tens, hundreds, etc.). In each recursive call, the function processes the current digit by dividing n by 10 to reduce it and adding the last digit (n % 10) to revNum, scaled by the basePos. The basePos is then multiplied by 10 to move to the next place value.

#include <bits/stdc++.h>
using namespace std;

void reverseDigits(int n, int &revNum, int &basePos) {
    if (n > 0) {
        reverseDigits(n / 10, revNum, basePos);  
        revNum += (n % 10) * basePos;             
        basePos *= 10;
    }
}

int main() {
    int n = 4562;
    int revNum = 0;
    int basePos = 1;
    reverseDigits(n, revNum, basePos);  
    cout << revNum;
    return 0;
}

#include <stdio.h>

void reverseDigits(int n, int *revNum, int *basePos) {
    if (n > 0) {
        reverseDigits(n / 10, revNum, basePos);
        *revNum += (n % 10) * (*basePos);        
        *basePos *= 10;                           
    }
}

int main() {
    int n = 4562;
    int revNum = 0;
    int basePos = 1;
    reverseDigits(n, &revNum, &basePos);  
    printf("%d", revNum);
    return 0;
}

class Solution {
    
    // Function to reverse digits recursively
    public void reverseDigits(int n, int[] revNum, int[] basePos) {
        if (n > 0) {
            
            reverseDigits(n / 10, revNum, basePos);  
            
             // Add current digit with its base position
            revNum[0] += (n % 10) * basePos[0];     
            basePos[0] *= 10;                         
        }
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int n = 4562;
        int[] revNum = {0};  
        int[] basePos = {1};  
        solution.reverseDigits(n, revNum, basePos);
        System.out.println(revNum[0]);  
    }
}

def reverseDigits(n, revNum, basePos):
    if n > 0:
        reverseDigits(n // 10, revNum, basePos)  
        revNum[0] += (n % 10) * basePos[0]       
        basePos[0] *= 10                         

# Driver code
n = 4562
revNum = [0]  
basePos = [1]  
reverseDigits(n, revNum, basePos)
print(revNum[0]) 

// C# program to reverse digits of a number

using System;
class GfG {
    static int reverseDigits(int n) {
         int revNum = 0;
   		 int basepos = 1;
        if (n > 0) {
            reverseDigits(n / 10);
            revNum += (n % 10) * basepos;
            basepos *= 10;
        }
        return revNum;
    }

    public static void Main() {
        int n = 4562;
        Console.WriteLine(reverseDigits(n));
    }
}

class Solution {
    
    // Function to reverse digits recursively
    reverseDigits(n, revNum, basePos) {
        if (n > 0) {
            this.reverseDigits(Math.floor(n / 10), revNum, basePos);  
            revNum[0] += (n % 10) * basePos[0];                        
            basePos[0] *= 10;                                           
        }
    }
}

// Driver code
let solution = new Solution();
let n = 4562;
let revNum = [0];  
let basePos = [1]; 
solution.reverseDigits(n, revNum, basePos);
console.log(revNum[0]);  

2654

Time Complexity - O(log n)
Space Complexity - O(log n)

Using String

This approach reverses a number by converting it into a string, reversing the string, and then converting it back into an integer. This avoids manual digit manipulation by leveraging string operations. The string reversal is done using a built-in function, and the result is then converted back to an integer and returned. This method is straightforward but requires extra space for the string conversion.

// C++ program to reverse a number
#include <bits/stdc++.h>
using namespace std;

int reverseDigits(int n) {
    
    // converting number to string
    string s = to_string(n);

    // reversing the string
    reverse(s.begin(), s.end());

    // converting string to integer
    n = stoi(s);

    // returning integer
    return n;
}
int main() {
    int n = 4562;
    cout << reverseDigits(n);
    return 0;
}

// C program to reverse a number
#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;

    // Reversing individual words as explained in the first step
    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 n) {
    char strin[100];
    sprintf(strin, "%d", n);

    // reversing the string
    reverseWords(strin);

    // converting string to integer
    n = atoi(strin);

    return n;
}

int main() {
    int n = 123456;
    printf("%d\n",reverseDigits(n));
    return 0;
}

// Java program to reverse a number

 class GfG {
    static int reversDigits(int n) {
        // converting number to string
        StringBuffer s
            = new StringBuffer(String.valueOf(n));

        // reversing the string
        s.reverse();

        // converting string to integer
        n = Integer.parseInt(String.valueOf(s));

        // returning integer
        return n;
    }
   
    public static void main(String[] args) {
        int n = 4562;
        System.out.println(reversDigits(n));
    }
}

# Python 3 program to reverse a number
def reversDigits(n):

    # converting number to string
    s = str(n)

    # reversing the string
    s = list(s)
    s.reverse()
    s = ''.join(s)

    # converting string to integer
    n = int(s)
    return n

if __name__ == "__main__":

    num = 4562
    print(reversDigits(num))

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

public class GfG {

    static string ReverseString(string s) {
        char[] array = s.ToCharArray();
        Array.Reverse(array);
        return new string(array);
    }

    static int reversDigits(int n) {
        // converting number to string
        string s = n.ToString();

        // reversing the string
        s = ReverseString(s);

        // converting string to integer
        n = int.Parse(s);

        // returning integer
        return n;
    }

    static public void Main()  {
        int n = 4562;
        Console.Write(reversDigits(n));
    }
}

// Javascript program to reverse a number

    function reversDigits(n) {
        // converting number to string
        let s = n.toString().split("").reverse().join("");
        
        // converting string to integer
        n = parseInt(s);

        // returning integer
        return s;
    }

// Driver Code
    
    let n = 4562;
    console.log(reversDigits(n));

2654

Time Complexity - O(log n)
Space Complexity - O(1)

Note: The above program doesn't consider leading zeroes. For example, for 100 programs will print 1. If you want to print 001

Using String and Slicing in Python

The approach used is "Using Slicing". This technique involves converting the number into a string, then reversing that string by using slicing operations. After reversing, the string is converted back into a number. This method is simple and efficient but requires additional space for storing the string representation of the number.

# Python 3 program to reverse a number
def reversDigits(n):

    # converting number to string
    s = str(n)

    # reversing the string
    s = s[::-1]

    # converting string to integer
    n = int(s)

    # returning integer
    return n

if __name__ == "__main__":

    n = 4562
    print(reversDigits(n))

2654

Time Complexity - O(n)
Space Complexity - O(n)