Deux façons de vérifier les palindromes en JavaScript

Cet article est basé sur le scripting d'algorithme de base de Free Code Camp «Check for Palindromes».

Un palindrome est un mot, une phrase, un nombre ou une autre séquence de caractères qui lit le même vers l'arrière ou vers l'avant. Le mot «palindrome» a été inventé par le dramaturge anglais Ben Jonson au 17ème siècle, à partir des racines grecques palin («encore») et dromos («chemin, direction»). - src. Wikipédia

Dans cet article, je vais expliquer deux approches, la première avec des fonctions intégrées et la seconde utilisant une boucle for.

Défi algorithme

Renvoie true si la chaîne donnée est un palindrome. Sinon, retournez false.

Un palindrome est un mot ou une phrase qui est orthographié de la même manière en avant et en arrière, ignorant la ponctuation, la casse et l'espacement.

Remarque. Vous devrez supprimer tous les caractères non alphanumériques (ponctuation, espaces et symboles) et mettre tout en minuscules pour vérifier les palindromes.

Nous passerons des cordes avec différents formats, tels que «racecar», «RaceCar» et «race CAR» entre autres.

function palindrome(str) { return true; } palindrome("eye");

Cas de test fournis

  • palindrome («voiture de course») devrait retourner vrai
  • palindrome («pas un palindrome»)devrait retourner faux
  • palindrome ("Un homme, un plan, un canal. Panama") devrait retourner vrai
  • palindrome ("jamais impair ou pair") doit retourner vrai
  • palindrome («non») doit renvoyer false
  • palindrome («nearomla») doit renvoyer false
  • palindrome ("Mon âge est 0, 0 si ega ym.") devrait renvoyer true
  • palindrome («1 œil pour 1 œil.») doit renvoyer faux
  • palindrome ("0_0 (: / - \ :) 0–0") doit retourner vrai

De quelle expression régulière aurons-nous besoin pour réussir le dernier cas de test?

Les expressions régulières sont des modèles utilisés pour faire correspondre les combinaisons de caractères dans les chaînes.

Lorsque la recherche d'une correspondance nécessite plus qu'une correspondance directe, le modèle inclut des caractères spéciaux.

To pass the last test case, we can use two Regular Expressions: /[^A-Za-z0–9]/g or /[\W_]/g

\ W supprime tous les caractères non alphanumériques :

  • \ W correspond à n'importe quel caractère autre qu'un mot
  • \ W équivaut à [^ A-Za-z0–9_]
  • \ W correspond à tout ce qui n'est pas entre crochets

Qu'est-ce que ça veut dire?

[^A-Z] matches anything that is not enclosed between A and Z [^a-z] matches anything that is not enclosed between a and z [^0-9] matches anything that is not enclosed between 0 and 9 [^_] matches anything that does not enclose _

Mais dans notre cas de test, nous avons besoin de palindrome (« 0_0 (: / - \ :) 0–0 ») pour renvoyer true , ce qui signifie que « _ (: / - \ :) - » doit être mis en correspondance.

Nous devrons ajouter « _ » pour réussir ce cas de test spécifique.

We now have “\W_”

Nous devrons également ajouter l' indicateur g pour la recherche globale.

We finally have “/[\W_]/g”
/ [\ W _] / g a été utilisé à des fins purement démonstratives pour montrer comment RegExp fonctionne. / [^ A-Za-z0–9] / g est la RegExp la plus simple à choisir .

1. Vérifiez les palindromes avec des fonctions intégrées

Pour cette solution, nous utiliserons plusieurs méthodes:

  • La méthode toLowerCase () pour renvoyer la valeur de la chaîne appelante convertie en minuscules.
  • La méthode replace () pour renvoyer une nouvelle chaîne avec certaines ou toutes les correspondances d'un modèle remplacées par un remplacement. Nous utiliserons l'un des RegExp que nous venons de créer précédemment.
  • La méthode split () divise un objet String en un tableau de chaînes en séparant la chaîne en sous-chaînes.
  • La méthode reverse () inverse un tableau en place. Le premier élément du tableau devient le dernier et le dernier devient le premier.
  • La méthode join () joint tous les éléments d'un tableau dans une chaîne.
