Palindrome vérification en Javascript

25x plus rapide que la réponse standard

function isPalindrome(s,i) {
 return (i=i||0)<0||i>=s.length>>1||s[i]==s[s.length-1-i]&&isPalindrome(s,++i);
}

à utiliser comme:

isPalindrome('racecar');

comme il se définit "je" lui-même

Violon: http://jsfiddle.net/namcx0yf/9/

C'est environ 25 fois plus rapide que la norme de réponse ci-dessous.

function checkPalindrome(str) {
  return str == str.split('').reverse().join('');
}

Violon: http://jsfiddle.net/t0zfjfab/2/

Vue de la console pour les résultats de la performance.

Même si la solution est difficile à lire et à maintenir, je vous recommande de le comprendre pour démontrer la non-ramification avec la récursivité et le décalage de bits pour impressionner votre prochaine interviewer.

expliqué

Le || et && sont utilisés pour le contrôle de flux comme "si" "else". Si quelque chose à gauche de || est vrai, c'est juste des sorties avec vrai. Si quelque chose est faux à gauche de || il doit continuer. Si quelque chose de gauche && est faux, il sort comme faux, si quelque chose de gauche d'un && est vrai, il doit continuer. Ceci est considéré comme "non-ramification" comme il n'a pas besoin de si-sinon interupts, plutôt son juste évalués.

1. Utilisé un initialiseur ne nécessitant pas de "je" pour être défini comme un argument. Attribue le "je" pour elle-même si elle est définie, sinon initialiser à 0. Toujours est faux alors, la prochaine, OU la condition est toujours évalué.

(i = i || 0) < 0

2. Vérifie si "je" suis allé la moitié du chemin, mais ignore la vérification milieu bizarre char. Peu déplacé ici, c'est comme la division par 2, mais à la plus basse, même voisin de la division par 2 résultat. Si vrai, alors assume palindrome depuis sa déjà fait. Si la valeur est false évalue côté OU de l'état.

i >= s.length >> 1

3. Compare depuis le début de char et de fin char selon le "je" par la suite, de rencontrer des voisins ou voisins du moyen-char. Si la valeur est false sorties et n'assume PAS palindrome. Si la valeur est true continue sur suivant ET de l'état.

s[i] == s[s.length-1-i]

4. Appelle de nouveau pour la récursivité en passant la chaîne d'origine comme "s". Car "je" est défini pour sûr, à ce stade, il est pré-incrémenté à poursuivre la vérification de la position de la chaîne. Retourne la valeur booléenne indiquant si palindrome.

isPalindrome(s,++i)

MAIS...

Une simple boucle for est encore deux fois plus rapide que mon imagination réponse (alias principe de BAISER)

function fastestIsPalindrome(str) {
  var len = Math.floor(str.length / 2);
  for (var i = 0; i < len; i++)
    if (str[i] !== str[str.length - i - 1])
      return false;
  return true;
}

http://jsfiddle.net/6L953awz/1/

Il fonctionne pour moi

function palindrome(str) {
  /* remove special characters, spaces and make lowercase*/
  var removeChar = str.replace(/[^A-Z0-9]/ig, "").toLowerCase();

  /* reverse removeChar for comparison*/
  var checkPalindrome = removeChar.split('').reverse().join('');

  /* Check to see if str is a Palindrome*/
   return (removeChar === checkPalindrome);
}

Plus brefs CODE (31 caractères maximum)(ES6):

p=s=>s==[...s].reverse().join``
p('racecar'); //true

Garder à l'esprit court code n'est pas nécessairement la meilleure. La lisibilité et l'efficacité peut importe le plus.

Comme un beaucoup plus claire de la fonction récursive: http://jsfiddle.net/dmz2x117/

function isPalindrome(letters) {

    var characters  = letters.split(''),
        firstLetter = characters.shift(),
        lastLetter  = characters.pop();

    if (firstLetter !== lastLetter) {
        return false;
    }

    if (characters.length < 2) {
        return true;
    }

    return isPalindrome(characters.join(''));

}

La chose la plus importante à faire lors de la résolution d'un Test Technique est N'utilisez pas de méthodes de raccourci -- ils veulent voir comment vous penser avec des algorithmes! Pas votre utilisation de méthodes.

Voici celle que j'ai trouvé (45 minutes après j'ai fait sauter le test). Il y a quelques optimisations à faire si. Lors de l'écriture de l'algorithme, de son mieux pour assumer false et de modifier la logique si son qui cherchent à être true.

isPalindrome():

