检查数字是否为回文-yiteyi-C++库

给定一个整数，编写一个函数，如果给定的数字是回文的，则返回true，否则返回false。例如，12321是回文，但1451不是回文。

null

图片[1]-检查数字是否为回文-yiteyi-C++库

建议：请在“上解决” 实践 “首先，在讨论解决方案之前。

让给定的数字为号码 .解决这个问题的一个简单方法是倒数号码，然后比较号码具有号码 .如果两者相同，则返回true，否则返回false。

以下是一个有趣的方法，灵感来自这邮递我们的想法是制作一份号码递归地通过引用传递副本，并传递号码按价值计算。在递归调用中，除法号码在沿着递归树向下移动的过程中。向上移动递归树时，将副本除以10。当它们在一个函数中相遇，且所有子函数调用都已结束时号码将是从开头开始的第i个数字，副本的最后一个数字将是从结尾开始的第i个数字。

C++

                         // 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                       
                         // digit                       
                         int                                     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 not                       
                         int                                     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 functions                       
                         int                                     main()                       
                         {                       
                                                 int                                     n = 12321;                       
                                                 isPal(n) ? cout <<                                     "Yes"                                     :  cout <<                                     "No"                                     << endl;                       
           
                                                 n = 12;                       
                                                 isPal(n) ? cout <<                                     "Yes"                                     : cout <<                                     "No"                                     << endl;                       
           
                                                 n = 88;                       
                                                 isPal(n) ? cout <<                                     "Yes"                                     : cout <<                                     "No"                                     << endl;                       
           
                                                 n = 8999;                       
                                                 isPal(n) ? cout <<                                     "Yes"                                     : cout <<                                     "No"                                     ;                       
                                                 return                                     0;                       
                         }                       
           
                         // this code is contributed by shivanisinghss2110                       

C

                         // 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                       
                         // digit                       
                         int                                     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 not                       
                         int                                     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 functions                       
                         int                                     main()                       
                         {                       
                                                 int                                     n = 12321;                       
                                                 isPal(n) ?                                     printf                                     (                                     "Yes"                                     ) :                                     printf                                     (                                     "No"                                     );                       
           
                                                 n = 12;                       
                                                 isPal(n) ?                                     printf                                     (                                     "Yes"                                     ) :                                     printf                                     (                                     "No"                                     );                       
           
                                                 n = 88;                       
                                                 isPal(n) ?                                     printf                                     (                                     "Yes"                                     ) :                                     printf                                     (                                     "No"                                     );                       
           
                                                 n = 8999;                       
                                                 isPal(n) ?                                     printf                                     (                                     "Yes"                                     ) :                                     printf                                     (                                     "No"                                     );                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // A recursive Java program to                       
                         // check whether a given number                       
                         // is palindrome or not                       
                         import                                     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                       

Python3

                         # A recursive Pyhton3 program to check                       
                         # whether a given number is palindrome or not                       
           
                         # A function that returns true                       
                         # only if num contains one digit                       
                         def                                     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 not                       
                         def                                     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):                       
                                                 print                                     (                                     "Yes"                                     )                       
                         else                                     :                       
                                                 print                                     (                                     "No"                                     )                       
           
                         n                                     =                                     12                       
                         if                                     isPal(n) :                       
                                                 print                                     (                                     "Yes"                                     )                       
                         else                                     :                       
                                                 print                                     (                                     "No"                                     )                       
           
                         n                                     =                                     88                       
                         if                                     isPal(n) :                       
                                                 print                                     (                                     "Yes"                                     )                       
                         else                                     :                       
                                                 print                                     (                                     "No"                                     )                       
           
                         n                                     =                                     8999                       
                         if                                     isPal(n) :                       
                                                 print                                     (                                     "Yes"                                     )                       
                         else                                     :                       
                                                 print                                     (                                     "No"                                     )                       
           
                         # This code is contributed by mits                       

C#

                         // A recursive C# program to                       
                         // check whether a given number                       
                         // is palindrome or not                       
                         using                                     System;                       
           
                         class                                     GFG                       
                         {                       
                                   
                         // A function that returns true                       
                         // only if num contains one digit                       
                         public                                     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 not                       
                         public                                     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 Code                       
                         public                                     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

                         <?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 digit                       
                         function                                     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 not                       
                         function                                     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"                                     ;                       
                         else                       
                                                 echo                                     "No"                                     ;                       
           
                         $n                                     = 12;                       
                         if                                     (isPal(                                     $n                                     ) == 0)                       
                                                 echo                                     "Yes"                                     ;                       
                         else                       
                                                 echo                                     "No"                                     ;                       
           
                         $n                                     = 88;                       
                         if                                     (isPal(                                     $n                                     ) == 1)                       
                                                 echo                                     "Yes"                                     ;                       
                         else                       
                                                 echo                                     "No"                                     ;                       
           
                         $n                                     = 8999;                       
                         if                                     (isPal(                                     $n                                     ) == 0)                       
                                                 echo                                     "Yes"                                     ;                       
                         else                       
                                                 echo                                     "No"                                     ;                       
           
                         // This code is contributed by m_kit                       
                         ?>                       

Javascript

                         <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>                       

输出：

YesNoYesNo

在不使用任何额外空格的情况下检查数字是否为回文 方法#2：使用string（）方法

当该数字的位数超过10时 ¹⁸ ，我们不能将该数字作为整数，因为long int的范围不满足给定的数字。
因此，将输入作为字符串，从开始到长度/2运行一个循环，并检查字符串的第一个字符（数字）到最后一个字符，以及第二个到最后一个字符，依此类推…。如果有任何字符不匹配，字符串就不是回文。

下面是上述方法的实现

C++14

                         // C++ implementation of the above approach                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
           
                         // Function to check palindrome                       
                         int                                     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 Code                       
                         int                                     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

                         // Java implementation of the above approach                       
                         import                                     java.io.*;                       
           
                         class                                     GFG{                       
           
                         // Function to check palindrome                       
                         static                                     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 Code                       
                         public                                     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

                         # Python3 implementation of the above approach                       
           
                         # function to check palindrome                       
                         def                                     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 code                       
                         st                                     =                                     "112233445566778899000000998877665544332211"                       
                         if                                     (checkPalindrome(st)                                     =                                     =                                     True                                     ):                       
                                                 print                                     (                                     "it is a palindrome"                                     )                       
                         else                                     :                       
                                                 print                                     (                                     "It is not a palindrome"                                     )                       

C#

                         // C# implementation of the above approach                       
                         using                                     System;                       
           
                         class                                     GFG{                       
           
                         // Function to check palindrome                       
                         static                                     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 Code                       
                         public                                     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                       

Javascript

                         <script>                       
           
                         // Javascript implementation of the above approach                       
           
                         // Function to check palindrome                       
                         function                                     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

时间复杂性： O（| str |）

方法3：同时使用split（）、reverse（）和join（）方法

当用户输入一个整数时，它被进一步传递到一个方法中，该方法将评估结果或实际的逻辑部分。
方法中的逻辑部分着重于同时使用几个重要的JavaScript方法。
第一个任务是使用toString（）方法将传入的整数转换为字符串。
然后将应用split（）、reverse（）和join（）方法来获取该字符串的反向。
然后，使用三重相等运算符（“==”），将比较反向字符串和原始字符串，并基于该结果在控制台上打印。

下面是上述方法的实现

Javascript

                         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....                       

输出

YesNo

本文由阿希什·巴恩瓦尔。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请发表评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章