Cómo verificar si una cadena es un palíndromo en JavaScript

Una cadena es un palíndromo, si el reverso de la cadena es la cadena misma.

Ahora la pregunta es, ¿cómo encontramos el reverso de una cadena? En javascript, la forma más sencilla es crear una matriz de caracteres, invertir la matriz y unir los caracteres nuevamente.

> const str = “hola”

> str.split (”)
<["h", "e", "l", "l", "o"]

> str.split (”). reverse ()
<["o", "l", "l", "e", "h"]

> str.split (”). reverse (). join (”)
<"olleh"

Entonces definimos nuestra función como:

función esPalindrome (str) {
return str === str.split (”). reverse (). join (”);
}

> isPalindrome (‘radar’)

> isPalindrome (‘hola’)

(Tenga en cuenta que esta no es la forma más rápida, pero me gusta más el estilo declarativo).

String.prototype.split ()

Array.prototype.reverse ()

Array.prototype.join ()

Una cadena es un palíndromo si permanece sin cambios cuando se invierte, por ejemplo, “papá” es un palíndromo ya que el reverso de “papá” es “papá”, mientras que “programa” no es un palíndromo. Algunas otras cadenas de palíndromo son “mamá”, “señora”, “abcba”.

Código fuente de programación Java

import java.util. *;
clase Palindrome
{
público estático vacío principal (String args [])
{
Cadena original, reverse = “”;
Scanner in = nuevo escáner (System. In);
System.out.println (“Ingrese una cadena para verificar si es un palíndromo”);
original = in.nextLine ();
int length = original.length ();
para (int i = longitud – 1; i> = 0; i–)
reverse = reverse + original.charAt (i);
if (original.equals (reverso))
System.out.println (“La cadena ingresada es un palíndromo”);
más
System.out.println (“La cadena ingresada no es un palíndromo”);
}
}

Para obtener más descripción sobre los conceptos de Java, puede visitar este enlace:

La respuesta de James McInnes es una línea totalmente dulce, y la mejor respuesta en mi opinión. Pero … creo que alguien realmente quiere que uses la recursividad aquí. Quiero decir, los palíndromos son recursivos, después de todo.

Entonces, para una respuesta recursiva, iría con esto:

función esPalindrome (input, palindrome) {
if (typeof palindrome === ‘undefined’) palindrome = input.replace (/ \ s / g, ”). toLowerCase (). split (“”);
if (palindrome.pop () === (palindrome.shift () || ‘undefined’)) {
return isPalindrome (input, palindrome);
} else if (input.length> 1 && palindrome.length === 0) {
volver verdadero;
} más {
falso retorno;
}
}

Si pudiera ser más corto, si hubiera puntos especiales para la brevedad, o podría ser más largo.

Un palíndromo es simplemente una palabra que se escribe de la misma manera hacia atrás que hacia adelante. Entonces, todo lo que tenemos que hacer es pasar a través de la cadena desde el frente y la parte posterior y asegurarnos de que cada letra sea la misma.

public boolean isPalindrome (String s) {
int front = 0, back = s.length – 1;
s = s.toLowerCase ();
while (frente if (s.charAt (frente)! = s.charAt (atrás)) {
falso retorno;
}
frente ++;
espalda-;
}
volver verdadero;
}

Tenga en cuenta que este método devolverá verdadero si pasa la cadena “Abcba”. Si no le gusta y prefiere que sus palíndromos distingan entre mayúsculas y minúsculas, elimine la línea que establece s en su representación en minúsculas.

Aquí una forma muy concisa de hacerlo usando expresiones regulares. Puede ser incluso más corto con ES6:

var isPalindrome = function (str) {
if (! str) devuelve falso;
// deshacerse de todos los espacios en blanco y deshacerse de las mayúsculas
var _str = str.replace (/ / g, ”). toLowerCase ();
// verifica nuevo _str contra su valor invertido para una coincidencia
return _str.split (”). reverse (). join (”) === _str;
}

// prueba algunos
alerta (isPalindrome (“Matam”));
alert (isPalindrome (“Navega en vasallos de juego Lacy save magnolias”));

Espero que ayude 🙂

Me gustaría recorrer los caracteres de la cadena desde el frente hacia el medio, comparándolo con el carácter en el lado opuesto de la cadena usando charAt (). Si algún emparejamiento es desigual, establece un valor booleano en falso y abandona el ciclo for con break.

1. var n = s.length;
2. var isPalindrome = verdadero;
3. for (var i = 0; i if (s.charAt (i)! = s.charAt (n-1-i)) {
isPalindrome = falso;
descanso;
}
4. el retorno es Palindrome;

La forma en que pensé en hacerlo es verificando un bucle for si str [i] es igual a str [str.length – 1 – i]. De esa manera verificas todos los caracteres. Al principio, puede establecer un valor booleano verdadero y, si la condición en el bucle for es falsa, cambie el valor booleano a falso. Al final devuelve el booleano.

var str = ‘señora’;

var i, j;

var encontrado = verdadero;

for (i = 0, j = (str.length-1); i

if (str [i]! = str [j]) {

encontrado = falso;

descanso;

}

}

si se encuentra){

console.log (‘String’ + str + ‘es palíndromo’);

}más{

console.log (‘String’ + str + ‘no es un palíndromo’);

}

nombre var = “Rahul”
var nameInReverse = name.split (”). reverse (). join (”)
name.toUpperCase () === nameInReverse.toUpperCase ()? console.log (“YES”): console.log (“NO”)

La solución más obvia para mí sería:

la función esPalindrome (s) {
return s == s.split (”). reverse (). join (”);
}

Creo que esto también funcionaría (agregándolo como método a la clase String):

String.prototype.isPalindrome = function () {
devuelve this == this.split (”). reverse (). join (”);
}