En gros, pour faire de cette course dans O(N) (linéaire) de la complexité que vous voulez avoir 2 itérateurs dont les vecteurs point les uns envers les autres. Sens, un itérateur qui commence au début et celle qui commence à la fin, chaque voyage vers l'intérieur. Vous pourriez avoir les itérateurs parcourir l'ensemble du tableau et utiliser une condition pour break/return une fois qu'ils se rencontrent au milieu, mais il peut gagner un peu de travail pour donner à chaque itérateur un demi-longueur par défaut.

for boucles semblent forcer l'utilisation de plus de vérifications, j'ai donc utilisé while boucles - je suis moins à l'aise avec.

Voici le code:

/**
 * 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);

Avis que si les boucles de comptage, il retourne true. La logique devrait être inversé de sorte qu'il renvoie par défaut false. J'ai aussi utilisé une méthode abrégée String.prototype.charAt(n), mais je me sentais OK avec ce que chaque langue prend nativement en charge cette méthode.

• = dans palindrom[i] = palindrom.charAt(palindrom.length)-1 devrait être == ou ===
• palindrom.charAt(palindrom.length)-1 devrait être palindrom.charAt(palindrom.length - i)

Partage mon jeûne variante qui a également en charge les espaces

JS:

function isPalindrom(str) {
  var ia = 0;
  var ib = str.length - 1;
  do {
    if (str[ia] === str[ib]) continue;

    //if spaces skip & retry
    if (str[ia] === ' ' && ib++) continue;
    if (str[ib] === ' ' && ia--) continue;

    return false;
  } while (++ia < --ib);
  return true;
}
var palindrom="never odd or even";
var res = isPalindrom(palindrom);
document.getElementById('check').innerHTML ='"'+ palindrom + '"'+" checked to be :" +res;

HTML:

<span id="check" />

Je me demandais pourquoi personne n'a suggéré ceci:

ES6:

//"aba" -> true
//"acb" -> false
//"aa" -> true
//"abba" -> true
//"s" -> true
isPalindrom = (str = "") => {
  if (str[0] === str[str.length - 1]) {
    return str.length <= 1 ? true : isPalindrom(str.slice(1, -1))
  }

  return false;
}

alert(["aba", "acb", "aa", "abba", "s"].map((e, i) => isPalindrom(e)).join())

ES5:

//"aba" -> true
//"acb" -> false
//"aa" -> true
//"abba" -> true
//"s" -> true
function isPalindrom(str) => {
  var str = typeof str !== "string" ? "" : str;

  if (str[0] === str[str.length - 1]) {
    return str.length <= 1 ? true : isPalindrom(str.slice(1, -1))
  }

  return false;
}

alert(["aba", "acb", "aa", "abba", "s"].map(function (e, i) {
    return isPalindrom(e);
}).join());

Je pensais que je voudrais partager ma propre solution:

JS:

function palindrome(string){
    var reverseString = '';
    for(var k in string){
       reverseString += string[(string.length - k) - 1];
    }
  if(string === reverseString){
    console.log('Hey there palindrome');
  }else{
    console.log('You are not a palindrome');
  }
}
palindrome('ana');

L'espère pourra aider quelqu'un.

J'ai trouvé ceci sur un site d'entrevue:

Écrire un efficace fonction qui vérifie si une permutation d'un
d'entrée de chaîne est un palindrome. Vous pouvez ignorer les signes de ponctuation, nous ne de soins
sur les personnages.

De jouer un peu avec elle, je suis venu avec ce vilain morceau de code 🙂

function checkIfPalindrome(text) {
    var found = {};
    var foundOne = 0;
    text = text.replace(/[^a-z0-9]/gi, '').toLowerCase();
    for (var i = 0; i < text.length; i++) {
        if (found[text[i]]) {
            found[text[i]]++;
        } else {
            found[text[i]] = 1;
        }
    }
    for (var x in found) {
        if (found[x] === 1) {
            foundOne++;
            if (foundOne > 1) {
                return false;
            }
        }
    }
    for (var x in found) {
        if (found[x] > 2 && found[x] % 2 && foundOne) {
            return false;
        }
    }
    return true;
}

Simplement laisser ici pour la postérité.

(JavaScript) à l'Aide de regexp, cette vérification pour alphanumériques palindrome et ne tient pas compte de l'espace et de la ponctuation.

function palindrome(str) {
  str = str.match(/[A-Za-z0-9]/gi).join("").toLowerCase();
  // (/[A-Za-z0-9]/gi) above makes str alphanumeric

  for(var i = 0; i < Math.floor(str.length/2); i++) { //only need to run for half the string length 
    if(str.charAt(i) !== str.charAt(str.length-i-1)) { //uses !== to compare characters one-by-one from the beginning and end
      return "Try again.";
    }
  }
  return "Palindrome!";
}
palindrome("A man, a plan, a canal. Panama.");
//palindrome("4_2 (: /-\ :) 2-4"); //This solution would also work on something like this.

`
function checkPalindrome (str) {
    var str = str.toLowerCase();
    var original = str.split(' ').join('');
    var reversed = original.split(' ').reverse().join('');

  return (original === reversed);
}
`

function myPolidrome(polidrome){
 var string=polidrome.split('').join(',');
 for(var i=0;i<string.length;i++){
    if(string.length==1){
     console.log("is polidrome");
   }else if(string[i]!=string.charAt(string.length-1)){
     console.log("is not polidrome");
     break;
  }else{
     return  myPolidrome(polidrome.substring(1,polidrome.length-1));
  }
  }
  }
myPolidrome("asasdsdsa");

Cela a fonctionné pour moi.

var number = 8008
number = number + "";
numberreverse = number.split("").reverse().join('');
console.log ("The number if reversed is: " +numberreverse);
if (number == numberreverse)
    console.log("Yes, this is a palindrome");
else
    console.log("Nope! It isnt a palindrome");

L'écriture de code pour la vérification des palindromes en suivant les meilleures pratiques de JavaScript:

JS:

(function(){
	'use strict';
	
	var testStringOne = "Madam";
	var testStringTwo = "testing";
	var testNull = null;
	var testUndefined;
	
	console.log(checkIfPalindrome(testStringOne));
	console.log(checkIfPalindrome(testStringTwo));
	console.log(checkIfPalindrome(testNull));
	console.log(checkIfPalindrome(testUndefined));
	
	function checkIfPalindrome(testStringOne){
		
		if(!testStringOne){
			return false;
		}
		
		var testArrayOne = testStringOne.toLowerCase().split("");
		testArrayOne.reverse();
		
		if(testArrayOne.toString() == testStringOne.toLowerCase().split("").toString()){
			return true;
		}else{
			return false;
		}
	}
	
})();

La solution avec ES6

isPalin = str => [...str].every((c, i) => c === str[str.length-1-i]);

function palindrome(str) {
//Good luck!
//convert the string into lowerCase.
 str = str.toLowerCase();
//this line remove all non=alphanumeric characters.
 strAlphaNum = str.replace(/[^a-z0-9]/g,"");
//this line create an array of the strAlphaNum string.
 strArray = strAlphaNum.split("");
//this line reverse the array
 strReversed = strArray.reverse();
//this line join the reversed array to make a string whithout space.
 strRevJoin = strReversed.join("");
//this condition check if the given string is a palindrome.
 if (strAlphaNum === strRevJoin){
 return true;}    
 else {return false;}
 }

<script>
    function checkForPally() {
        var input = document.getElementById("inputTable").value;
        var input = input.replace(/\s/g, ''); 
        var arrayInput = input.split(); 
        var inputReversed = arrayInput.reverse();
        var stringInputReversed = inputReversed.join("");

        if (input == stringInputReversed) {
            check.value = "The word you enter is a palindrome"
        }
        if (input != stringInputReversed) {
            check.value = "The word you entered is not a palindrome"
        }
    }
</script>

De la première utilisation de la getElement tag de la variable du palindrome. En le voyant comme un palindrome peut être composé de plusieurs mots que vous utilisez la regex entrée pour supprimer les espaces. Ensuite, vous utilisez la fonction de répartition pour convertir la chaîne en un tableau.

Ensuite, vous utilisez la méthode inverse à l'inverse de la matrice lorsque cela est fait, vous rejoignez l'inversion de la matrice de retour dans une chaîne. Enfin, il vous suffit d'utiliser un très de base si l'instruction pour vérifier l'égalité, si l'inversion de la valeur est equall à l'initiale de la variable que vous avez vous-même un palindrome.

Nice réponses ici.
Voici une autre approche.

    function checkPalindrom(palindrom){
      var len = palindrom.length; //get length of the word
      var pos = len-1;      //get index of the last character
      var median  = len/2  //get median character
      if(len <= 1){
         document.write("The word is a Palindrome");
      }else{
         for(var i = 0; i < median+1; i++){
           if(palindrom.charAt(i) == palindrom.charAt(pos-i)){
             document.write("The word is a Palindrome")
           }
         }
         document.write("The word is not a Palindrome")
      }       

      checkPalindrom('wordthatwillbechecked');