Parola palindroma in JavaScript, soluzioni palindroma

In questo tutorial verificheremo se una parola è palindroma in JavaScript.

Per risolvere questo algoritmo possiamo utilizzare varie soluzioni.

Utilizzo del metodo reverse per il calcolo della parola palindroma in JavaScript

In questa prima soluzione, la più semplice, ci appoggeremo al metodo reverse di JavaScript per verificare se la parola presa in input è palindroma.

Ma il metodo reverse si applica ad un array, dunque la soluzione è proprio quella di trasformare la stringa in un array. Il tutorial inerente il metodo reverse lo trovate al seguente link: metodo reverse sugli array.

Quindi utilizzeremo innanzitutto il metodo split per suddividere il testo in sottostringhe. Ricordiamo che, se utilizziamo il metodo indicando tra parentesi gli apici vuoti, otteniamo un array che contiene le lettere della parola.

Dunque supponendo di avere la seguente parola in input:

const parola = 'Osso';

Applichiamo il metodo split a parola:

let parolaDivisa = parola.split('');
console.log(parolaDivisa); // [ 'O', 's', 's', 'o' ]

Otterremo un array di 4 elementi, così composto:

0: “o”

1: “s”

2: “s”

3: “o”

Quindi adesso utilizziamo il metodo reverse per invertire l’array.

parolaDivisa = parolaDivisa.reverse();
console.log(parolaDivisa); [ 'o', 's', 's', 'O' ]

In questo caso otterremo l’array inverito, infatti la O maiuscola rappresenta l’ultima elemento dell’array. Provate con altre parole.

Adesso occorre riunire le lettere, per ottenere nuovamente la stringa e per fare questo utilizzeremo il metodo join:

const parolaInvertita = parolaDivisa.join('');
console.log(parolaInvertita);

Quindi dobbiamo solo confrontare la parola iniziale con quella invertita per verificare se è palindroma, per fare ciò utilizzeremo semplicemente un’istruzione condizionale.

if(parola === parolaInvertita){
  console.log('la parola è palindroma');
} else {
  console.log('la parola non è palindroma');
}

In questo caso avremmo in output: ‘la parola non è palindroma’ in quanto fa distinzione tra lettere maiscuole e minuscole.

Potremmo allora utilizzare toLowerCase() per convertire la parola iniziale in minuscolo. Di seguito il programma completo:

const parola = 'osso';
let parolaDivisa = parola.toLowerCase().split('');

parolaDivisa = parolaDivisa.reverse();

const parolaInvertita = parolaDivisa.join('');

if(parola === parolaInvertita){
  console.log('la parola è palindroma');
} else {
  console.log('la parola non è palindroma');
}

Il tutto si potrebbe risolvere con l’utilizzo di una funzione per poterla poi utilizzare su altri casi:


const parola = 'osso';

const parolaInversa = invertiParola(parola);

if(parola === parolaInversa){
    console.log('la parola è palindroma');
  } else {
    console.log('la parola non è palindroma');
  }
  
function invertiParola(str){
  const strInversa = str.toLowerCase().split('').reverse().join('');  
  return strInversa;
}

Esplora l’universo infinito della programmazione con ’50 Algoritmi per imparare JavaScript’, il libro che trasformerà la tua passione per il codice in realtà digitale!

Acquistalo su Amazon

Parola palindroma in JavaScript – seconda soluzione

Come vi dicevo, la soluzione presentata sopra non è l’unico modo per risolvere l’algoritmo. Possiamo trovare una soluzione che invece di utilizzare i metodi appena visti sopra, cerchi di prendere lettera per lettera e poi la ricomponga al contrario.

Quindi ci servirà un’istruzione ciclica sulla lunghezza della parola che ad ogni iterazione estrapoli ciascuna lettera.

Dunque con un ciclo while che scorre la parola partendo dalla fine, estraiamo ciascun carattere e lo inseriamo in una variabile. Dopo, con un’istruzione condizionale, verifichiamo se la parola presa in input è palindroma.

const parola ='osso';
let carattere;
let parolaInversa = '';

let i = parola.length - 1;

while (i >= 0) {
  carattere = parola[i];
  parolaInversa += carattere;
  console.log(carattere);
  i--;
}

console.log(parolaInversa);

if (parola === parolaInversa) {
    console.log('La parola è palindroma');
} else {
    console.log('La parola non è palindroma');
}

Possiamo al solito sviluppare una funzione così da riutilizzarla all’occorrenza:

const parola ='otto';
let parolaInversa = invertiParola(parola);

if (parola === parolaInversa){
    console.log('la parola è palindroma');
  } else {
    console.log('la parola non è palindroma');
}

function invertiParola(str){
  let parolaInversa = '';

  let i = str.length - 1;

  while (i >= 0) {
    parolaInversa += str[i];
    i--;
  }

  return parolaInversa;
}

Funzione ricorsiva per verificare se una parola è palindroma in JavaScript

Propongo adesso un’altra soluzione all’algoritmo utilizzando una funzione ricorsiva. Utilizzeremo anche i metodi per le stringhe, substring e charAt.

function invertiParola(str) {
  if (str !== "")
    return invertiParola(str.substr(1)) + str.charAt(0);
 else
   return ""; //quando terminerà l'estrazione delle lettere
}

console.log(invertiParola("coding"));

Quindi utilizzeremo delle chiamate nidificate. Quando richiamo invertiParola su coding, otterrò dunque questo risultato:

1 – invertiParola("coding") - 
substring(1) vuol dire che parte dalla pos. 1 fino alla fine 
+ charAt(0) cioè la prima lettera, 
quindi si ottiene il return di invertiParola("oding") + "c"
... e così via ... 
6 – invertiParola("g")   ritornerà invertiParola("") + "g"

Quindi nella seconda parte si avrà 
return invertiParola("") + "g" = "g"
return invertiParola("g") + "n" = "g" + "n"
... e così via ...
return invertiParola("oding") + "c" = "g" + "n" + "i" + "d" + "o" + "c"

In questa lezione abbiamo affrontato alcune possibili soluzioni alla parola palindroma in JavaScript, chiaramente ce ne possono essere tante altre, provate pure a sviluppare al vostra.

>> esercizi sulle stringhe

parola più lunga >>