Acest articol se bazează pe Free Code Camp Basic Algorithm ScriptingVerificați dacă există palindromuri”.

Un palindrom este un cuvânt, o frază, un număr sau altă secvență de caractere care citește același înapoi sau înainte. Cuvântul „palindrom” a fost inventat pentru prima dată de dramaturgul englez Ben Jonson în secolul al XVII-lea, din rădăcinile grecești palin („Din nou”) și dromos („Cale, direcție”). – src. Wikipedia

În acest articol, voi explica două abordări, prima cu funcții încorporate și a doua folosind o buclă for.

Algorithm Challenge

Returnează true dacă șirul dat este un palindrom. În caz contrar, returnează fals.

Un palindrom este un cuvânt sau o propoziție scrisă în același mod atât în ​​față, cât și înapoi, ignorând punctuația, majusculele și spațiul.

Notă. Va trebui să eliminați toate caracterele nealfanumerice (punctuație, spații și simboluri) și transformați totul cu litere mici pentru a verifica palindromii.

Vom transmite șiruri cu diferite formate, cum ar fi „racecar”, „RaceCar” și „race CAR”, printre altele.

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

Cazuri de test furnizate

  • palindrom („mașină de curse”) ar trebui să revină adevărat
  • palindrom („nu un palindrom”) ar trebui să returneze fals
  • palindrom („Un om, un plan, un canal. Panama”) ar trebui să revină adevărat
  • palindrom („niciodată impar sau par”) ar trebui să revină adevărat
  • palindrom („nu”) ar trebui să returneze fals
  • palindrom („almostomla”) ar trebui să returneze fals
  • palindrom („Vârsta mea este 0, 0 si ega ym.”) ar trebui să revină adevărat
  • palindrom („1 ochi pentru 1 ochi”.) ar trebui să returneze fals
  • palindrom („0_0 (: / – 🙂 0-0”) ar trebui să revină adevărat

Care Expresie uzuala va trebui să trecem ultimul caz de testare?

Expresiile regulate sunt modele utilizate pentru a se potrivi combinațiilor de caractere din șiruri.

Când căutarea unei potriviri necesită ceva mai mult decât o potrivire directă, modelul include caractere speciale.

To pass the last test case, we can use two Regular Expressions:

/[^A-Za-z0–9]/g  or

/[W_]/g

W elimină toate caracterele nealfanumerice:

  • W se potrivește cu orice caracter fără cuvinte
  • W este echivalent cu [^A-Za-z0–9_]
  • W se potrivește cu orice nu este inclus între paranteze

Ce inseamna asta?

[^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 _

Dar în cazul nostru de testare, avem nevoie de palindrom („0_0 (: / – 🙂 0-0“) a se intoarce Adevărat, care înseamnă “_ (: / – 🙂 –”Trebuie să se potrivească.

Va trebui să adăugăm „_”Pentru a trece acest caz de test specific.

We now have “W_”

De asemenea, va trebui să adăugăm g pavilion pentru căutare globală.

We finally have “/[W_]/g”

/[W_]/ g a fost folosit în scop demonstrativ pur pentru a arăta cum funcționează RegExp. /[^A-Za-z0–9]/ g este cel mai simplu RegExp de ales.

1. Verificați dacă există palindromuri cu funcții încorporate

Pentru această soluție, vom folosi mai multe metode:

  • toLowerCase () metoda de a returna valoarea șirului de apel convertit în minuscule.
  • a inlocui() metoda de a returna un șir nou cu unele sau toate potrivirile unui model înlocuit cu un înlocuitor. Vom folosi unul dintre RegExp pe care tocmai l-am creat mai devreme.
  • Despică() metoda împarte un obiect String într-o matrice de șiruri prin separarea șirului în sub șiruri.
  • verso() metoda inversează o matrice în loc. Primul element matrice devine ultimul și ultimul devine primul.
  • a te alatura() metoda unește toate elementele unui tablou într-un șir.
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");

Fara comentarii:

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. Verificați dacă există palindromuri cu o buclă FOR

Jumătate de indexare (len / 2) are avantaje atunci când se procesează șiruri mari. Verificăm sfârșitul din fiecare parte și împărțim numărul de iterații din bucla FOR la ​​două.

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 < len/2    i++    if(str[i] !== str[len - 1 - i])?
      1st iteration:        0        yes         1     if(str[0] !== str[15 - 1 - 0])? => 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");

Fara comentarii:

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");

Sper că ți s-a părut de ajutor. Aceasta face parte din seria mea de articole „How to Solve FCC Algorithms” despre Provocările Algoritmului Taberei Codului Liber, unde propun mai multe soluții și explic pas cu pas ce se întâmplă sub capotă.

Două modalități de a confirma sfârșitul unui șir în JavaScript
În acest articol, vă voi explica cum să rezolvați provocarea „Confirmă sfârșitul” Routech.

Trei moduri de a inversa un șir în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Reverse a String”

Trei moduri de a factorializa un număr în JavaScript
Acest articol se bazează pe algoritmul de bază Free Code Camp Scripting „Factorializați un număr”

Trei moduri de a găsi cel mai lung cuvânt într-un șir în JavaScript
Acest articol se bazează pe algoritmul de bază Free Code Camp Scripting „Găsiți cel mai lung cuvânt într-un șir”.

Trei moduri de a titla o frază în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Title Case a Sentence”.

Trei moduri în care puteți găsi cel mai mare număr dintr-o matrice folosind JavaScript
În acest articol, vă voi explica cum să rezolvați provocarea „Returnează cele mai mari numere din matrice” din Free Code Camp. Acest…

Dacă aveți propria soluție sau sugestii, împărtășiți-le mai jos în comentarii.

Sau poți să mă urmărești mai departe Mediu, Stare de nervozitate, Github și LinkedIn, imediat după ce faceți clic pe inima verde de mai jos 😉

# StayCurious, # KeepOnHacking & # MakeItHappen!

Resurse