Progetto di cicli (1) Iterazione. Progetto di cicli (2) Scrivere cicli in un programma. I loop pattern che abbiamo visto. Progetto di cicli (3)

Transcript

1 4 Progetto di cicli (1) Iterazione La costruzione dei cicli. Strutture tipiche. Ciclo for Il concetto di cortocircuito Gli statement break e continue Strategia: raffinamento di soluzioni approssimate. Cosa fare con problemi che non si adattano a un pattern? Esempio: costruire un metodo privato di una classe che dati due interi x e y calcola x y Passo1: Procedimento informale: come calcolarlo a mano? Risposta: moltiplicazione ripetuta: x y = 1 * x * x * x *... * x (y volte) Di conseguenza: start with 1 multiply by x repeatedly until y multiplications have been performed last result is answer Il resto dell approccio consiste nel trasformare questa intuizione in codice 2 5 Scrivere cicli in un programma Due approcci validi (1) Utilizzare un loop pattern (2) Abilità di costruire un ciclo quando nessun pattern è disponibile Sono necessari entrambi gli approcci: (1) non re-inventare ciò che già l acqua calda (2) potrebbero non esserci patterns disponibili necessità di costruire nuovi patterns Progetto di cicli (2) Passo 2: scelta e definizione delle variabili: Necessità di mantenere traccia di: Il valore dell ultima moltiplicazione Numero di moltiplicazioni effettuate Dichiariamo due variabili int count, // count == # of mults result; // result == 1 * x * x *... * x // (count times) // result == x ** k 3 6 I loop pattern che abbiamo visto READ/PROCESS: try to read item while (read was successful) { process most recent item read try to read another item Passo 3: scheletro del codice Progetto di cicli (3) // count == # of mults while (condition) // result == 1 * x * x *... * x (count times) Passo 4: Cosa vogliamo che succeda dopo la fine del while? Per rispondere a questa domanda cruciale è necessario pensare in termini dei valori delle variabili e delle operazioni di I/O

2 7 10 Progetto di cicli (4) Alla fine del ciclo deve essere count == y Questo deve essere garantito dalla condizione del while while (count!= y) // al termine del ciclo risulta count == y Progetto di cicli (7) Completamento del corpo del ciclo Intuizione della procedura informale: dovremmo effettuare una moltiplicazione ad ogni iterazione Per definizione count conta le moltiplicazioni quindi se incrementiamo count dobbiamo anche effettuare una moltiplicazione Per definizione result == x ** count Quindi se count è incrementato di 1, allora dobbiamo moltiplicare result per x Di conseguenza il corpo del ciclo sarà: result *= x; Bisogna inizializzare result a 1 prima del ciclo while Infatti essendo prima del ciclo count == 0, sarà result == x Progetto di cicli (5) Quando l esecuzione raggiunge l istruzione while, le variabili che appaiono nella sua condizione devono avere dei valori Prima del ciclo non ci sono state ancora moltiplicazioni, per cui count dovrebbe essere 0 y invece ha già un valore count = 0; // inizializzazione di count while (count!= y) Metodo completo count = 0; result = 1; while (count!= y) { result * = x; Progetto di cicli (6) Bisogna garantire la terminazione del ciclo Assicurarsi che la condizione del ciclo diventi falsa Intuitivamente, bisogna incrementare di 1 count nel corpo del ciclo count = 0; // inizializzazione di count while (count!= y) { rest of 9 Un altro esempio: la moltiplicazione (1) Supponiamo non sia disponibile un operatore per la moltiplicazione Costruiamo un metodo private che faccia questo private int multiply(int x, int y) { // y >= 0, restituisce x * y Passo 1: procedura informale Intuition: una moltiplicazione è un addizione ripetuta x * y = 0 + x + x x (y times) Quindi partiamo da 0 e aggiungiamo x finché non completiamo le y addizioni 12

3 Un altro esempio: la moltiplicazione (2) Passo 2: Scegliere e definire le variabili int count, // count == # of adds done result; // result == 0 + x + x x // (count times) // result == x * y Passo 3: Scheletro del codice while (condition ) { 13 Un altro esempio: la moltiplicazione (5) Passo 7: Completare il corpo del ciclo result è definito come 0 + x + x x (count times) incrementiamo count? Allora dobbiamo aggiungere x! Passo 8: Altra inizializzazione Inizialmente count è 0, quindi (per definizione) result deve essere 0 count = 0; result = 0; while ( count!= y ) { result += x; // altra inizializzazione // completa il corpo del ciclo 16 Un altro esempio: la moltiplicazione (3) Passo 4: Condizione del while termina quando result == x * y; ossia quando count == y Per garantire che al termine de ciclo sia count == y, la condizione del ciclo deve essere k!= y while ( count!= y ) { // al termine sarà count == y 14 private int multiply(int x, int y) { count = 0; result = 0; while ( count!= y ) { result += x; Metodo completo 17 Un altro esempio: la moltiplicazione (4) Passo 5: Inizializzazione Inizialmente non ci sono addizioni, per cui count deve essere 0 Passo 6: Garantire la terminazione Incrementare count garantisce che prima o poi count raggiungerà y count = 0; // inizializzazione while ( count!= y ) { rest of // garantisce la terminazione 15 Metodologia per il progetto di cicli Meglio eseguire i passi da 1 a 4 in ordine I passi da 5 a 8 possono essere eseguiti in qualsiasi ordine I passi 1 e 2 sono i PIU cruciali Forniscono la guida e la fase per i passi successivi Perché definire la condizione del ciclo prima del corpo del ciclo? Può essere definita dal nostro obiettivo Il suo effetto è più facilmente analizzabile 18

