saber - Cómo escribir palíndromo en JavaScript
palindrome javascript (30)
Me pregunto cómo escribir palíndromo en javascript, donde ingreso diferentes palabras y el programa muestra si la palabra es palíndromo o no. Por ejemplo, palabra mediodía es palíndromo, mientras que mala no lo es.
Gracias de antemano.
25 veces más rápido + recursivo + no ramificado + terso
function palindrome(str) {
var re = /[^A-Za-z0-9]/g;
str = str.toLowerCase().replace(re, '''');
var len = str.length;
for (var i = 0; i < len/2; i++) {
if (str[i] !== str[len - 1 - i]) {
return false;
}
}
return true;
}
¡Todos estos bucles! ¿Qué tal algo de bondad funcional? :) Puede ejecutarse para solucionar problemas de llamadas en motores js antiguos / actuales, resueltos en ES6
function isPalendrome(str){
var valid = false;
if(str.length < 2 ) return true;
function even(i,ii){
str[i]===str[ii] ? ((i+1 !== ii) ? even(i+1,ii-1) : valid = true) : null
}
function odd(i, ii){
str[i]===str[ii] ? ((i !== ii) ? odd(i+1,ii-1) : valid = true) : null
}
if(str.length % 2){
return odd(0,str.length-1),valid;
}else{
return even(0,str.length-1),valid;
}
}
Para probar su pila de llamadas, ejecute este código, podrá analizar cadenas que duplican el tamaño de la pila de llamadas.
function checkStackSize(){
var runs = 70000;
var max_process = 1;
var max = 0;
function recurse_me() {
max_process++;
if(max_process === runs) return;
max = max_process;
try {
recurse_me()
} catch(e) {
max = max_process;
}
}
recurse_me()
console.log(max);
}
Debido a la naturaleza simétrica del problema, puede dividir la cadena desde el exterior y procesar los fragmentos que están dentro de los límites de la pila de llamadas.
con eso quiero decir si la longitud de los palíndromos es 1000. Podrías unir 0-250 y 750-1000 y unir 250-499 con 500-749. A continuación, puede pasar cada parte en la función. La ventaja de esto es que podría ejecutar el proceso en paralelo utilizando trabajadores web o subprocesos para conjuntos de datos muy grandes.
¿Que tal este?
const isPal = str => Array
.apply(null, new Array(strLen = str.length))
.reduce((acc, s, i) => acc + str[strLen - (i + 1)], '''') === str;
Aquí hay otra forma de hacerlo:
function isPalin(str) {
str = str.replace(//W/g,'''').toLowerCase();
return(str==str.split('''').reverse().join(''''));
}
Aquí hay una sola línea sin usar String.reverse,
function checkPalindrom(str) {
var str = str.replace(/[^a-zA-Z0-9]+/gi, '''').toLowerCase();
return str == str.split('''').reverse().join('''');
}
Creo que seguir la función con complejidad de tiempo de o (log n) será mejor.
function isPalindrome(s,i) {
return (i=i||0)<0||i>=s.length>>1||s[i]==s[s.length-1-i]&&isPalindrome(s,++i);
}
console.log (palindrom (12321));
ES6 forma de hacerlo. Tenga en cuenta que aprovecho el método de matriz reduceRight para revertir una cadena (puede usar métodos de matriz en cadenas si le da la cadena como contexto, ya que las cadenas de bajo nivel son matrices de caracteres). No, no tiene el mismo rendimiento que otras soluciones, pero no vio ninguna respuesta que lo obtuviera utilizando es6 o funciones de orden superior, así que pensé en lanzar esta por ahí.
const palindrome = str => {
const middle = str.length/2;
const left = str.slice(0, middle)
const right = Array.prototype.reduceRight.call(str.slice(Math.round(middle)), (str, char) => str + char, '''')
return left === right;
}
El código a continuación le indica cómo obtener una cadena de textBox y le dice si es un palíndromo y no muestra su respuesta en otro cuadro de texto
<html>
<head>
<meta charset="UTF-8"/>
<link rel="stylesheet" href=""/>
</head>
<body>
<h1>1234</h1>
<div id="demo">Example</div>
<a accessKey="x" href="http://www.google.com" id="com" >GooGle</a>
<h1 id="tar">"This is a Example Text..."</h1>
Number1 : <input type="text" name="txtname" id="numb"/>
Number2 : <input type="text" name="txtname2" id="numb2"/>
Number2 : <input type="text" name="txtname3" id="numb3" />
<button type="submit" id="sum" onclick="myfun()" >count</button>
<button type="button" id="so2" onclick="div()" >counnt</button><br/><br/>
<ol>
<li>water</li>
<li>Mazaa</li>
</ol><br/><br/>
<button onclick="myfun()">TryMe</button>
<script>
function myfun(){
var pass = document.getElementById("numb").value;
var rev = pass.split("").reverse().join("");
var text = document.getElementById("numb3");
text.value = rev;
if(pass === rev){
alert(pass + " is a Palindrome");
}else{
alert(pass + " is Not a Palindrome")
}
}
</script>
</body>
</html>
El código es conciso, rápido, rápido y comprensible.
TL; DR
Explicación:
Aquí, la función isPalindrome acepta un parámetro str que es una cadena de caracteres.
- Si la longitud del parámetro str es menor o igual que uno, simplemente devuelve "falso".
Si el caso anterior es falso, pasa a la segunda instrucción if y comprueba que si el carácter en la posición 0 de la cadena es el mismo que el del último lugar. Hace una prueba de desigualdad entre los dos.
str.charAt(0) // gives us the value of character in string at position 0 str.slice(-1) // gives us the value of last character in the string.
Si el resultado de la desigualdad es verdadero, entonces continúa y devuelve falso.
- Si el resultado de la declaración anterior es falso, entonces invoca recursivamente la función
isPalindrome(str)una y otra vez hasta el resultado final.
function isPalindrome(str){
if (str.length <= 1) return true;
if (str.charAt(0) != str.slice(-1)) return false;
return isPalindrome(str.substring(1,str.length-1));
};
document.getElementById(''submit'').addEventListener(''click'',function(){
var str = prompt(''whats the string?'');
alert(isPalindrome(str))
});
document.getElementById(''ispdrm'').onsubmit = function(){alert(isPalindrome(document.getElementById(''inputTxt'').value));
}
<!DOCTYPE html>
<html>
<body>
<form id=''ispdrm''><input type="text" id="inputTxt"></form>
<button id="submit">Click me</button>
</body>
</html>
Empecemos por la definición recursiva de un palíndromo:
- La cadena vacía '''' es un palíndromo
- La cadena que consta del carácter c, por lo tanto ''c'', es un palíndromo
- Si la cadena s es un palíndromo, entonces la cadena ''c'' + s + ''c'' para algún carácter c es un palíndromo
Esta definición se puede codificar directamente en JavaScript:
function isPalindrome(s) {
var len = s.length;
// definition clauses 1. and 2.
if (len < 2) {
return true;
}
// note: len >= 2
// definition clause 3.
if (s[0] != s[len - 1]) {
return false;
}
// note: string is of form s = ''a'' + t + ''a''
// note: s.length >= 2 implies t.length >= 0
var t = s.substr(1, len - 2);
return isPalindrome(t);
}
Aquí hay un código de prueba adicional para el shell mongo JavaScript de MongoDB, en un navegador web con depurador que reemplaza a print () con console.log ()
function test(s) {
print(''isPalindrome('' + s + ''): '' + isPalindrome(s));
}
test('''');
test(''a'');
test(''ab'');
test(''aa'');
test(''aab'');
test(''aba'');
test(''aaa'');
test(''abaa'');
test(''neilarmstronggnortsmralien'');
test(''neilarmstrongxgnortsmralien'');
test(''neilarmstrongxsortsmralien'');
Tengo esta salida:
$ mongo palindrome.js
MongoDB shell version: 2.4.8
connecting to: test
isPalindrome(): true
isPalindrome(a): true
isPalindrome(ab): false
isPalindrome(aa): true
isPalindrome(aab): false
isPalindrome(aba): true
isPalindrome(aaa): true
isPalindrome(abaa): false
isPalindrome(neilarmstronggnortsmralien): true
isPalindrome(neilarmstrongxgnortsmralien): true
isPalindrome(neilarmstrongxsortsmralien): false
Una solución iterativa es:
function isPalindrome(s) {
var len = s.length;
if (len < 2) {
return true;
}
var i = 0;
var j = len - 1;
while (i < j) {
if (s[i] != s[j]) {
return false;
}
i += 1;
j -= 1;
}
return true;
}
Esto prueba cada extremo de la cadena que sale hacia afuera y sale tan pronto como se detecta una falta de simetría.
function isPalindrome(word){
var head = 0;
var tail = word.length - 1;
var palindrome = true;
while (palindrome && (head < tail)) {
if (word.charAt(head) !== word.charAt(tail)){
return false
} else {
head ++;
tail --;
}
};
return true;
};
La mejor manera de verificar la cadena es palíndromo con más criterios como el caso y los caracteres especiales ...
function palindrome(str) {
var lenMinusOne = str.length - 1;
var halfLen = Math.floor(str.length / 2);
for (var i = 0; i < halfLen; ++i) {
if (str[i] != str[lenMinusOne - i]) {
return false;
}
}
return true;
}
Puede probarlo con las siguientes palabras y cadenas y le da un resultado más específico.
1. bob
2. Doc, nota, yo disiento. Un ayuno nunca evita una gordura. Hago dieta de bacalao
Para las cadenas, ignora los caracteres especiales y convierte las cadenas en minúsculas.
Lo más importante que debe hacer al resolver una prueba técnica es No utilice métodos de acceso directo , ¡ quieren ver cómo piensa de forma algorítmica! No es su uso de métodos.
Aquí hay uno que se me ocurrió (45 minutos después de que me hice la prueba). Hay un par de optimizaciones para hacer sin embargo. Al escribir cualquier algoritmo, es mejor asumir que es false y alterar la lógica si se busca que sea true .
isPalindrome() :
Básicamente, para que esto se ejecute en complejidad O (N) (lineal), querrá tener 2 iteradores cuyos vectores apuntan uno hacia el otro. Es decir, un iterador que comienza al principio y otro que comienza al final, cada uno viajando hacia adentro. Podría hacer que los iteradores atraviesen toda la matriz y usar una condición para break / return una vez que se encuentren en el medio, pero puede ahorrar algo de trabajo y solo dar a cada iterador una longitud media de forma predeterminada.
for bucles parecen forzar el uso de más controles, así que utilicé los bucles while, con los que me siento menos cómodo.
Aquí está el código:
/**
* TODO: If func counts out, let it return 0
* * Assume !isPalindrome (invert logic)
*/
function isPalindrome(S){
var s = S
, len = s.length
, mid = len/2;
, i = 0, j = len-1;
while(i<mid){
var l = s.charAt(i);
while(j>=mid){
var r = s.charAt(j);
if(l === r){
console.log(''@while *'', i, l, ''...'', j, r);
--j;
break;
}
console.log(''@while !'', i, l, ''...'', j, r);
return 0;
}
++i;
}
return 1;
}
var nooe = solution(''neveroddoreven''); // even char length
var kayak = solution(''kayak''); // odd char length
var kayaks = solution(''kayaks'');
console.log(''@isPalindrome'', nooe, kayak, kayaks);
Tenga en cuenta que si los bucles cuentan, devuelve true . Toda la lógica debe invertirse para que, por defecto, devuelva false . También utilicé un método de método abreviado String.prototype.charAt(n) , pero me sentí bien con esto ya que todos los idiomas soportan este método de forma nativa
Manera más rápida:
-Computar la mitad del camino en bucle.
- Almacene la longitud de la palabra en una variable en lugar de calcularla cada vez.
EDITAR: Almacene la longitud de palabra / 2 en una variable temporal para no calcular cada vez en el bucle como lo indica (mvw).
function isPalindrome(word){
var i,wLength = word.length-1,wLengthToCompare = wLength/2;
for (i = 0; i <= wLengthToCompare ; i++) {
if (word.charAt(i) != word.charAt(wLength-i)) {
return false;
}
}
return true;
}
Mira esto:
function isPalindrome(word){
if(word==null || word.length==0){
// up to you if you want true or false here, don''t comment saying you
// would put true, I put this check here because of
// the following i < Math.ceil(word.length/2) && i< word.length
return false;
}
var lastIndex=Math.ceil(word.length/2);
for (var i = 0; i < lastIndex && i< word.length; i++) {
if (word[i] != word[word.length-1-i]) {
return false;
}
}
return true;
}
Edición: ahora la mitad de la operación de comparación se realiza ya que itero solo hasta media palabra para compararla con la última parte de la palabra. ¡Más rápido para grandes datos!
Dado que la cadena es una matriz de caracteres, no es necesario utilizar funciones de caracteres.
Referencia: http://wiki.answers.com/Q/Javascript_code_for_palindrome
No estoy seguro de cómo este JSPerf verifica el rendimiento del código. Acabo de intentar revertir la cadena y comprobar los valores. Por favor comente sobre los Pros y Contras de este método.
function palindrome(str) {
var re = str.split(''''),
reArr = re.slice(0).reverse();
for (a = 0; a < re.length; a++) {
if (re[a] == reArr[a]) {
return false;
} else {
return true;
}
}
}
Nota: Esto distingue entre mayúsculas y minúsculas
function palindrome(word)
{
for(var i=0;i<word.length/2;i++)
if(word.charAt(i)!=word.charAt(word.length-(i+1)))
return word+" is Not a Palindrome";
return word+" is Palindrome";
}
Aquí está el violín: http://jsfiddle.net/eJx4v/
Para evitar errores con caracteres especiales utilice esta función a continuación
function palindrome(str){
var removeChar = str.replace(/[^A-Z0-9]/ig, "").toLowerCase();
var checkPalindrome = removeChar.split('''').reverse().join('''');
if(removeChar === checkPalindrome){
return true;
}else{
return false;
}
}
Para un mejor rendimiento también puedes usar este.
function palindrome(str) {
str = str.split("");
var i = str.length;
var check = "Yes"
if (i > 1) {
for (var j = 0; j < i / 2; j++) {
if (str[j] != str[i - 1 - j]) {
check = "NO";
break;
}
}
console.log(check);
} else {
console.log("YES");
}
}
Prueba esto:
var isPalindrome = function (string) {
if (string == string.split('''').reverse().join('''')) {
alert(string + '' is palindrome.'');
}
else {
alert(string + '' is not palindrome.'');
}
}
document.getElementById(''form_id'').onsubmit = function() {
isPalindrome(document.getElementById(''your_input'').value);
}
Entonces, este script alerta el resultado, es palíndromo o no. Necesitas cambiar el your_id con tu id de entrada y form_id con tu id de formulario para obtener este trabajo.
También podrías hacer algo como esto:
function isPalindrome(str) {
var newStr = '''';
for(var i = str.length - 1; i >=0; i--) {
newStr += str[i];
}
if(newStr == str) {
return true;
return newStr;
} else {
return false;
return newStr;
}
}
Tomando una puñalada en esto. Aunque es un poco difícil de medir el rendimiento.
function palin(word) {
var i = 0,
len = word.length - 1,
max = word.length / 2 | 0;
while (i < max) {
if (word.charCodeAt(i) !== word.charCodeAt(len - i)) {
return false;
}
i += 1;
}
return true;
}
Mi charCodeAt() es utilizar charCodeAt() lugar de charAt() con la esperanza de que asignar un Number lugar de una String tenga un mejor rendimiento porque las String s son de longitud variable y podrían ser más complejas de asignar. Además, solo se itera a la mitad ( como lo señala sai ) porque eso es todo lo que se requiere. Además, si la longitud es impar (por ejemplo, ''aba'' ), el carácter central siempre está bien.
Un simple código de una línea para verificar si la cadena es palíndromo o no:
function palindrome (str) {
return str === str.split("").reverse().join("");
}
<!-- Change the argument to check for other strings -->
<button type="button" onclick="alert(palindrome(''naman''));">Click Me<utton>
La función anterior devolverá true si la cadena es palíndromo. Si no, devolverá falso.
Usa algo como esto
function isPalindrome(s) {
return s == s.split("").reverse().join("") ? true : false;
}
alert(isPalindrome("noon"));
como alternativa, el código anterior puede optimizarse como [actualizado después del comentario del plegado derecho]
function isPalindrome(s) {
return s == s.split("").reverse().join("");
}
alert(isPalindrome("malayalam"));
alert(isPalindrome("english"));
str1 es la cadena original con caracteres y espacios no alfanuméricos eliminados y str2 es la cadena original invertida.
function palindrome(str) {
var str1 = str.toLowerCase().replace(//s/g, '''').replace(
/[^a-zA-Z 0-9]/gi, "");
var str2 = str.toLowerCase().replace(//s/g, '''').replace(
/[^a-zA-Z 0-9]/gi, "").split("").reverse().join("");
if (str1 === str2) {
return true;
}
return false;
}
palindrome("almostomla");
function palindrom(s){
s = s.toString();
var f = true; l = s.length/2, len = s.length -1;
for(var i=0; i < l; i++){
if(s[i] != s[len - i]){
f = false;
break;
}
}
return f;
}
Optimizado para el análisis de media cadena y para variables de valor constante.
function palindrome(s) {
var re = /[/W_]/g;
var lowRegStr = s.toLowerCase().replace(re, '''');
var reverseStr = lowRegStr.split('''').reverse().join('''');
return reverseStr === lowRegStr;
}
function palindrome(str) {
var len = str.length;
for ( var i = 0; i < Math.floor(len/2); i++ ) {
if (str[i] !== str[len - 1 - i]) {
return false;
}
}
return true;
}
palindrome regresará si la palabra especificada es palindrome, según el valor boolean (verdadero / falso)
ACTUALIZAR:
Abrí generosidad en esta pregunta debido al rendimiento y he investigado y aquí están los resultados:
Si estamos tratando con una gran cantidad de datos como
var abc = "asdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfd";
for ( var i = 0; i < 10; i++ ) {
abc += abc; // making string even more larger
}
function reverse(s) { // using this method for second half of string to be embedded
return s.split("").reverse().join("");
}
abc += reverse(abc); // adding second half string to make string true palindrome
En este ejemplo, Palindrome es True, solo para notar
La función palíndromo publicada nos da tiempo de 180 a 210 milisegundos (en el ejemplo actual), y la función publicada a continuación con string == string.split('''').reverse().join('''') método nos da 980 a 1010 milisegundos .
Detalles de la máquina:
Sistema: Ubuntu 13.10 Tipo de SO: 32 Bit RAM: 2 Gb CPU: 3.4 Ghz * 2 Navegador: Firefox 27.0.1
function palindrome(str){
for (var i = 0; i <= str.length; i++){
if (str[i] !== str[str.length - 1 - i]) {
return "The string is not a palindrome";
}
}
return "The string IS a palindrome"
}
palindrome("abcdcba"); //"The string IS a palindrome"
palindrome("abcdcb"); //"The string is not a palindrome";
Si console.log esta línea: console.log(str[i] + " and " + str[str.length - 1 - i]) , antes de la instrucción if, verá qué (str[str.length - 1 - i]) es. Creo que esta es la parte más confusa, pero la obtendrás fácilmente cuando la consultes en tu consola.
function pall (word) {
var lowerCWord = word.toLowerCase();
var rev = lowerCWord.split('''').reverse().join('''');
return rev.startsWith(lowerCWord);
}
pall(''Madam'');