Check if a number is Palindrome - GeeksforGeeks

27 Apr, 2022
Given an integer, write a function that returns true if the given number is palindrome, else false. For example, 12321 is palindrome, but 1451 is not palindrome. 
Let the given number be num. A simple method for this problem is to first reverse digits of num, then compare the reverse of num with num. If both are same, then return true, else false. 
Following is an interesting method inspired from method#2 of this post. The idea is to create a copy of num and recursively pass the copy by reference, and pass num by value. In the recursive calls, divide num by 10 while moving down the recursion tree. While moving up the recursion tree, divide the copy by 10. When they meet in a function for which all child calls are over, the last digit of num will be ith digit from the beginning and the last digit of copy will be ith digit from the end.
C++
C
Java
Python3
C#
PHP
Javascript
// A recursive C++ program to check// whether a given number// is palindrome or not#include <iostream>using namespace std; // A function that returns true only// if num contains one// digitint oneDigit(int num){         // Comparison operation is faster    // than division    // operation. So using following    // instead of "return num    // / 10 == 0;"    return (num >= 0 && num < 10);} // A recursive function to find// out whether num is// palindrome or not. Initially, dupNum// contains address of// a copy of num.bool isPalUtil(int num, int* dupNum){         // Base case (needed for recursion    // termination): This    // statement mainly compares the    // first digit with the    // last digit    if (oneDigit(num))        return (num == (*dupNum) % 10);     // This is the key line in this    // method. Note that all    // recursive calls have a separate    // copy of num, but they    // all share same copy of *dupNum.    // We divide num while    // moving up the recursion tree    if (!isPalUtil(num / 10, dupNum))        return false;     // The following statements are    // executed when we move up    // the recursion call tree    *dupNum /= 10;     // At this point, if num%10 contains    // i'th digit from    // beginning, then (*dupNum)%10    // contains i'th digit    // from end    return (num % 10 == (*dupNum) % 10);} // The main function that uses// recursive function// isPalUtil() to find out whether// num is palindrome or notint isPal(int num){         // Check if num is negative,    // make it positive    if (num < 0)        num = -num;     // Create a separate copy of num,    // so that modifications    // made to address dupNum don't    // change the input number.    // *dupNum = num    int* dupNum = new int(num);     return isPalUtil(num, dupNum);} // Driver program to test// above functionsint main(){    int n = 12321;    isPal(n) ? cout <<"Yes\n":  cout <<"No" << endl;     n = 12;    isPal(n) ? cout <<"Yes\n": cout <<"No" << endl;     n = 88;    isPal(n) ? cout <<"Yes\n": cout <<"No" << endl;     n = 8999;    isPal(n) ? cout <<"Yes\n": cout <<"No";    return 0;} // this code is contributed by shivanisinghss2110
// A recursive C program to check// whether a given number// is palindrome or not#include <stdio.h> // A function that returns true only// if num contains one// digitint oneDigit(int num){         // Comparison operation is faster    // than division    // operation. So using following    // instead of "return num    // / 10 == 0;"    return (num >= 0 && num < 10);} // A recursive function to find// out whether num is// palindrome or not. Initially, dupNum// contains address of// a copy of num.bool isPalUtil(int num, int* dupNum){         // Base case (needed for recursion    // termination): This    // statement mainly compares the    // first digit with the    // last digit    if (oneDigit(num))        return (num == (*dupNum) % 10);     // This is the key line in this    // method. Note that all    // recursive calls have a separate    // copy of num, but they    // all share same copy of *dupNum.    // We divide num while    // moving up the recursion tree    if (!isPalUtil(num / 10, dupNum))        return false;     // The following statements are    // executed when we move up    // the recursion call tree    *dupNum /= 10;     // At this point, if num%10 contains    // i'th digit from    // beginning, then (*dupNum)%10    // contains i'th digit    // from end    return (num % 10 == (*dupNum) % 10);} // The main function that uses// recursive function// isPalUtil() to find out whether// num is palindrome or notint isPal(int num){         // Check if num is negative,    // make it positive    if (num < 0)        num = -num;     // Create a separate copy of num,    // so that modifications    // made to address dupNum don't    // change the input number.    // *dupNum = num    int* dupNum = new int(num);     return isPalUtil(num, dupNum);} // Driver program to test// above functionsint main(){    int n = 12321;    isPal(n) ? printf("Yes\n") : printf("No\n");     n = 12;    isPal(n) ? printf("Yes\n") : printf("No\n");     n = 88;    isPal(n) ? printf("Yes\n") : printf("No\n");     n = 8999;    isPal(n) ? printf("Yes\n") : printf("No\n");    return 0;}
// A recursive Java program to// check whether a given number// is palindrome or notimport java.io.*;import java.util.*;  public class CheckPallindromNumberRecursion {      // A function that returns true    // only if num contains one digit    public static int oneDigit(int num) {          if ((num >= 0) && (num < 10))            return 1;        else            return 0;    }      public static int isPalUtil    (int num, int dupNum) throws Exception {          // base condition to return once we        // move past first digit        if (num == 0) {            return dupNum;        } else {            dupNum = isPalUtil(num / 10, dupNum);        }          // Check for equality of first digit of        // num and dupNum        if (num % 10 == dupNum % 10) {            // if first digit values of num and            // dupNum are equal divide dupNum            // value by 10 to keep moving in sync            // with num.            return dupNum / 10;        } else {            // At position values are not            // matching throw exception and exit.            // no need to proceed further.            throw new Exception();        }      }      public static int isPal(int num)    throws Exception {          if (num < 0)            num = (-num);          int dupNum = (num);          return isPalUtil(num, dupNum);    }      public static void main(String args[]) {          int n = 1242;        try {            isPal(n);            System.out.println("Yes");        } catch (Exception e) {            System.out.println("No");        }        n = 1231;        try {            isPal(n);            System.out.println("Yes");        } catch (Exception e) {            System.out.println("No");        }          n = 12;        try {            isPal(n);            System.out.println("Yes");        } catch (Exception e) {            System.out.println("No");        }          n = 88;        try {            isPal(n);            System.out.println("Yes");        } catch (Exception e) {            System.out.println("No");        }          n = 8999;        try {            isPal(n);            System.out.println("Yes");        } catch (Exception e) {            System.out.println("No");        }    }}  // This code is contributed// by Nasir J
# A recursive Python3 program to check# whether a given number is palindrome or not # A function that returns true# only if num contains one digitdef oneDigit(num):         # comparison operation is faster    # than division operation. So    # using following instead of    # "return num / 10 == 0;"    return ((num >= 0) and            (num < 10)) # A recursive function to find# out whether num is palindrome# or not. Initially, dupNum# contains address of a copy of num.def isPalUtil(num, dupNum):         # Base case (needed for recursion    # termination): This statement    # mainly compares the first digit    # with the last digit    if oneDigit(num):        return (num == (dupNum[0]) % 10)     # This is the key line in this    # method. Note that all recursive    # calls have a separate copy of    # num, but they all share same    # copy of *dupNum. We divide num    # while moving up the recursion tree    if not isPalUtil(num //10, dupNum):        return False     # The following statements are    # executed when we move up the    # recursion call tree    dupNum[0] = dupNum[0] //10     # At this point, if num%10    # contains i'th digit from    # beginning, then (*dupNum)%10    # contains i'th digit from end    return (num % 10 == (dupNum[0]) % 10) # The main function that uses# recursive function isPalUtil()# to find out whether num is# palindrome or notdef isPal(num):    # If num is negative,    # make it positive    if (num < 0):        num = (-num)     # Create a separate copy of    # num, so that modifications    # made to address dupNum    # don't change the input number.    dupNum = [num] # *dupNum = num     return isPalUtil(num, dupNum) # Driver Coden = 12321if isPal(n):    print("Yes")else:    print("No") n = 12if isPal(n) :    print("Yes")else:    print("No") n = 88if isPal(n) :    print("Yes")else:    print("No") n = 8999if isPal(n) :    print("Yes")else:    print("No") # This code is contributed by mits
// A recursive C# program to// check whether a given number// is palindrome or notusing System; class GFG{     // A function that returns true// only if num contains one digitpublic static int oneDigit(int num){    // comparison operation is    // faster than division    // operation. So using    // following instead of    // "return num / 10 == 0;"    if((num >= 0) &&(num < 10))    return 1;    else    return 0;} // A recursive function to// find out whether num is// palindrome or not.// Initially, dupNum contains// address of a copy of num.public static int isPalUtil(int num,                            int dupNum){    // Base case (needed for recursion    // termination): This statement    // mainly compares the first digit    // with the last digit    if (oneDigit(num) == 1)        if(num == (dupNum) % 10)        return 1;        else        return 0;     // This is the key line in    // this method. Note that    // all recursive calls have    // a separate copy of num,    // but they all share same    // copy of *dupNum. We divide    // num while moving up the    // recursion tree    if (isPalUtil((int)(num / 10), dupNum) == 0)        return -1;     // The following statements    // are executed when we move    // up the recursion call tree    dupNum = (int)(dupNum / 10);     // At this point, if num%10    // contains i'th digit from    // beginning, then (*dupNum)%10    // contains i'th digit from end    if(num % 10 == (dupNum) % 10)        return 1;    else        return 0;} // The main function that uses// recursive function isPalUtil()// to find out whether num is// palindrome or notpublic static int isPal(int num){    // If num is negative,    // make it positive    if (num < 0)    num = (-num);     // Create a separate copy    // of num, so that modifications    // made to address dupNum    // don't change the input number.    int dupNum = (num); // *dupNum = num     return isPalUtil(num, dupNum);} // Driver Codepublic static void Main(){int n = 12321;if(isPal(n) == 0)    Console.WriteLine("Yes");else    Console.WriteLine("No"); n = 12;if(isPal(n) == 0)    Console.WriteLine("Yes");else    Console.WriteLine( "No"); n = 88;if(isPal(n) == 1)    Console.WriteLine("Yes");else    Console.WriteLine("No"); n = 8999;if(isPal(n) == 0)    Console.WriteLine("Yes");else    Console.WriteLine("No");}} // This code is contributed by mits
<?php// A recursive PHP program to// check whether a given number// is palindrome or not // A function that returns true// only if num contains one digitfunction oneDigit($num){    // comparison operation is faster    // than division operation. So    // using following instead of    // "return num / 10 == 0;"    return (($num >= 0) &&            ($num < 10));} // A recursive function to find// out whether num is palindrome// or not. Initially, dupNum// contains address of a copy of num.function isPalUtil($num, $dupNum){    // Base case (needed for recursion    // termination): This statement    // mainly compares the first digit    // with the last digit    if (oneDigit($num))        return ($num == ($dupNum) % 10);     // This is the key line in this    // method. Note that all recursive    // calls have a separate copy of    // num, but they all share same    // copy of *dupNum. We divide num    // while moving up the recursion tree    if (!isPalUtil((int)($num / 10),                         $dupNum))        return -1;     // The following statements are    // executed when we move up the    // recursion call tree    $dupNum = (int)($dupNum / 10);     // At this point, if num%10     // contains i'th digit from    // beginning, then (*dupNum)%10    // contains i'th digit from end    return ($num % 10 == ($dupNum) % 10);} // The main function that uses// recursive function isPalUtil()// to find out whether num is// palindrome or notfunction isPal($num){    // If num is negative,    // make it positive    if ($num < 0)    $num = (-$num);     // Create a separate copy of    // num, so that modifications    // made to address dupNum    // don't change the input number.    $dupNum = ($num); // *dupNum = num     return isPalUtil($num, $dupNum);} // Driver Code$n = 12321;if(isPal($n) == 0)    echo "Yes\n";else    echo "No\n"; $n = 12;if(isPal($n) == 0)    echo "Yes\n";else    echo "No\n"; $n = 88;if(isPal($n) == 1)    echo "Yes\n";else    echo "No\n"; $n = 8999;if(isPal($n) == 0)    echo "Yes\n";else    echo "No\n"; // This code is contributed by m_kit?>
<script>// A recursive javascript program to// check whether a given number// is palindrome or not     // A function that returns true    // only if num contains one digit    function oneDigit(num) {          if ((num >= 0) && (num < 10))            return 1;        else            return 0;    }      function isPalUtil    (num , dupNum) {          // base condition to return once we        // move past first digit        if (num == 0) {            return dupNum;        } else {            dupNum = isPalUtil(parseInt(num / 10), dupNum);        }          // Check for equality of first digit of        // num and dupNum        if (num % 10 == dupNum % 10) {            // if first digit values of num and            // dupNum are equal divide dupNum            // value by 10 to keep moving in sync            // with num.            return parseInt(dupNum / 10);        } else {            // At position values are not            // matching throw exception and exit.            // no need to proceed further.            throw e;        }      }      function isPal(num)    {          if (num < 0)            num = (-num);          var dupNum = (num);          return isPalUtil(num, dupNum);    }             var n = 1242;    try {        isPal(n);        document.write("<br>Yes");    } catch (e) {        document.write("<br>No");    }    n = 1231;    try {        isPal(n);        document.write("<br>Yes");    } catch (e) {        document.write("<br>No");        }          n = 12;        try {            isPal(n);            document.write("<br>Yes");    } catch (e) {        document.write("<br>No");        }          n = 88;        try {            isPal(n);            document.write("<br>Yes");    } catch (e) {        document.write("<br>No");        }          n = 8999;        try {            isPal(n);            document.write("<br>Yes");    } catch (e) {        document.write("<br>No");    } // This code is contributed by Amit Katiyar</script>
Output: 
Yes
No
Yes
No 
To check a number is palindrome or not without using any extra spaceMethod #2:Using string() method
When the number of digits of that number exceeds 1018, we can’t take that number as an integer since the range of long long int doesn’t satisfy the given number.So take input as a string, Run a loop from starting to length/2 and check the first character(numeric) to the last character of the string and second to second last one, and so on ....If any character mismatches, the string wouldn’t be a palindrome.
When the number of digits of that number exceeds 1018, we can’t take that number as an integer since the range of long long int doesn’t satisfy the given number.
So take input as a string, Run a loop from starting to length/2 and check the first character(numeric) to the last character of the string and second to second last one, and so on ....If any character mismatches, the string wouldn’t be a palindrome.
Below is the implementation of the above approach
C++14
Java
Python3
C#
Javascript
// C++ implementation of the above approach#include <iostream>using namespace std; // Function to check palindromeint checkPalindrome(string str){    // Calculating string length    int len = str.length();       // Traversing through the string    // upto half its length    for (int i = 0; i < len / 2; i++) {               // Comparing i th character        // from starting and len-i        // th character from end        if (str[i] != str[len - i - 1])            return false;    }       // If the above loop doesn't return then it is    // palindrome    return true;} // Driver Codeint main(){ // taking number as string    string st        = "112233445566778899000000998877665544332211";    if (checkPalindrome(st) == true)        cout << "Yes";    else        cout << "No";    return 0;}// this code is written by vikkycirus
// Java implementation of the above approachimport java.io.*; class GFG{ // Function to check palindromestatic boolean checkPalindrome(String str){         // Calculating string length    int len = str.length();     // Traversing through the string    // upto half its length    for(int i = 0; i < len / 2; i++)    {                 // Comparing i th character        // from starting and len-i        // th character from end        if (str.charAt(i) !=            str.charAt(len - i - 1))            return false;    }     // If the above loop doesn't return then    // it is palindrome    return true;} // Driver Codepublic static void main(String[] args){         // Taking number as string    String st = "112233445566778899000000998877665544332211";         if (checkPalindrome(st) == true)        System.out.print("Yes");    else        System.out.print("No");}} // This code is contributed by subhammahato348
# Python3 implementation of the above approach # function to check palindromedef checkPalindrome(str):       # Run loop from 0 to len/2    for i in range(0, len(str)//2):        if str[i] != str[len(str)-i-1]:            return False               # If the above loop doesn't    #return then it is palindrome    return True  # Driver codest = "112233445566778899000000998877665544332211"if(checkPalindrome(st) == True):    print("it is a palindrome")else:    print("It is not a palindrome")
// C# implementation of the above approachusing System; class GFG{ // Function to check palindromestatic bool checkPalindrome(string str){         // Calculating string length    int len = str.Length;     // Traversing through the string    // upto half its length    for(int i = 0; i < len / 2; i++)    {                 // Comparing i th character        // from starting and len-i        // th character from end        if (str[i] != str[len - i - 1])            return false;    }     // If the above loop doesn't return then    // it is palindrome    return true;} // Driver Codepublic static void Main(){         // Taking number as string    string st = "112233445566778899000000998877665544332211";     if (checkPalindrome(st) == true)        Console.Write("Yes");    else        Console.Write("No");}} // This code is contributed by subhammahato348
<script> // Javascript implementation of the above approach // Function to check palindromefunction checkPalindrome(str){    // Calculating string length    var len = str.length;        // Traversing through the string    // upto half its length    for (var i = 0; i < len / 2; i++) {                // Comparing ith character        // from starting and len-ith        // character from end        if (str[i] != str[len - i - 1])            return false;    }        // If the above loop doesn't return then it is    // palindrome    return true;}  // Driver Code // taking number as string    let st        = "112233445566778899000000998877665544332211";    if (checkPalindrome(st) == true)        document.write("Yes");    else        document.write("No");         // This code is contributed by Mayank Tyagi </script>
Yes
Time Complexity: O(|str|)
Method #3:Using split(), reverse() and join() methods simultaneously 
When user inputs an integer, it is further passed inside a method which will evaluate the result or the actual logic part.Logic part inside the method focuses on using several important JavaScript methods simultaneously.First task is to convert the integer passed in into the string using toString() method.Then split(), reverse() and join() method will be applied to obtain the reverse of that string.Thereafter using the triple equality operator (“===”), reverse string and original string will be compared and based on that result will be printed on the console.
When user inputs an integer, it is further passed inside a method which will evaluate the result or the actual logic part.
Logic part inside the method focuses on using several important JavaScript methods simultaneously.
First task is to convert the integer passed in into the string using toString() method.
Then split(), reverse() and join() method will be applied to obtain the reverse of that string.
Thereafter using the triple equality operator (“===”), reverse string and original string will be compared and based on that result will be printed on the console.
 Below is the implementation of the above approach
