Articolo originale: Two Ways to Check for Palindromes in JavaScript
Questo articolo è basato sulla sfida di scripting di base di algoritmi di Free Code Camp " Check for Palindromes ".
Un palindromo è una parola, una frase, un numero o un'altra sequenza di caratteri che letta in senso inverso mantiene immutato il significato. La parola "palindromo" fu coniata per la prima volta dal drammaturgo inglese Ben Jonson nel XVII secolo, dalle radici greche palin ("di nuovo") e dromos ("via, direzione"). — src. Wikipedia
In questo articolo, spiegherò due approcci, il primo con le funzioni integrate e il secondo utilizzando un ciclo for.
Sfida dell'algoritmo
Restituiscitruese la stringa data è un palindromo. In caso contrario, restituiscifalse.
Un palindromo è una parola o una frase che mantiene il significato leggendolo sia in un verso che nell'altro, ignorando la punteggiatura, le maiuscole e la spaziatura.
Nota. Dovrai rimuovere tutti i caratteri non alfanumerici (punteggiatura, spazi e simboli) e portare tutto in minuscolo per verificare la presenza di palindromi.
Passeremo stringhe con diversi formati, come "racecar", "RaceCar" e "race CAR", e altri.
function palindrome(str) {
return true;
}
palindrome("eye");Casi di prova forniti
palindrome("race car")dovrebbe restituiretruepalindrome("not a palindrome")dovrebbe restituirefalsepalindrome("A man, a plan, a canal. Panama")dovrebbe restituiretruepalindrome("never odd or even")dovrebbe restituiretruepalindrome("nope")dovrebbe restituirefalsepalindrome("almostomla")dovrebbe restituirefalsepalindrome("My age is 0, 0 si ega ym.")dovrebbe restituiretruepalindrome("1 eye for of 1 eye.")dovrebbe restituirefalsepalindrome("0_0 (: /-\ :) 0–0")dovrebbe restituiretrue
Di quale espressione regolare avremo bisogno per superare l'ultimo test?
Le espressioni regolari sono modelli usati per abbinare le combinazioni di caratteri nelle stringhe.
Quando la ricerca di una corrispondenza richiede qualcosa di più di una corrispondenza diretta, il modello include caratteri speciali.
Per superare l'ultimo test case, possiamo utilizzare due espressioni regolari:
/[^A-Za-z0–9]/g o
/[\W_]/g\W rimuove tutti i caratteri non alfanumerici :
\Wcorrisponde a qualsiasi carattere diverso da una parola\Wè equivalente a[^A-Za-z0–9_]\Wcorrisponde a tutto ciò che non è racchiuso tra le parentesi
Che cosa significa?
[^A-Z] corrisponde a tutto ciò che non è incluso nel range tra A e Z
[^a-z] corrisponde a tutto ciò che non è incluso nel range tra a e z
[^0-9] corrisponde a tutto ciò che non è incluso nel range tra 0 e 9
[^_] corrisponde a tutto ciò che non include _Ma nel nostro caso testato, abbiamo bisogno del palindrome(" 0_0 (: /-\ :) 0–0 ") restituisca true , il che significa che _(: /-\ :)– deve corrispondere all'espressione regolare.
Dovremo aggiungere _ per superare questo caso di test specifico.
Ora abbiamo "\W_"Dovremo anche aggiungere il flag g per la ricerca globale.
Alla fine abbiamo "/[\W_]/g"/[\W_]/gè stato utilizzato a puro scopo dimostrativo per mostrare come funziona RegExp./[^A-Za-z0–9]/gè l'espressione regolare più semplice da scegliere .
1. Verifica la presenza di palindromi con funzioni integrate
Per questa soluzione utilizzeremo diversi metodi:
- Il metodo toLowerCase() per restituire il valore della stringa su cui [ invocato convertito in minuscolo.
- Il metodo replace() per restituire una nuova stringa con alcune o tutte le corrispondenze di un modello di abbinamento sostituite da una sostituzione. Useremo uno dei RegExp che abbiamo appena creato.
- Il metodo split() divide una stringa in un array di stringhe suddividendo la stringa in sottostringhe.
- Il metodo reverse() inverte un array sul posto. Il primo elemento dell'array diventa l'ultimo e l'ultimo diventa il primo.
- Il metodo join() unisce tutti gli elementi di un array in una stringa.
function palindrome(str) {
// Step 1. Metti in minuscolo la stringa e usa il regex per rimuovere i caratteri indesiderati da essa
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. Usa gli stessi metodi di concatenamento con le funzioni integrate del precedente articolo "Tre modi per invertire una stringa 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"
// Quindi, "amanaplanacanalpanama".split('').reverse().join('') = "amanaplanacanalpanama";
// E, var reverseStr = "amanaplanacanalpanama";
// Step 3. Verifica se reverseStr è rigorosamente uguale a lowRegStr e restituisce un valore booleano
return reverseStr === lowRegStr; // "amanaplanacanalpanama" === "amanaplanacanalpanama"? => true
}
palindrome("A man, a plan, a canal. Panama");Senza commenti:
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. Verificare la presenza di Palindromi con un Ciclo FOR
La mezza indicizzazione (len/2) offre vantaggi quando si elaborano stringhe di grandi dimensioni. Controlliamo la fine di ciascuna parte e dividiamo per due il numero di iterazioni all'interno del ciclo FOR.
function palindrome(str) {
// Step 1. La prima parte è la stessa di prima
var re = /[^A-Za-z0-9]/g; // or var re = /[\W_]/g;
str = str.toLowerCase().replace(re, '');
// Step 2. Crea il ciclo FOR
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]) { // Finché i caratteri di ciascuna parte corrispondono, il ciclo FOR continuerà
return false; // Quando i caratteri non corrispondono più, viene restituito false e usciamo dal ciclo FOR
}
/* Here len/2 = 15
Per ogni iterazione: i = ? i < len/2 i++ if(str[i] !== str[len - 1 - i])?
1a iterazione: 0 sì 1 if(str[0] !== str[15 - 1 - 0])? => if("a" !== "a")? // false
2a iterazione: 1 sì 2 if(str[1] !== str[15 - 1 - 1])? => if("m" !== "m")? // false
3a iterazione: 2 sì 3 if(str[2] !== str[15 - 1 - 2])? => if("a" !== "a")? // false
4a iterazione: 3 sì 4 if(str[3] !== str[15 - 1 - 3])? => if("n" !== "n")? // false
5a iterazione: 4 sì 5 if(str[4] !== str[15 - 1 - 4])? => if("a" !== "a")? // false
6a iterazione: 5 sì 6 if(str[5] !== str[15 - 1 - 5])? => if("p" !== "p")? // false
7a iterazione: 6 sì 7 if(str[6] !== str[15 - 1 - 6])? => if("l" !== "l")? // false
8a iterazione: 7 sì 8 if(str[7] !== str[15 - 1 - 7])? => if("a" !== "a")? // false
9a iterazione: 8 sì 9 if(str[8] !== str[15 - 1 - 8])? => if("n" !== "n")? // false
10a iterazione: 9 sì 10 if(str[9] !== str[15 - 1 - 9])? => if("a" !== "a")? // false
11a iterazione: 10 sì 11 if(str[10] !== str[15 - 1 - 10])? => if("c" !== "c")? // false
12a iterazione: 11 sì 12 if(str[11] !== str[15 - 1 - 11])? => if("a" !== "a")? // false
13a iterazione: 12 sì 13 if(str[12] !== str[15 - 1 - 12])? => if("n" !== "n")? // false
14a iterazione: 13 sì 14 if(str[13] !== str[15 - 1 - 13])? => if("a" !== "a")? // false
15a iterazione: 14 sì 15 if(str[14] !== str[15 - 1 - 14])? => if("l" !== "l")? // false
16a iterazione: 15 no
Fine del ciclo FOR*/
}
return true; // Entrambe le parti sono rigorosamente uguali, restituisce true => La stringa è un palindromo
}
palindrome("A man, a plan, a canal. Panama");Senza commenti:
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");Spero che tu l'abbia trovato utile. Questo fa parte della mia serie di articoli "Come risolvere gli algoritmi FCC" sulle sfide degli algoritmi di Free Code Camp, in cui propongo diverse soluzioni e spiego passo dopo passo cosa succede sotto il cofano.
Due modi per confermare la fine di una stringa in JavaScript
In questo articolo, spiegherò come risolvere la sfida "Conferma il finale" di freeCodeCamp.
Tre modi per invertire una stringa in JavaScript
Questo articolo è basato sullo scripting dell'algoritmo di base di Free Code Camp "Reverse a String"
Tre modi per fattorializzare un numero in JavaScript
Questo articolo si basa sullo scripting dell'algoritmo di base di Code Camp "Factorializzare un numero"
Tre modi per trovare la parola più lunga in una stringa in JavaScript
Questo articolo è basato sullo script dell'algoritmo di base di Free Code Camp "Trova la parola più lunga in una stringa".
Tre modi per capitalizzare una frase in JavaScript
Questo articolo è basato sull'algoritmo di base di Free Code Camp per lo scripting "Capitalizzare una frase".
Tre modi per trovare il numero più grande in un array usando JavaScript
In questo articolo, spiegherò come risolvere la sfida "Restituisci i numeri più grandi negli array" di Free Code Camp. Questo…
Se hai la tua soluzione o suggerimenti, condividili di seguito nei commenti.
Oppure puoi seguirmi su Medium , Twitter , Github e LinkedIn , subito dopo aver cliccato sul cuore verde qui sotto ;-)
# StayCurious, # KeepOnHacking & # MakeItHappen!