Reverse a number

Beginner Problems Basic Maths Easy

Fun Fact: Reversing the digits of a number is often used in designing certain algorithms and applications, such as in credit card number processing or generating unique access codes
This kind of problem strengthens understanding of basic manipulation and conversion of data types, especially in languages that treat strings and integers distinctly

You are given an integer n. Return the integer formed by placing the digits of n in reverse order.

Examples:

Input: n = 25

Output: 52

Explanation: Reverse of 25 is 52.

Input: n = 123

Output: 321

Explanation: Reverse of 123 is 321.

Input: n = 54

Constraints

0 <= n <= 5000
n will contain no leading zeroes except when it is 0 itself.

Company Tags

TCS Cognizant Accenture Infosys Capgemini Wipro IBM HCL Tech Mahindra MindTree

Editorial

Intuition:

Given a number, it can be reversed if all the digits are extracted from the end of the original number and pushed at the back of a new reversed number.

Approach:

Initialize a reversed number with zero, which will store the reversed number. To push any digit at the end of the reversed number, the following mathematical operation can be used:
revNum = (revNum * 10) + digit.
The last digit of the original number can be found by using the modulus operator (used to find the remainder for any division) with the number 10.
Iterate on the original number till there are digits left. In every iteration, extract the last (rightmost) digit and push it at the back of the reversed number. Also, divide the original number by 10 so that the remaining digits can be extracted in the next iterations.
Once the iterations are over, the reversed number will be stored in the reverse of the original number.

Dry Run:

Solution:

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

class Solution {
public:
    // Function to reverse given number n
    int reverseNumber(int n) {
        /* After the code, revNum will
        contain the reversed number */
        int revNum = 0;

        /* Keep on iterating while there
        are digits left to extract */
        while(n > 0) {
            int lastDigit = n % 10;

            /* Pushing last digit at the
            back of reversed number */
            revNum = (revNum * 10) + lastDigit;
            n = n / 10;
        }
        
        return revNum;
    }
};

int main()
{
    int n = 6678;
    
    /* Creating an instance of 
    Solution class */
    Solution sol; 
    
    // Function call to reverse the digits in n
    int ans = sol.reverseNumber(n);
    cout << "The reverse of given number is: " << ans;
    
    return 0;
}
class Solution {
    // Function to reverse given number n
    public int reverseNumber(int n) {
        /* After the code, revNum will
        contain the reversed number */
        int revNum = 0;
        
        /* Keep on iterating while there
        are digits left to extract */
        while (n > 0) {
            int lastDigit = n % 10;

            /* Pushing last digit at the
            back of reversed number */
            revNum = (revNum * 10) + lastDigit;
            n = n / 10;
        }
        
        return revNum;
    }

    public static void main(String[] args) {
        int n = 6678;
        
        /* Creating an instance of 
        Solution class */
        Solution sol = new Solution();
        
        // Function call to reverse the digits in n
        int ans = sol.reverseNumber(n);
        System.out.println("The reverse of given number is: " + ans);
    }
}
class Solution:
    # Function to reverse given number n
    def reverseNumber(self, n):
        """ After the code, revNum will
        contain the reversed number """
        revNum = 0
        
        """ Keep on iterating while there
        are digits left to extract """
        while n > 0:
            lastDigit = n % 10
            
            """ Pushing last digit at the
            back of reversed number """
            revNum = (revNum * 10) + lastDigit
            n = n // 10
        
        return revNum

if __name__ == "__main__":
    n = 6678
    
    """ Creating an instance of 
    Solution class """
    sol = Solution()
    
    # Function call to reverse the digits in n
    ans = sol.reverseNumber(n)
    print("The reverse of given number is:", ans)
class Solution {
    // Function to reverse given number n
    reverseNumber(n) {
        /* After the code, revNum will
        contain the reversed number */
        let revNum = 0;
        
        /* Keep on iterating while there
        are digits left to extract */
        while (n > 0) {
            let lastDigit = n % 10;
            
            /* Pushing last digit at the
            back of reversed number */
            revNum = (revNum * 10) + lastDigit;
            n = Math.floor(n / 10);
        }
        
        return revNum;
    }
}

const n = 6678;

/* Creating an instance of 
Solution class */
const sol = new Solution();

// Function call to reverse the digits in n
const ans = sol.reverseNumber(n);
console.log("The reverse of given number is:", ans);

Complexity Analysis:

Time Complexity: O(log₁₀(N)) – In every iteration, N is divided by 10 (equivalent to the number of digits in N.)

Space Complexity: O(1) – Using a couple of variables i.e., constant space.

Code

Problem List