Python3
Javascript
def checkPalindrome(x):    convertedNumber = str(x)    reverseString = convertedNumber[::-1]    return "Yes" if reverseString == convertedNumber else "No" # Some Testcases...num = 12321print(checkPalindrome(num)) # Yes number = 456print(checkPalindrome(number)) # No # This code is contributed by shinjanpatra
function checkPalindrome(x) {    let convertedNumber = x.toString();    let reverseString = convertedNumber.split("").reverse().join("");    return reverseString === convertedNumber ? "Yes" : "No";} // Some Testcases...let num = 12321;console.log(checkPalindrome(num)); // Yes let number = 456;console.log(checkPalindrome(number)); // No // This code is contributed by Aman Singla....
Output
Yes
No
This article is compiled by Aashish Barnwal. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
jit_t
Mithun Kumar
Akanksha_Rai
NasirJamal
pansaripulkit13
vikkycirus
mayanktyagi1709
subhammahato348
amit143katiyar
akshaysingh98088
ruhelaa48
shivanisinghss2110
sagartomar9927
rishavmahato348
amansingla
simmytarika5
shinjanpatra
Adobe
Oracle
palindrome
Samsung
Zoho
Mathematical
Recursion
Zoho
Samsung
Oracle
Adobe
Mathematical
Recursion
palindrome
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Merge two sorted arrays
Modulo Operator (%) in C/C++ with Examples
Prime Numbers
Program to find GCD or HCF of two numbers
Print all possible combinations of r elements in a given array of size n
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Recursion
Program for Tower of Hanoi
Backtracking | Introduction
Print all possible combinations of r elements in a given array of size n