Soluzione del primo compitino

Transcript

1 Corso di Programmazione Anno Accademico Prof. Giovanni Pighizzini Soluzione del primo compitino Esercizio 1 Considerate la seguente dichiarazione di variabile: Sequenza<String> elenco; //si riferisce a una sequenza di oggetti String Supponete che elenco si riferisca a un oggetto già costruito (quindi non contiene null). Scrivete una porzione di codice alla fine della quale due variabili lungtot e nonlettere (da definire opportunamente) contengano, rispettivamente, la somma delle lunghezze delle stringhe presenti nella sequenza e il numero di stringhe che contengono almeno un carattere che non sia una lettera. Ad esempio, se la sequenza contiene le stringhe "Cane" "44 gatti" "" "123" "ZzZ!!!" le variabili lungtot e nonlettere dopo l esecuzione dovranno contenere rispettivamente 21 e 3. Soluzione Possiamo utilizzare un ciclo for-each in cui ad ogni iterazione si esamina una stringa della sequenza. for (String s: elenco)...esamina la stringa riferita da s... Per ciascuna stringa esaminata si deve: aggiungere alla variabile lungtot, dichiarata e inizializzata a zero prima del ciclo, la lunghezza della stringa in esame, ottenibile mediante il metodo length dell oggetto riferito da s; stabilire se la stringa riferita da s contenga almeno un carattere che non sia una lettera e, in tal caso, aggiungere 1 alla variabile nlettere (anch essa dichiarata e inizializzata a zero prima del ciclo). Esaminiamo più in dettaglio questa operazione: possiamo utilizzare una variabile nonlettera di tipo boolean, destinata a contenere true se si è trovato almeno un carattere che non sia una lettera. La variabile viene inizializzata a false. Si esamina quindi la stringa, carattere per carattere: se il carattere considerato non è una lettera, si pone a true la variabile nonlettera. Per verificare se il carattere non sia una lettera, possiamo ricorrere al metodo statico isletter di Character e negare la risposta ottenuta. Pertanto se lung contiene la lunghezza della stringa (ottenuta precedentemente) possiamo scrivere: c 2009 Giovanni Pighizzini Il contenuto di queste pagine è protetto dalle leggi sul copyright e dalle disposizioni dei trattati internazionali. Il titolo ed i copyright relativi alle pagine sono di proprietà dell autore. Le pagine possono essere riprodotte ed utilizzate liberamente dagli studenti, dagli istituti di ricerca, scolastici e universitari afferenti al Ministero dell Istruzione, dell Università e della Ricerca, per scopi istituzionali, non a fine di lucro. Ogni altro utilizzo o riproduzione (ivi incluse, ma non limitatamente a, le riproduzioni a mezzo stampa, su supporti magnetici o su reti di calcolatori) in toto o in parte è vietata, se non esplicitamente autorizzata per iscritto, a priori, da parte dell autore. L informazione contenuta in queste pagine è ritenuta essere accurata alla data della pubblicazione. Essa è fornita per scopi meramente didattici e non per essere utilizzata in progetti di impianti, prodotti, ecc. L informazione contenuta in queste pagine è soggetta a cambiamenti senza preavviso. L autore non si assume alcuna responsabilità per il contenuto di queste pagine (ivi incluse, ma non limitatamente a, la correttezza, completezza, applicabilità ed aggiornamento dell informazione). In ogni caso non può essere dichiarata conformità all informazione contenuta in queste pagine. In ogni caso questa nota di copyright non deve mai essere rimossa e deve essere riportata anche in utilizzi parziali.

