Comprobar si un número es palíndromo o no sin utilizar ningún espacio extra | conjunto 2

Dado un número ‘n’, nuestro objetivo es averiguar si es palíndromo o no sin usar ningún espacio adicional. No podemos hacer una nueva copia del número.

Ejemplos:

Entrada: n = 2332
Salida: Sí, es Palindrome.
Explicación:
número original = 2332
número invertido = 2332
Ambos son iguales, por lo tanto, el número es palíndromo.

Entrada: n=1111
Salida: Sí, es Palindrome.

Entrada: n = 1234
Salida: No no Palíndromo.

Otro enfoque: los otros enfoques recursivos y el enfoque para comparar los dígitos se analizan en el Conjunto 1 de este artículo . Aquí, estamos discutiendo los otros enfoques.

Enfoque: Este enfoque depende de 3 pasos principales, encuentre la cantidad de dígitos en el número. Divide el número en 2 partes desde el medio. Tenga cuidado con el caso en que la longitud es impar, en la que tendremos que usar el elemento central dos veces. Compruebe si el número en ambos números es el mismo o no. Siga los pasos a continuación para resolver el problema:

• Inicialice la variable K como la longitud del número n.
• Inicialice la variable ans como 0.
• Iterar sobre el rango [0, K/2) usando la variable i y realizar las siguientes tareas:
  • Ponga el valor de n%10 en la variable ans y divida n por 10.
• Si K%2 es igual a 1 , entonces ponga el valor de n%10 en la variable ans.
• Después de realizar los pasos anteriores, si ans es igual a n , entonces es un palíndromo; de lo contrario, no.

A continuación se muestra la implementación del enfoque anterior.

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find if the number is a
// pallindrome or not
bool isPalindrome(int n)
{
    if (n < 0)
        return false;
    if (n < 10)
        return true;
 
    // Find the length of the number
    int K = ceil(log(n) / log(10));
 
    int ans = 0;
 
    // Partition the number into 2 halves
    for (int i = 0; i < K / 2; i++) {
        ans = ans * 10 + n % 10;
        n = n / 10;
    }
    if (K % 2 == 1)
        ans = ans * 10 + n % 10;
 
    // Equality Condition
    return (ans == n);
}
 
// Driver Code
int main()
{
    isPalindrome(1001) ? cout << "Yes, it is Palindrome"
                       : cout << "No, not Palindrome";
    return 0;
}

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find if the number is a
// pallindrome or not
static boolean isPalindrome(int n)
{
    if (n < 0)
        return false;
    if (n < 10)
        return true;
 
    // Find the length of the number
    int K = (int) Math.ceil(Math.log(n) / Math.log(10));
 
    int ans = 0;
 
    // Partition the number into 2 halves
    for (int i = 0; i < K / 2; i++) {
        ans = ans * 10 + n % 10;
        n = n / 10;
    }
    if (K % 2 == 1)
        ans = ans * 10 + n % 10;
 
    // Equality Condition
    return (ans == n);
}
 
// Driver Code
public static void main(String[] args)
{
    System.out.print(isPalindrome(1001) ? "Yes, it is Palindrome"
                       : "No, not Palindrome");
}
}
 
// This code is contributed by 29AjayKumar

# Python code for the above approach
import math as Math
 
# Function to find if the number is a
# pallindrome or not
def isPalindrome(n):
    if (n < 0):
        return False
    if (n < 10):
        return True
 
    # Find the length of the number
    K = Math.ceil(Math.log(n) / Math.log(10))
 
    ans = 0
 
    # Partition the number into 2 halves
    for i in range(0, K // 2):
        ans = ans * 10 + n % 10
        n = Math.floor(n / 10)
    if (K % 2 == 1):
        ans = ans * 10 + n % 10
 
    # Equality Condition
    return (ans == n)
 
# Driver Code
print("Yes, it is Palindrome") if isPalindrome(
    1001) else print("No, not Palindrome")
 
# This code is contributed by Saurabh jaiswal

// C# program for the above approach
using System;
 
class GFG
{
 
  // Function to find if the number is a
  // pallindrome or not
  static bool isPalindrome(int n)
  {
    if (n < 0)
      return false;
    if (n < 10)
      return true;
 
    // Find the length of the number
    int K = (int)Math.Ceiling(Math.Log(n) / Math.Log(10));
 
    int ans = 0;
 
    // Partition the number into 2 halves
    for (int i = 0; i < K / 2; i++)
    {
      ans = ans * 10 + n % 10;
      n = n / 10;
    }
    if (K % 2 == 1)
      ans = ans * 10 + n % 10;
 
    // Equality Condition
    return (ans == n);
  }
 
  // Driver Code
  public static void Main()
  {
    Console.Write(isPalindrome(1001) ? "Yes, it is Palindrome" : "No, not Palindrome");
  }
}
 
// This code is contributed by Saurabh Jaiswal

<script>
       // JavaScript code for the above approach
 
       // Function to find if the number is a
       // pallindrome or not
       function isPalindrome(n) {
           if (n < 0)
               return false;
           if (n < 10)
               return true;
 
           // Find the length of the number
           let K = Math.ceil(Math.log(n) / Math.log(10));
 
           let ans = 0;
 
           // Partition the number into 2 halves
           for (let i = 0; i < K / 2; i++) {
               ans = ans * 10 + n % 10;
               n = Math.floor(n / 10);
           }
           if (K % 2 == 1)
               ans = ans * 10 + n % 10;
 
           // Equality Condition
           return (ans == n);
       }
 
       // Driver Code
       isPalindrome(1001) ? document.write("Yes, it is Palindrome")
           : document.write("No, not Palindrome");
 
 // This code is contributed by Potta Lokesh
   </script>

Yes, it is Palindrome

Complejidad de tiempo: O(K), donde K es el número de dígitos
Enfoque auxiliar: O(1)