Palindrome number

Beginner Problems Basic Maths Easy

Palindrome checking, as in this problem, is often used in error detection within computer systems
It's used specifically in the realm of ECC (Error Checking and Correction) memory, commonly seen in crucial systems such as servers
Here, bits are encoded with a simple algorithm which checks if a string of binary data reads the same backwards as forwards to prevent potential crashes from memory faults
Additionally, palindrome checking can be applied in string processing within Natural Language Processing (NLP) applications for linguistic pattern detection

You are given an integer n. You need to check whether the number is a palindrome number or not. Return true if it's a palindrome number, otherwise return false.

A palindrome number is a number which reads the same both left to right and right to left.

Examples:

Input: n = 121

Output: true

Explanation: When read from left to right : 121.

When read from right to left : 121.

Input: n = 123

Output: false

Explanation: When read from left to right : 123.

When read from right to left : 321.

Input: 101

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 is a palindrome if it remains the same when its digits are reversed.

Approach:

Initialize a reversed number with zero, which will store the reversed number. Store a copy of the original number which can be used to compare the original number and 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. Check if the stored copy of the original number is the same as the reversed number. If yes, the number is palindrome else it is not a palindrome.

Dry Run:

Solution:

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

class Solution {
public:

    /* Function to check if a 
    number is palindrome or not*/
    bool isPalindrome(int n) {
        // Create a copy of original number
        int copy = 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 true if the reversed and 
        copy of original number is same */
        if(revNum == copy) return true;
        return false;
    }
};

int main()
{
    int n = 12321;
    
    /* Creating and instance of 
    Solution class */
    Solution sol; 
    
    // Function call to check if n is a palindrome
    bool ans = sol.isPalindrome(n);
    
    if(ans) cout << "The given number is a palindrome";
    else cout << "The given number is not a palindrome";
    
    return 0;
}
class Solution {
    /* Function to check if a 
    number is palindrome or not */
    public boolean isPalindrome(int n) {
        // Create a copy of original number
        int copy = 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 true if the reversed and 
        copy of original number is same */
        return revNum == copy;
    }

    public static void main(String[] args) {
        int n = 12321;
        
        /* Creating an instance of 
        Solution class */
        Solution sol = new Solution();
        
        // Function call to check if n is a palindrome
        boolean ans = sol.isPalindrome(n);
        
        if (ans) {
            System.out.println("The given number is a palindrome");
        } else {
            System.out.println("The given number is not a palindrome");
        }
    }
}
class Solution:
    # Function to check if a 
    # number is palindrome or not
    def isPalindrome(self, n):
        # Create a copy of original number
        copy = 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 true if the reversed and 
        # copy of original number is same
        return revNum == copy

# Input number
n = 12321

# Creating an instance of Solution class
sol = Solution()

# Function call to check if n is a palindrome
ans = sol.isPalindrome(n)

if ans:
    print("The given number is a palindrome")
else:
    print("The given number is not a palindrome")
class Solution {
    /* Function to check if a 
    number is palindrome or not */
    isPalindrome(n) {
        // Create a copy of original number
        let copy = 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 true if the reversed and 
        copy of original number is same */
        return revNum === copy;
    }
}

// Input number
let n = 12321;

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

// Function call to check if n is a palindrome
let ans = sol.isPalindrome(n);

if (ans) {
    console.log("The given number is a palindrome");
} else {
    console.log("The given number is not a palindrome");
}

Complexity Analysis:

Time Complexity: O(log10(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