4 Un terzo esempio: stampa degli stipendi Dato il seguente input: informazioni che definiscono il dipendente 1 (name, wage rate) ore lavorate dal dipendente 1 informazioni che definiscono il dipendente 2 (name, wage rate) ore lavorate dal dipendente 2 Stampa lo stipendio di ogni dipendente Si assuma l esistenza di una classe Employee con i metodi: readin getname calcpay 19 Inizializzazione e completamento del Inizializzazione e garanzia di terminazione: emp = Employee.readIn(br); while (emp!=null) { rest of emp = Employee.readIn(br); Completamento del : emp = Employee.readIn(br); while (emp!=null) { hours =Integer.parseInt(br.readLine()); int pay = emp.calcpay(hours); System.out.println(pay); emp = Employee.readIn(br); Procedimento informale e variabili Procedimento informale: eseguire ripetutamente, finché ci sono dati da leggere, le seguenti istruzioni leggere i dati del dipendente leggere le ore lavorate calcolare lo stipendio risultante Stamparlo Definizione di variabili Employee emp; // refers to most recently read Employee object int hours; // the number of hours worked // by the most recently read employee Contatori: Altri schemi di cicli (1) int countsomething = 0; // # of somethings encountered so far while () { if (Something) countsomething++; Scheletro del codice e condizione del while while (condition) { // no more data to read Quale è la negazione di "no more data to read"??? Se la nostra lettura è della forma: emp = Employee.readIn(br); allora quando emp == null sappiamo che non ci sono più dati Quindi: while (emp!=null) { // no more data to read 21 Cicli a conteggio Altri schemi di cicli (2) int countsomething = 0; // # of somethings encountered so far while (countsomething!= desiredvalue) { if ( Something) countsomething++; 24

5 25 28 Altri schemi di cicli (3) Ciclo a conteggio incondizionato si contano tutti gli elementi considerati (incondizionatamente) int count = 0; // # of somethings encountered so far while (count!= desiredvalue) { Altri schemi di cicli (5) Oggetti con valori estremi: Dato un insieme di oggetti con una relazione d ordine, trovare l oggetto che è estremo (minimo o massimo) SomeType extreme; // extreme == reference to object that is most // extreme among set of objects encountered // so far OR is null if that set is empty while () { if (extreme == null current object is more extreme than extreme) extreme = current object Ciclo a conteggio incondizionato: un esempio Intestazione: Il primo dato rappresenta il numero di data items da elaborare int header, numread=0; read header while (numread!= header) { read data process data numread++; 26 Altri schemi di cicli (6) Estremi tra valori di dati primitivi: dato un insieme di valori, cercare il minimo o il massimo boolean foundextreme; // true iff extreme has been found SomeType extreme; // extreme == most extreme value seen so far // if foundextreme is true; otherwise its value is meaningless extreme = some arbitrary and meaningless value; foundextreme = false; while () { if (!foundextreme current value is more extreme than extreme) { extreme = current value foundextreme = true; 29 Altri schemi di cicli (4) Accumulatore: Data una operazione arbitraria (come add, multiply) Applicare l operazione ad un insieme di valori per ottenere il totale SomeType accumulator; // accumulator == application of OPERATION // to set of objects or values encountered so far while () { accumulator = apply OPERATION to both accumulator and next object or value 27 Estremi tra valori di dati primitivi: un esempio boolean foundextreme; int largest, x; Stampare l intero più grande foundextreme = false; largest = 0; String line = br.readline(); while (line!= null) { x = Integer.parseInt(line); if(!foundextreme x > largest) { largest = x; foundextreme = true; line = br.readline(); System.out.println( Largest integeris, largest); 30

6 int largest, x; largest = -1; Estremi in un sottoinsieme di valori di dati primitivi // -1 è un valore proibito se supponiamo che i // valori letti sono tutti non negativi String line = br.readline(); while (line!= null) { x = Integer.parseInt(line); if(x > largest) largest = x; line = br.readline(); System.out.println( Largest integer is, largest); 31 Intestazione: Il ciclo for: un esempio int lines; // == number of lines read & printed so far int header; // == number of lines available from input header = Integer.parseInt(br.readLine()); for ( lines=0; lines!= header; lines++) System.out.println(br.readLine()); Schema per i tipi di dati primitivi int largest, x; String line; largest = Integer.parseInt(br.readLine()); // primo intero // br contiene almeno una linea while (line!= null) { x = Integer.parseInt(line); if(x > largest) largest = x; line = br.readline(); System.out.println( Largest integer is, largest); Il ciclo for: flessibilità for (initialization; loop condition; increment) Si possono omettere ciascuna delle tre parti che compongono l intestazione del for BISOGNA mantenere i punti e virgola Le inizializzazioni possono essere assegnamenti multipli separati da virgole Gli incrementi possono essere incrementi multipli separati da virgole ESEMPIO // print table of powers of 2 for (i=0, powof2=1; i<10; i++, powof2*=2) System.out.println("2 to the + i + " is " + pow2); Il ciclo for Supporto esplicito per cicli a conteggio: for (initialization; loop condition; increment) Notare i separatori (punto e virgola) Inizializzazione: tipicamente un assegnamento singolo Equivalente a: initialization; while (loop condition) { increment; Valutazioni corto-circuito Le condizioni composte sono valutate da sinistra a destra La valutazione si interrompe quando il risultato è già noto Esempio: atbat!=0 && hits/atbat>0.300 Supponiamo atbat è zero: atbat!=0 è valutato a false A questo punto il risultato è noto: l intera condizione composta sarà false La valutazione si arresta: hits/atbat>0.300 non sarà valutata!

7 37 40 Valutazioni corto-circuito: altri esempi Se si tratta di un OR, allora se il primo operando è true, il secondo non viene valutato: person.age()>=17 person.accompaniedbyadult() Un altro esempio (dall esempio estremi tra oggetti ) if (longest==null s.length()>longest.length()) longest = s; L istruzione continue Singola keyword e un punto e virgola: continue; Termina l esecuzione corrente del corpo del ciclo e va immediatamente alla condizione di valutazione Esempio: for (i=0; i<100; i++) { if (i%2==1) continue; if (!verycomplicatedcondition(i)) continue; process i Vantaggio(?): riduce i livelli di nesting e le indentazioni L istruzione break Singola keyword e un punto e virgola: break; Termina l esecuzione di un ciclo immediatamente, esempio: int k=0; while (k!=5) { String s = infile.readline(); if (s==null) break; process s k++; // k==5 or s==null L istruzione continue: pericoli Consideriamo di voler leggere qualche stringa e elaborare solo quelle che soddisfano due condizioni: String s = keybd.readline(); while (s!=null) { if (!condition1(s)) continue; if (!condition2(s)) continue; process s s = keybd.readline(); Cosa è sbagliato? L istruzione break: semplicemente evitarla Il ciclo precedente può essere espresso come: int k=0; String s = infile.readline(); while (!(k==5 s==null)) { process s k++; s = infile.readline(); Con il break: La condizione di terminazione non è ovvia Il lettore deve costruire mentalmente una condizione di terminazione il OR Senza break: La condizione di terminazione è ovvia e si ottiene dalla condizione del while 39 Raffinamento di soluzioni imperfette Partire con la soluzione iniziale provvisoria, imperfetta o incompleta Migliorarla ripetutamente, finché non è sufficientemente buona Funziona con molti problemi di calcolo numerico! Richiede la capacità di: Costruire una soluzione iniziale provvisoria Prendere una soluzione provvisoria e migliorarla Determinare se una data soluzione provvisoria è sufficientemente buona 42

8 Raffinamento di soluzioni imperfette s = provisional solution while (! (s is good enough) ) s = improvement of s 43 Algoritmo di Newton: il codice Trovare la radice quadrata di x boolean iscloseenough(double x, double y, double precision) { return Math.abs(y*y-x) <= precision; // squareroot returns square root of x within the given precision private double squareroot(double x, double precision) { double y; y = x; while (!closeenough(x,y*y,precision)) y = (y+x/y)/2.0; return y; 46 Raffinamento di soluzioni imperfette... Condizione del while: determinare se la soluzione corrente è sufficientemente buona Inizializzazione: costruire una soluzione iniziale provvisoria Garantire la terminazione Migliorare la soluzione corrente Emittente Radiofonica (rivisitazione) WOLD è rimasto talmente soddisfatto della sua esperienza con un sistema computerizzato che ha deciso di automatizzare il suo programma pomeridiano la cui trovata consiste nel trasmettere segmenti senza pubblicità. Prima della trasmissione il DJ crea un file contenente le canzoni che desidera trasmettere durante un determinato segmento. Questo file è tratto dal file di libreria delle canzoni in cui i dati contengono anche la durata delle canzoni. L applicazione consiste nel chiedere al DJ di specificare la durata del segmento senza pubblicità. In seguito viene letta la lista delle canzoni e viene prodotto lo stampato e viene prodotto lo stampato della sequenza di canzoni in modo tale che la loro durata non sia inferiore al segmento Esempio: Algoritmo di Newton Trovare la radice quadrata di x: start with any number, g while (! (g 2 is close enough to x) ) g = average of g and x/g Idea di base: se g è più piccolo della radice quadrata allora x/g è più grande fai la media dei due Il punto importante: facendo questo ripetutamente si converge alla radice quadrata di x Emittente Radiofonica (rivisitazione) Viene chiesto al DJ di inserire una pubblicità almeno ogni N minuti. In altre parole, il segmento a una durata massima che NON si può superare.