2 Soluzione del primo compitino 2 boolean nonlettera = false; for (int i = 0; i < lung; i++) { char c = s.charat(i) if (!Character.isLetter(c)) nonlettera = true; Dopo la scansione della stringa, decidiamo se incrementare nonlettere: if (nonlettera) nonlettere = nonlettere + 1; Il codice risultante, riscritto senza utilizzare la variabile c, è: int lungtot = 0; int nonlettere = 0; for (String s: elenco) { int lung = s.length(); lungtot = lungtot + lung; boolean nonlettera = false; for (int i = 0; i < lung; i++) if (!Character.isLetter(s.charAt(i))) nonlettera = true; if (nonlettera) nonlettere = nonlettere + 1; In realtà, una volta che esaminando un carattere di una stringa si verifica che esso non è una lettera, è inutile continuare ad esaminare gli altri caratteri della stessa stringa. Si può quindi introdurre un istruzione break (da documentare vicino all intestazione del for), nel corpo dell if. L ultima parte del corpo del ciclo esterno può essere dunque riscritta come: boolean nonlettera = false; for (int i = 0; i < lung; i++) // terminazione anche con break! if (!Character.isLetter(s.charAt(i))) { nonlettera = true; break; if (nonlettera) nonlettere = nonlettere + 1; Osserviamo che a questo punto, ogni volta che si assegna true a nonlettera, si passa poi a incrementare nonlettere. Pertanto, possiamo rimuovere la variabile di tipo boolean ed eseguire direttamente l incremento, sostituendo la sequenza di istruzioni scritta sopra con: for (int i = 0; i < lung; i++) // terminazione anche con break! if (!Character.isLetter(s.charAt(i))) { nonlettere = nonlettere + 1; break; Note ed errori frequenti Uso scorretto del costrutto for-each.

3 Soluzione del primo compitino 3 Le posizioni nelle stringhe sono contate a partire da 0 e non da 1. Ogni elemento della sequenza riferita da elenco è un oggetto di tipo String. 1. Un metodo statico è un servizio offerto da una classe e pertanto deve essere invocato indicando il nome della classe che lo fornisce. Se si usa break per provocare la terminazione del ciclo, è bene evidenziarne la presenza con un breve commento vicino alla condizione del ciclo. L uso dell assegnamento i = lung per provocare prematuramente la terminazione del ciclo for è un pessimo stile di programmazione. Per questo scopo esiste break. Le istruzioni break e continue hanno significati differenti. Il tipo char non contiene solo lettere e cifre: è sbagliato utilizzare il metodo isdigit di Character per controllare che un carattere non sia una lettera. È inutile riempire il codice di parentesi graffe destinate a contenere una sola istruzione: è bene limitare l uso delle graffe ai casi in cui vi sia la necessità di raggruppare più istruzioni. Esercizio 2 Completate il seguente metodo main in modo che legga due stringhe inserite dall utente. Il metodo deve poi stabilire e comunicare se la seconda stringa sia un fattore della prima. In caso affermativo il metodo deve inoltre: (a) indicare a partire da quale carattere della prima stringa compare la seconda stringa; tale indicazione deve essere fornita, all interno di un messaggio all utente, come numero ordinale scritto in lettere (si vedano gli esempi); se la stringa appare più volte, è richiesta l indicazione della posizione della prima occorrenza; (b) visualizzare il prefisso della prima stringa che precede la prima occorrenza della seconda stringa e il suffisso che la segue. Note: - Una stringa è un fattore di un altra se appare contiguamente all interno di essa. Ad esempio, cambi è un fattore di scambiare e di cambiamento, ma non di cambogia. - Un fattore che non è preceduto da nulla viene detto prefisso, un fattore che non è seguito da nulla viene detto suffisso. Ad esempio, nella stringa scambiare, il prefisso che precede cambi è s, il suffisso che lo segue è are. - Non preoccupatevi delle questioni relative alle maiuscole e minuscole, che sono considerate diverse. Pertanto Cambi non è un fattore di scambiare. - Attenzione: nel messaggio fornito all utente la posizione della stringa va indicata contando i caratteri secondo l uso comune e non secondo le convenzioni di Java. Esempi di esecuzione Dove cercare? cambiamento Cosa cercare? cambi cambi appare in cambiamento dal primo carattere Prefisso precedente: Suffisso seguente: amento 1 Si osservi che tra gli elementi di una Sequenza non vi possono essere riferimenti null.

4 Soluzione del primo compitino 4 Dove cercare? scambio Cosa cercare? cambi cambi appare in scambio dal secondo carattere Prefisso precedente: s Suffisso seguente: o Dove cercare? cambogia Cosa cercare? cambi cambi non appare in cambogia Dove cercare? cambiamento Cosa cercare? am am appare in cambiamento dal secondo carattere Prefisso precedente: c Suffisso seguente: biamento public static void main(string[] args) { ConsoleInputManager in = new ConsoleInputManager(); ConsoleOutputManager out = new ConsoleOutputManager(); String dove = in.readline("dove cercare? ");... Soluzione Iniziamo a completare la parte di lettura del metodo main: String dove = in.readline("dove cercare? "); String cosa = in.readline("cosa cercare? "); A questo punto il metodo deve stabilire se la stringa referita da dove contenga quella riferita da cosa. A tale scopo può essere utilizzato il metodo contains della classe String. In base al risultato di questo controllo andranno forniti messaggi differenti: if (dove.contains(cosa))..comunica quanto indicato nei punti (a) e (b) del testo dell esercizio... else...comunica che la seconda stringa non appare nella prima... La parte else può essere realizzata semplicemente con l istruzione: out.println(cosa + " non appare in " + dove); Sviluppiamo ora l altra parte della selezione, seguendo l ordine indicato ai punti (a) e (b) dell esercizio. Determiniamo la posizione in cui cosa appare in dove. A tale scopo possiamo utilizzare il metodo indexof: int i = dove.indexof(cosa); Dobbiamo osservare che il valore ottenuto, memorizzato nella variabile i, corrisponde alla convenzione di Java, in cui le posizioni sono numerate a partire da 0. Per contare da 1, secondo l uso comune, dovremo dunque considerare i + 1.

5 Soluzione del primo compitino 5 Otteniamo la stringa che rappresenta in lettere la posizione, e la visualizziamo, come negli esempi. Poiché è richiesta la stringa in lettere come numero ordinale, rappresentiamo il numero come oggetto della classe Intero e ne invochiamo il metodo toordinalstring. Scriviamo pertanto le seguenti istruzioni: int i = dove.indexof(cosa); Intero ii = new Intero(i + 1); // i + 1 per contare da 1! String is = ii.toordinalstring(); out.println(cosa + " appare in " + dove + " dal " + is + " carattere"); Ricaviamo e visualizziamo il prefisso e suffisso richiesti. Per ricavare queste stringhe ricorriamo ai metodi substring con gli opportuni argomenti, visualizzando poi il risultato: String prefisso = dove.substring(0, i); String suffisso = dove.substring(i + cosa.length()); out.println("prefisso precedente: " + prefisso); out.println("suffisso seguente: " + suffisso); Ecco il metodo main completo, inserito in una classe, e preceduto dalla direttive di importazione (non richieste per lo svolgimento del compitino): import prog.io.consoleinputmanager; import prog.io.consoleoutputmanager; import prog.utili.intero; class CercaStringa { public static void main(string[] a) { ConsoleInputManager in = new ConsoleInputManager(); ConsoleOutputManager out = new ConsoleOutputManager(); String dove = in.readline("dove cercare? "); String cosa = in.readline("cosa cercare? "); if (dove.contains(cosa)) { //cerca la posizione di cosa in dove... int i = dove.indexof(cosa); //...e ne ottiene la rappresentazione in lettere Intero ii = new Intero(i + 1); // i + 1 per contare da 1! String is = ii.toordinalstring(); //visualizza il risultato out.println(cosa + " appare in " + dove + " dal " + is + " carattere"); //calcola e visualizza prefisso e suffisso String prefisso = dove.substring(0, i); String suffisso = dove.substring(i + cosa.length()); out.println("prefisso precedente: " + prefisso); out.println("suffisso seguente: " + suffisso);

6 Soluzione del primo compitino 6 else out.println(cosa + " non appare in " + dove); Anziché utilizzare il metodo contains per la condizione della selezione, si può utilizzare il risultato di indexof (-1 indica che il fattore cercato non c è). A tale scopo, è opportuno spostare la dichiarazione e l assegnamento int i = dove.indexof(cosa); prima della selezione, modificando la condizione in i!= -1 Esercizio 2 Completate il seguente metodo main in modo che: (a) legga un numero intero e lo visualizzi in lettere (b) legga una stringa (c) controlli se la stringa letta è un fattore della stringa che rappresenta in lettere il numero intero e, in caso affermativo, ricavi la stringa che si ottiene cancellando la stringa letta dalla stringa che rappresenta il numero (nel caso la stringa letta appaia più volte, cancellate solo la prima occorrenza, nel caso non appaia non cancellate nulla); (d) visualizzi il tutto come fosse una sottrazione, esattamente nello stesso formato presentato negli esempi di esecuzione che seguono. Note: - Una stringa è un fattore di un altra se appare contiguamente all interno di essa. Ad esempio, odi è un fattore di dodici e di odissea, ma non di modelli. - Non preoccupatevi delle questioni relative alle maiuscole e minuscole, che sono considerate diverse. Pertanto Odi non è un fattore di dodici. Esempi di esecuzione Numero in cifre? 7 sette Cosa cercare? t sette - t = sete Numero in cifre? 44 quarantaquattro Cosa cercare? qua quarantaquattro - qua = rantaquattro Numero in cifre? 125 centoventicinque Cosa cercare? venti centoventicinque - venti = centocinque Numero in cifre? 125 centoventicinque

7 Soluzione del primo compitino 7 Cosa cercare? dieci centoventicinque - dieci = centoventicinque public static void main(string[] args) { ConsoleInputManager in = new ConsoleInputManager(); ConsoleOutputManager out = new ConsoleOutputManager(); int num = in.readint("numero in cifre? ");... Soluzione Il metodo main, dopo la lettura del numero con l istruzione: int num = in.readint("numero in cifre? "); deve visualizzare il numero scritto in lettere (punto (a) dell esercizio). A tale scopo, il numero può essere rappresentato come oggetto della classe Intero, ricavando, mediante il metodo tostring, la corrispondente stringa in lettere. Un riferimento a tale stringa, che oltre a dover essere visualizzata, sarà utile anche successivamente, viene memorizzato in una variabile nums: Intero numi = new Intero(num); String nums = numi.tostring(); out.println(nums); La lettura della stringa (punto (b)) è semplicemente: String s = in.readline("cosa cercare? "); Scriviamo ora il codice per i punti (c) e (d). Sulla base degli esempi, il messaggio che dovrà essere visualizzato si compone delle seguenti parti: il numero letto, espresso in lettere; la variabile nums contiene già il riferimento alla stringa che dobbiamo utilizzare per questa parte; il simbolo - (preceduto e seguito da uno spazio, per separarlo dal resto); la stringa letta, il cui riferimento è nella variable s; il simbolo = (preceduto e seguito da uno spazio, per separarlo dal resto); la stringa ottenuta secondo quanto indicato al punto (c). Supponendo che una variabile risultato di tipo String contenga un riferimento alla stringa richiesta al punto (c), l istruzione finale di visualizzazione sarà: out.println(nums + " - " + s + " = " + risultato); Studiamo ora come ottenere risultato. Occorre stabilire se la stringa che rappresenta il numero, cioè la stringa referita da nums, contenga come fattore quella riferita da s. A tale scopo può essere utilizzato il metodo contains della classe String. In base al risultato di questo test andranno forniti messaggi differenti: if (nums.contains(s)) risultato = stringa ottenuta cancellando la stringa riferita da s da quella riferita da nums else risultato = nums

8 Soluzione del primo compitino 8 Per ricavare la stringa richiesta nel caso la condizione sia vera, procediamo come segue. Determiniamo la posizione in cui s appare in nums. A tale scopo possiamo utilizzare il metodo indexof: int i = nums.indexof(s); Ricaviamo il prefisso e suffisso che, rispettivamente, precedono e seguono il fattore corrispondente a s. Per ricavare queste stringhe ricorriamo ai metodi substring con gli opportuni argomenti: String prima = nums.substring(0, i); String dopo = nums.substring(i + s.length()); La stringa cercata è data dalla concatenazione di queste due stringhe: risultato = prima + dopo; Ecco il metodo main completo, inserito in una classe, e preceduto dalla direttive di importazione (non richieste per lo svolgimento del compitino): import prog.io.*; import prog.utili.intero; class Cancella { public static void main(string[] a) { ConsoleInputManager in = new ConsoleInputManager(); ConsoleOutputManager out = new ConsoleOutputManager(); int num = in.readint("numero in cifre? "); //costruisce un oggetto Intero che rappresenta num Intero numi = new Intero(num); //ricava la stringa che rappresenta il numero in lettere... String nums = numi.tostring(); out.println(nums); //...e la visualizza //lettura della stringa String s = in.readline("cosa cercare? "); //determina la stringa risultato String risultato; if (nums.contains(s)) { //cerca la stringa riferita da s int i = nums.indexof(s); String prima = nums.substring(0, i); String dopo = nums.substring(i + s.length()); risultato = prima + dopo; else risultato = nums; //visualizza la sottrazione

9 Soluzione del primo compitino 9 out.println(nums + " - " + s + " = " + risultato); Anziché utilizzare il metodo contains per la condizione della selezione, si può utilizzare il risultato di indexof, come indicato nella soluzione dell esercizio precedente. Note ed errori frequenti I meccanismi di autoboxing e unboxing sono disponibili esclusivamente tra i tipi primitivi e le corrispondenti classi involucro. La classe involucro per int è Integer e non Intero. Pertanto per ottenere un oggetto della classe Intero che rappresenti un dato int, è necessario utilizzare esplicitamente il costruttore di Intero. La variabile num è del tipo primitivo int. Pertanto non possono essere invocati metodi utilizzando num come fosse un riferimento. Scritture come num.tostring... o num.length... non hanno alcun senso. Mentre l operatore + tra stringhe indica la concatenazione, non esiste un operatore - per cancellare. Per ottenere la stringa risultante dalla cancellazione, richiesta dall esercizio, si doveva procedere come nella soluzione, concatenando il prefisso che precede la parte da cancellare, con il suffisso che la segue. Il prefisso e il suffisso possono essere ricavati con i metodi substring. Attenzione all uso degli indici dei metodi substring: il metodo con due argomenti riceve l indice della prima posizione da considerare e l indice della prima posizione (successiva alla precedente) da non considerare. Secondo le convenzioni del linguaggio gli indici vengono contati a partire da zero. Esercizio 3 Date due variabili c e d di tipo double, si considerino le seguenti due espressioni: c >= d - 2 c < d (a) Esprimete in linguaggio Java la congiunzione delle due espressioni. (b) Esprimete in linguaggio Java la negazione dell espressione ottenuta al punto precedente, senza utilizzare l operatore! di negazione. Soluzione L operatore di congiunzione (AND) è indicata in Java con il simbolo &&. Pertanto, per il punto (a) è sufficiente scrivere: c >= d - 2 && c < d Applicando le leggi di De Morgan, la negazione della condizione precedente è esprimibile come!(c >= d - 2)!(c < d) Ricordandando che la negazione di >= e < sono uno la negazione dell altro, otteniamo: c < d - 2 c >= d

10 Soluzione del primo compitino 10 Note ed errori frequenti Non si devono confondere gli operatori di congiunzione e di disgiunzione. Attenzione alla negazione degli operatori di confronto: la negazione di < non è >, ma >=. Le negazione di <= è >, ecc. Gli operatori && e sono preferibili ai corrispondenti operatori orientati ai bit & e, per i quali la valutazione è meno efficiente, non utilizzando il meccanismo della lazy evaluation. Esercizio 4 Siano x e y due variabili di tipo int. Indicate i valori che conterrà ciascuna delle due variabili dopo l esecuzione dei seguenti frammenti di codice, nell ipotesi che prima dell esecuzione di ciascuno di essi x contenga 4 e y contenga 9: (a) x = (y = x) + y++; (b) x = y++ + (y = x); (c) x = (x = y++) + y; (d) x = y + (x = y++); Soluzione Osserviamo prima di tutto che in tutte le espressioni sul lato destro degli assegnamenti vi sono due effetti collaterali: uno dovuto all assegnamento a y che modifica la variabile y fornendo, come valore ai fini del calcolo dell espressione, il valore assegnato; l altro è dovuto all operatore di incremento postfisso nell espressione y++ che produce il valore di y ai fini del calcolo dell espressione e provoca subito dopo un incremento. Per risolvere l esercizio occorre prestare particolare attenzione all ordine con cui vengono eseguite le operazioni, in particolare all ordine con cui vengono valutati gli operandi della somma sul lato destro dell assegnamento. Ricordiamo che all inizio i contenuti delle variabili sono: x == 4 y == 9 (a) x = (y = x) + y++; Per valutare l operando sinistro di +, viene eseguito l assegnamento y = x. Si ottiene pertanto: x == 4 y == 4 operando sx == 4 Per valutare l operando destro si deve applicare l operatore di decremento postfisso: questo produce prima di tutto il valore di y come risultato, che sarà dunque l operando destro, e poi l incremento della variabile y: x == 4 y == 5 operando sx == 4 operando dx == 4 Il risultato della somma è dunque 8, che viene assegnato a x, ottenendo: x == 8 y == 5 (b) x = y++ + (y = x); Dalla situazione iniziale, con la valutazione dell operando sinistro, y++, si ottiene: x == 4 y == 10 operando sx == 9 Si valuta quindi l operando destro y = x: x == 4 y == 4 operando sx == 9 operando dx == 4 Pertanto, dopo il calcolo della somma e dell assegnamento, si ha: x == 13 y == 4 (c) x = (x = y++) + y; Per valutare l operando sinistro di + è necessario assegnare a x il risultato dell espressione y++. Il valore assegnato sarà anche il valore dell operando sinistro. Come nei casi precedenti,

11 Soluzione del primo compitino 11 l espressione y++ produce, prima di tutto, come risultato il valore presente in y, in questo caso 9 e poi provoca l incremento di y. Pertanto, dopo la valutazione di x = y++, si ha: x == 9 y == 10 operando sx == 9 L operando destro è direttamente il valore di y, che ora è 10. Pertanto, il risultato della somma è 19. Dunque, dopo l esecuzione si ha: x == 19 y == 10 (d) x = y + (x = y++); L operando sinistro di + è il valore contenuto in y: x == 4 y == 9 operando sx == 9 La valutazione dell operando destro, avviene secondo i passi descritti al punto precedente, provocando effetti collaterali sia su x sia su y: x == 9 y == 10 operando sx == 9 operando dx == 9 Dopo l esecuzione della somma si ha dunque: x == 18 y == 10 Note ed errori frequenti È fondamentale fare attenzione all ordine con cui vengono valutate gli operatori nelle espressioni e all ordine con cui si producono gli effetti collaterali. Nell operatore di incremento postfisso si produce il valore dell espressione (che coincide con il contenuto della variabile da incrementare) e subito dopo si effettua l incremento della variabile. Esercizio 5 Supponete che in, di tipo ConsoleInputManager, sia un riferimento alla tastiera. Per ognuno dei seguenti frammenti di codice, rispondete alle domande: L esecuzione può essere infinita (cioè non terminare)? stringa in ingresso per cui ciò avvenga. Se avete risposto sì, indicate una L esecuzione può terminare? Se avete risposto sì, indicate una stringa in ingresso per cui ciò avvenga. (a) String t = in.readline("stringa? "); String s = t + t; while (s!= t) s = s.substring(s.length() / 2); (b) String t = in.readline("stringa? "); String s = t + t; while (s == t) s = s.substring(s.length() / 2); (c) String t = in.readline("stringa? "); String s = t + t; while (s.equals(t)) s = s.substring(s.length() / 2); (d) String t = in.readline("stringa? "); String s = t + t; while (!s.equals(t)) s = s.substring(s.length() / 2);

12 Soluzione del primo compitino 12 Soluzione I quattro frammenti di codice differiscono solo per la condizione del ciclo. La prima istruzione assegna alla variabile t il riferimento a una stringa inserita dall utente. La seconda istruzione assegna a s il riferimento a una stringa data dalla concatenazione di t con se stessa. La condizione nel frammento (a) confronta i due riferimenti s e t, che sono inizialemente diversi. Ad ogni iterazione, a s viene assegnato il riferimento a una nuova stringa, ottenuta mediante il metodo substring. Quindi, durante l esecuzione il riferimento in s non potrà mai diventare uguale al riferimento in t che, invece, non viene modificato. Pertanto la condizione è sempre vera. Dunque il ciclo è infinito per qualunque stringa fornita in ingresso, e dunque non può mai terminare. Per le stesse ragioni, nel caso (b) la condizione è immediatamente falsa. Pertanto l esecuzione termina subito, qualunque sia la stringa in ingresso. Nel caso (c) la condizione utilizza il metodo equals della classe String che verifica l uguaglianza tra le stringhe. Nel caso venga inserita la stringa vuota, sia t che s si riferiranno a oggetti che rappresentano tale stringa. Inoltre, l oggetto ottenuto nel corpo del ciclo, mediante il metodo substring rappresenta anch esso la stringa vuota. Dunque leggendo la stringa vuota il ciclo non termina. Se invece viene letta una stringa non vuota, la condizione risulta immediatamente falsa, e l esecuzione termina. Infine, nel caso (d), se l utente ha inserito la stringa vuota, la condizione, negazione di quella del caso (c), è immediatamente falsa e il ciclo termina. Se l utente ha invece inserito una stringa non vuota, come ad esempio "pippo", alla prima valutazione la condizione risulterà vera. Infatti, la stringa riferita da s conterrà due copie della stringa riferita da t (nell esempio "pippopippo"). L assegnamento all interno del ciclo fa in modo che la variabile s si riferisca a una nuova stringa, che rappresenta la seconda metà della stringa a cui si riferiva s prima dell assegnamento (nell esempio la nuova stringa sarà "pippo"). Siccome la stringa riferita da s era formata dalla concatenazione di due copie della stringa riferita da t, questa nuova stringa è uguale a quella riferita da t. Pertanto alla seconda valutazione la condizione risulta falsa provocando così la terminazione del ciclo. Dunque, nel caso (d) il ciclo termina per qualunque stringa in ingresso. Note ed errori frequenti Per programmare correttamente è indispensabile conoscere la differenza tra confronto tra riferimenti (effettuato mediante gli operatori di confronto == e!=) e confronto tra oggetti (effettuato mediante i metodi equals disponibili nelle varie classi). Non è possibile che uno stesso frammento di codice non possa essere infinito e non possa terminare.