Aiuto ricorsione

[Laker]

Buongiorno a tutti ragazzi, come va?
Dato che ho un po' di difficolta a pensare ricorsivamente, vorrei farvi esaminare un codice appunto ricorsivo...il metodo deve verificare se una data strigna è tandem, sapendo che tandem è una parola come "toctoc", ossia con stringe che si ripetono.

public class Tandem {
    private String parola;
    public Tandem(String parola) {
        this.parola = parola;
    }
    public String getParola() {
        return parola;
    }
    public boolean èTandem(String stringa) {
        if(stringa.length() < 2)
            return false;
        if(stringa.length() == 2) {
            char lettera1 = stringa.charAt(0);
            char lettera2 = stringa.charAt(1);
            if(lettera1 == lettera2)
                return true;
            else
                return false;
        }
        if(stringa.length() > 2) {
            String stringa1 = stringa.substring(0, stringa.length()/2);
            String stringa2 = stringa.substring(stringa.length()/2, stringa.length() - 1);
            for(int i = 0; i < stringa1.length(); i++) {
                for(int j = 0; j < stringa2.length(); j++) {
                    char lettera1 = stringa1.charAt(i);
                    char lettera2 = stringa2.charAt(j);
                    if(lettera1 == lettera2)
                        return true;
                }
            }
        }
        return èTandem(stringa);
    }
}

è valido secondo voi come metodo ricorsivo?

Grazie mille in anticipo

[Shores]

Mmm, questo tipo di problema a mio avviso non va risolto con la ricorsione, ma con un semplice confronto di stringhe: nella tua definizione, la stringa è tandem se la sua prima metà è uguale alla sua seconda metà.

Quindi, basterà verificare se la stringa è lunga un numero pari di caratteri, e in questo caso se la substringa della prima metà è identica alla substringa della seconda metà.

Inoltre, io non userei una lettera accentata nel nome di una funzione, mai... rischi errori di compilazione.

Detto questo, la tua funzione è comunque erronea e ridondante:

1) la chiamata ricorsiva return èTandem(stringa) sembra aggiunta alla fine del codice senza che abbia senso, e non è nemmeno condizionata a nulla: prova ad immaginare che cosa succederebbe se io chiamassi la tua funzione con stringa "aabb": la funzione andrebbe in un loop infinito.

2) fai un ciclo per confrontare due diverse stringhe carattere per carattere quando potresti confrontarle e basta!

3) crei una classe e un membro della classe (parola) che poi non usi mai!

    public boolean isTandem(String stringa) {
        if(stringa.length() % 2 != 0)
            return false;
       else
            return (stringa.substring(0, stringa.length()/2)==stringa.substring(stringa.length()/2));
    }
}

Volendo la funzione potrebbe essere resa ricorsiva, anche se non ne vedo l'utilità, facendo i modo che controlli solo la corrispondenza delle due lettere corrispondenti:

    public boolean isTandem(String stringa) {
        if(stringa.length() % 2 != 0)
            return false;
       else
            return (stringa.substring(0, 1)==stringa.substring(stringa.length()/2,1) && isTandem(stringa.substring(1,stringa.length()/2-1)+ stringa.substring(stringa.length()/2+1)));
    }
}

Ma mi sembra assolutamente ridondante!

[Laker]

so benissimo l'inutilità di utilizzare la ricorsione in questo tipo di esercizio, ma purtroppo mi è stato richiesto di farlo in questo modo...comunque grazie mille davvero