function palindrome(str) { // Step 1. Lowercase the string and use the RegExp to remove unwanted characters from it var re = /[\W_]/g; // or var re = /[^A-Za-z0-9]/g; var lowRegStr = str.toLowerCase().replace(re, ''); // str.toLowerCase() = "A man, a plan, a canal. Panama".toLowerCase() = "a man, a plan, a canal. panama" // str.replace(/[\W_]/g, '') = "a man, a plan, a canal. panama".replace(/[\W_]/g, '') = "amanaplanacanalpanama" // var lowRegStr = "amanaplanacanalpanama"; // Step 2. Use the same chaining methods with built-in functions from the previous article 'Three Ways to Reverse a String in JavaScript' var reverseStr = lowRegStr.split('').reverse().join(''); // lowRegStr.split('') = "amanaplanacanalpanama".split('') = ["a", "m", "a", "n", "a", "p", "l", "a", "n", "a", "c", "a", "n", "a", "l", "p", "a", "n", "a", "m", "a"] // ["a", "m", "a", "n", "a", "p", "l", "a", "n", "a", "c", "a", "n", "a", "l", "p", "a", "n", "a", "m", "a"].reverse() = ["a", "m", "a", "n", "a", "p", "l", "a", "n", "a", "c", "a", "n", "a", "l", "p", "a", "n", "a", "m", "a"] // ["a", "m", "a", "n", "a", "p", "l", "a", "n", "a", "c", "a", "n", "a", "l", "p", "a", "n", "a", "m", "a"].join('') = "amanaplanacanalpanama" // So, "amanaplanacanalpanama".split('').reverse().join('') = "amanaplanacanalpanama"; // And, var reverseStr = "amanaplanacanalpanama"; // Step 3. Check if reverseStr is strictly equals to lowRegStr and return a Boolean return reverseStr === lowRegStr; // "amanaplanacanalpanama" === "amanaplanacanalpanama"? => true } palindrome("A man, a plan, a canal. Panama");

Sans commentaire:

function palindrome(str) { var re = /[\W_]/g; var lowRegStr = str.toLowerCase().replace(re, ''); var reverseStr = lowRegStr.split('').reverse().join(''); return reverseStr === lowRegStr; } palindrome("A man, a plan, a canal. Panama");

2. Vérifiez les palindromes avec une boucle FOR

La demi-indexation (len / 2) présente des avantages lors du traitement de chaînes volumineuses. Nous vérifions la fin de chaque partie et divisons le nombre d'itérations à l'intérieur de la boucle FOR par deux.

function palindrome(str) { // Step 1. The first part is the same as earlier var re = /[^A-Za-z0-9]/g; // or var re = /[\W_]/g; str = str.toLowerCase().replace(re, ''); // Step 2. Create the FOR loop var len = str.length; // var len = "A man, a plan, a canal. Panama".length = 30 for (var i = 0; i < len/2; i++) { if (str[i] !== str[len - 1 - i]) { // As long as the characters from each part match, the FOR loop will go on return false; // When the characters don't match anymore, false is returned and we exit the FOR loop } /* Here len/2 = 15 For each iteration: i = ? i  if("a" !== "a")? // false 2nd iteration: 1 yes 2 if(str[1] !== str[15 - 1 - 1])? => if("m" !== "m")? // false 3rd iteration: 2 yes 3 if(str[2] !== str[15 - 1 - 2])? => if("a" !== "a")? // false 4th iteration: 3 yes 4 if(str[3] !== str[15 - 1 - 3])? => if("n" !== "n")? // false 5th iteration: 4 yes 5 if(str[4] !== str[15 - 1 - 4])? => if("a" !== "a")? // false 6th iteration: 5 yes 6 if(str[5] !== str[15 - 1 - 5])? => if("p" !== "p")? // false 7th iteration: 6 yes 7 if(str[6] !== str[15 - 1 - 6])? => if("l" !== "l")? // false 8th iteration: 7 yes 8 if(str[7] !== str[15 - 1 - 7])? => if("a" !== "a")? // false 9th iteration: 8 yes 9 if(str[8] !== str[15 - 1 - 8])? => if("n" !== "n")? // false 10th iteration: 9 yes 10 if(str[9] !== str[15 - 1 - 9])? => if("a" !== "a")? // false 11th iteration: 10 yes 11 if(str[10] !== str[15 - 1 - 10])? => if("c" !== "c")? // false 12th iteration: 11 yes 12 if(str[11] !== str[15 - 1 - 11])? => if("a" !== "a")? // false 13th iteration: 12 yes 13 if(str[12] !== str[15 - 1 - 12])? => if("n" !== "n")? // false 14th iteration: 13 yes 14 if(str[13] !== str[15 - 1 - 13])? => if("a" !== "a")? // false 15th iteration: 14 yes 15 if(str[14] !== str[15 - 1 - 14])? => if("l" !== "l")? // false 16th iteration: 15 no End of the FOR Loop*/ } return true; // Both parts are strictly equal, it returns true => The string is a palindrome } palindrome("A man, a plan, a canal. Panama");

Sans commentaire:

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; } palindrome("A man, a plan, a canal. Panama");

J'espère que vous avez trouvé cela utile. Cela fait partie de ma série d'articles «Comment résoudre les algorithmes FCC» sur les défis de l'algorithme Free Code Camp, où je propose plusieurs solutions et explique étape par étape ce qui se passe sous le capot.

Deux façons de confirmer la fin d'une chaîne en JavaScript

Dans cet article, je vais vous expliquer comment résoudre le défi «Confirmer la fin» de freeCodeCamp.

Trois façons d'inverser une chaîne en JavaScript

Cet article est basé sur le script d'algorithme de base de Free Code Camp "Inverser une chaîne"

Trois façons de factoriser un nombre en JavaScript

Cet article est basé sur le script d'algorithme de base de Free Code Camp "Factorialiser un nombre"

Trois façons de trouver le mot le plus long dans une chaîne en JavaScript

Cet article est basé sur le scripting d'algorithme de base de Free Code Camp «Trouver le mot le plus long d'une chaîne».

Trois façons de titrer une phrase en JavaScript

Cet article est basé sur le scripting d'algorithme de base de Free Code Camp «Title Case a Sentence».

Trois façons de trouver le plus grand nombre dans un tableau à l'aide de JavaScript

Dans cet article, je vais vous expliquer comment résoudre le défi «Renvoyer les plus grands nombres dans les tableaux» de Free Code Camp. Ce…

Si vous avez votre propre solution ou des suggestions, partagez-les ci-dessous dans les commentaires.

Ou vous pouvez me suivre sur Medium , Twitter, Github et LinkedIn , juste après avoir cliqué sur le cœur vert ci-dessous ;-)

# StayCurious, # KeepOnHacking et # MakeItHappen!

Ressources

  • Expressions régulières - MDN
  • Méthode toLowerCase () - MDN
  • replace () - MDN
  • méthode split () - MDN
  • méthode reverse () - MDN
  • join (), méthode - MDN
  • String.length - MDN
  • pour - MDN