Dado un número entero, escribe una función que devuelva verdadero si el número dado es palíndromo, de lo contrario, falso. Por ejemplo, 12321 es palíndromo, pero 1451 no es palíndromo.
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\n": cout <<"No" << endl;
n = 12;
isPal(n) ? cout <<"Yes\n": cout <<"No" << endl;
n = 88;
isPal(n) ? cout <<"Yes\n": cout <<"No" << endl;
n = 8999;
isPal(n) ? cout <<"Yes\n": cout <<"No";
return 0;
}
// this code is contributed by shivanisinghss2110
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\n") : printf("No\n");
n = 12;
isPal(n) ? printf("Yes\n") : printf("No\n");
n = 88;
isPal(n) ? printf("Yes\n") : printf("No\n");
n = 8999;
isPal(n) ? printf("Yes\n") : printf("No\n");
return 0;
}
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 Python3 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\n";
else
echo "No\n";
$n = 12;
if(isPal($n) == 0)
echo "Yes\n";
else
echo "No\n";
$n = 88;
if(isPal($n) == 1)
echo "Yes\n";
else
echo "No\n";
$n = 8999;
if(isPal($n) == 0)
echo "Yes\n";
else
echo "No\n";
// This code is contributed by m_kit
?>
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>
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>
C++
// C++ program to implement the approach
#include<bits/stdc++.h>
using namespace std;
string checkPalindrome(int x) {
string convertedNumber = to_string(x);
string reverseString = convertedNumber;
reverse(reverseString.begin(),reverseString.end());
return reverseString == convertedNumber ? "Yes" : "No";
}
// Driver code
int main () {
// Some Testcases...
int num = 12321;
cout<<checkPalindrome(num)<<endl; // Yes
int number = 456;
cout<<checkPalindrome(number)<<endl; // No
return 0;
}
// This code is contributed by shinjanpatra
Java
// Java program to implement the approach
import java.util.*;
class GFG {
static String checkPalindrome(int x)
{
String convertedNumber = String.valueOf(x);
// reversing the string using StringBuilder
StringBuilder reverseString = new StringBuilder();
// append a string into StringBuilder input1
reverseString.append(convertedNumber);
// reverse StringBuilder
reverseString.reverse();
// comparing the reversed string and the number
return (reverseString.toString())
.equals(convertedNumber)
? "Yes"
: "No";
}
// Driver code
public static void main(String[] args)
{
// Some Testcases...
int num = 12321;
System.out.println(checkPalindrome(num)); // Yes
int number = 456;
System.out.println(checkPalindrome(number)); // No
}
}
// This code is contributed by phasing17
Python3
def checkPalindrome(x): convertedNumber = str(x) reverseString = convertedNumber[::-1] return "Yes" if reverseString == convertedNumber else "No" # Some Testcases... num = 12321 print(checkPalindrome(num)) # Yes number = 456 print(checkPalindrome(number)) # No # This code is contributed by shinjanpatra
C#
// C# program to implement the approach
using System;
class GFG {
static string checkPalindrome(int x)
{
string convertedNumber = Convert.ToString(x);
// reversing the string
string reverseString = convertedNumber;
char[] charArray = reverseString.ToCharArray();
Array.Reverse(charArray);
reverseString = new string(charArray);
// comparing the reversed string and the number
return reverseString == convertedNumber ? "Yes"
: "No";
}
// Driver code
public static void Main(string[] args)
{
// Some Testcases...
int num = 12321;
Console.WriteLine(checkPalindrome(num)); // Yes
int number = 456;
Console.WriteLine(checkPalindrome(number)); // No
}
}
// This code is contributed by phasing17
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....
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
int input1 = 7007;
String str_input1 = String.valueOf(input1); //conversion of int to string
String str = new StringBuilder(str_input1).reverse().toString(); // reversing the input string
if (str.equals(str_input1)) //Checking for Palindrome
{
System.out.println(input1 + " is Palindrome");
}
else
{
System.out.println(input1+ " is not Palindrome");
}
}
}
C#
// C# implementation of the approach
using System;
using System.Linq;
using System.Collections.Generic;
class GFG {
public static void Main(string[] args)
{
int input1 = 7007;
string str_input1 = Convert.ToString(
input1); // conversion of int to string
string str = new string(
str_input1.Reverse()
.ToArray()); // reversing the input string
if (String.Equals(
str, str_input1)) // Checking for Palindrome
{
Console.WriteLine(input1 + " is Palindrome");
}
else {
Console.WriteLine(input1
+ " is not Palindrome");
}
}
}
// This code is contributed to phasing17
C++
// C++ program to check if a number is Palindrome
#include <iostream>
using namespace std;
// Function to check Palindrome
bool checkPalindrome(int n)
{
int reverse = 0;
int temp = n;
while (temp != 0) {
reverse = (reverse * 10) + (temp % 10);
temp = temp / 10;
}
return (reverse
== n); // if it is true then it will return 1;
// else if false it will return 0;
}
int main()
{
int n = 7007;
if (checkPalindrome(n) == 1) {
cout << "Yes\n";
}
else {
cout << "No\n";
}
return 0;
}
// This code is contributed by Suruchi Kumari
Java
/*package whatever //do not write package name here */
import java.io.*;
class GFG {
// Java program to check if a number is Palindrome
// Function to check Palindrome
static boolean checkPalindrome(int n)
{
int reverse = 0;
int temp = n;
while (temp != 0) {
reverse = (reverse * 10) + (temp % 10);
temp = temp / 10;
}
return (reverse == n); // if it is true then it will return 1;
// else if false it will return 0;
}
// Driver Code
public static void main(String args[])
{
int n = 7007;
if (checkPalindrome(n) == true) {
System.out.println("Yes");
}
else {
System.out.println("No");
}
}
}
// This code is contributed by shinjanpatra
Python3
# Python3 program to check if a number is Palindrome
# Function to check Palindrome
def checkPalindrome(n):
reverse = 0
temp = n
while (temp != 0):
reverse = (reverse * 10) + (temp % 10)
temp = temp // 10
return (reverse == n) # if it is true then it will return 1;
# else if false it will return 0;
# driver code
n = 7007
if (checkPalindrome(n) == 1):
print("Yes")
else:
print("No")
# This code is contributed by shinjanpatra
C#
// C# program to check if a number is Palindrome
using System;
class GFG {
// Function to check Palindrome
static bool checkPalindrome(int n)
{
int reverse = 0;
int temp = n;
while (temp != 0) {
reverse = (reverse * 10) + (temp % 10);
temp = temp / 10;
}
return (
reverse
== n); // if it is true then it will return 1;
// else if false it will return 0;
}
// Driver Code
public static void Main(string[] args)
{
int n = 7007;
if (checkPalindrome(n) == true) {
Console.WriteLine("Yes");
}
else {
Console.WriteLine("No");
}
}
}
// This code is contributed by phasing17
Javascript
<script>
// JavaScript program to check if a number is Palindrome
// Function to check Palindrome
function checkPalindrome(n)
{
let reverse = 0;
let temp = n;
while (temp != 0) {
reverse = (reverse * 10) + (temp % 10);
temp = Math.floor(temp / 10);
}
return (reverse == n); // if it is true then it will return 1;
// else if false it will return 0;
}
// driver code
let n = 7007;
if (checkPalindrome(n) == 1) {
document.write("Yes","</br>");
}
else {
document.write("No","</br>");
}
// This code is contributed by shinjanpatra
</script>
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA