Variabili, tipo, assegnamento, selezione (if), iterazione...

Laboratorio di Programmazione – Esercitazioni - Iuri Frosio - [email protected] 1

Variabili, tipo, assegnamento, selezione (if), iterazione (while, do... while, for):

esercizi, approfondimenti

Programmazione ad oggetti: costruttori, metodi (la classe Frazione)


Break

All'interno di un ciclo while, do... while o for, l'istruzione “break” permette di terminare preventivamente il ciclo.

Sintassi:break;

Possibile utilizzo: all'interno di un ciclo infinito, l'istruzione break permette di inserire una condizione di fine ciclo.

In genere utile nei casi in cui è richiesta efficienza computazionale (può evitare dei calcoli inutili!).


Esercizio 1

Si scriva un programma che, per mezzo di un ciclo for, permette di acquisire una serie di 50 numeri interi. Il programma deve terminare preventivamente nel momento in cui viene inserito un numero negativo.


Continue

L'istruzione “continue”, utilizzata all'interno di un ciclo, permette di saltare una delle iterazioni del ciclo, passando direttamente alla successiva (il codice che si trova all'interno del ciclo, dopo l'istruzione continue, non viene eseguito).

Sintassi:Continue;


Esercizio 2

Si scriva un programma che calcoli la somma di 10 numeri interi inseriti dall'utente a run-time. Per evitare di svolgere operazioni inutili, si eviti di aggiornare la somma quando il numero inserito è pari a 0.

Soluzione → sito web.


Esercizio 3 – Somma frazioni

Si scriva un programma che sia in grado di calcolare la somma di una sequenza di 4 frazioni;l'acquisizione di ogni frazione richiede l'acquisizione di numeratore e denominatore;nel caso in cui il numeratore sia uguale a zero, si proceda direttamente all'acquisizione della frazione successiva;nel caso in cui il denominatore sia uguale a zero, si termini il programma segnalando un errore.


Break e continue

Le istruzioni break e continue servono a terminare preventivamente un ciclo in esecuzione / saltare un'iterazione del ciclo.Vanno usate“con parsimonia”, in quanto spesso rendono più complicata l'interpretazione del codice (non è chiaro il flusso del programma).Utili nel momento in cui si voglia scrivere codice efficiente in particolari situazioni.


Break e continue

Programmazione ad oggetti: costruttori, metodi (la classe Frazione)


Esercizio 4: selezione (binaria)

● Si scriva un programma che legge un numero intero maggiore di zero. Il programma dica poi se il numero letto è pari oppure dispari.


Esercizio 5: selezione (più selezioni binarie)

● Si scriva un programma che legge un numero intero. Il programma dica poi se il numero letto è nullo, pari oppure dispari. Nel caso in cui il numero letto sia pari, il programma comunichi all'utente se il numero è divisibile per 4 o meno. Nel caso in cui sia dispari, il programma comunichi all'utente se il numero è divisibile per 7 o meno. Nel caso in cui il numero inserito sia 17, il programma termini immediatamente avvertendo l'utente che tale numero porta male.


Esercizio 6: iterazione

● Si scriva un programma che comunichi all'utente la lista dei numeri interi compresi tra 0 e 100 divisibili per 7, a partire dal numero più alto. Si scriva il programma in una prima versione utilizzando il ciclo for, in una seconda versione utilizzando un ciclo while.


Esercizio 7: iterazione

● Si riscriva il programma dell'esercizio 6 per fare in modo che, modificando una sola riga del programma, sia possibile stampare a schermo tutti i numeri divisibili per 5, 6, 7 o un qualsiasi altro numero.


Esercizio 8 (vecchio conio)

● Scrivete un programma che dato in ingresso un prezzo in Euro (rappresentato per semplicità come un numero in virgola mobile a doppia precisione), ne stampi l’equivalente in Lire. Si ricordi che 1 Euro = 1936, 27 Lire.


Esercizio 9 (vecchio e nuovo conio)

● Scrivete un programma che, prima di tutto, chieda se si vuole effettuare una conversione Euro/lira o lira/Euro.

● Dato in ingresso un prezzo in Euro (Lire) (rappresentato per semplicità come un numero in virgola mobile a doppia precisione), ne stampi l’equivalente in Lire (Euro). Si ricordi che 1 Euro = 1936, 27 Lire.


Esercizio 10 (Gatti)Scrivete un programma che esibisca il comportamento schematizzato dalle due seguenti esecuzioni (in grassetto sono indicati i dati introdotti dall’utente):

Quanti gatti in tutto? 35

Quanti gatti in ogni fila? 6

35 gatti in fila per 6 col resto di 5

Quanti gatti in tutto? 128

Quanti gatti in ogni fila? 7

128 gatti in fila per 7 col resto di 2

Soluzione → sul sito web...


Esercizio 11 - ExtraterrestriL’esistenza di civiltà extraterrestri evolute è una delle questioni più affascinanti e dibattute fra gli scienziati di tutto il mondo, e la possibilità che tali civiltà esistano ha dato origine a un vero e proprio filone letterario e cinematografico. Il professor Frank Drake, oggi astrofisico all’Università di Santa Cruz, in California, ha tentato nel 1961 di stimare il numero N di civiltà extraterrestri con cui potremmo entrare in contatto; tale valutazione è basata su una formula, oggi nota come formula di Drake:

N = R × f p × ne × f × fi × fc × L.

In questa formula compaiono alcuni dati la cui valutazione è possibile in modo abbastanza accurato, e altri che possono essere solo ipotizzati:

● Rè la frequenza media con cui si formano delle stelle nella nostra galassia; secondo la NASA e l’Agenzia Spaziale Europea, questo dato è circa 6 stelle/anno;

● fp è la frazione di stelle che hanno un sistema di pianeti; il valore è molto incerto: secondo Drake f p = 0.5 (cioè, il 50% delle stelle hanno un sistema planetario), ma fino ad ora si è potuto stabilire solo fp = 0.1 (è però probabile che ciò sia dovuto semplicemente al fatto che le tecnologie di cui disponiamo non consentono di rilevare sistemi planetari molto piccoli o molto distanti);

● ne è il numero medio di pianeti che possono ammettere la nascita della vita in ciascun sistema planetario; è molto difficile da stimare: l’assunzione di Drake è che ne = 2, ma secondo alcuni si tratta di un’ipotesi troppo ottimistica;

● f è la probabilità che, in un pianeta che può ammettere la nascita della vita, si sviluppi effettivamente qualche forma di vita; secondo Drake f = 1, mentre recenti studi di carattere statistico hanno stabilito che comunque f > 0.13, posto che si assuma che il pianeta in questione sia esistito per almeno un miliardo di anni;

● fi è la probabilità che, in un pianeta in cui si sviluppi la vita, si abbia la nascita di vita intelligente; Drake stimò fi = 0.01;


Esercizio 11 - Extraterrestri● fc è la probabilità che una civiltà intelligente sia disponibile e in grado di comunicare; Drake stimò fc =

0.01;

● L è il numero di anni per cui una civiltà intelligente e in grado di comunicare può sopravvivere; secondo Drake L = 10000.

Scrivete un programma che calcoli il valore della stima di Drake, prendendo in input i valori dei parametri incerti (definite i parametri per i quali ritenete che il valore sia sufficientemente certo mediante dichiarazione e assegnamento simultanei), e fornendo in output N. Fate girare il programma alcune volte, prima inserendo i valori supposti da Drake, e poi inserendo le vostre valutazioni personali, che potranno essere più ottimistiche o pessimistiche di quelle ipotizzate da Drake. Che risultati ottenete?

● Soluzione → sito web...


Esercizio 12

Sia N un intero positivo. Si consideri la seguente regola:Se N è dispari, aggiornare N come segue: N = 3N +1;Se N è pari, aggiornare N some segue: N = N/2.Tale sequenza termina sempre con N=1.Si scriva un programma che simuli la sequenza appena descritta, mostrando a schermo i vari passaggi, iniziando da un numero N scelto dall'utente.

Soluzione → sito web...

Hint (ciclo while per le iterazioni... - per uscire dal ciclo è meglio usare break o porre una condizione sul ciclo while?)


Esercizio 13 – Numeri primi

Calcolare e stampare i primi 100 numeri primi – si ricordi che un numero primo è divisibile solo per 1 e per se stesso – per verificare che N sia primo, è sufficiente verificare che non sia divisibile per uno dei numeri maggiori di 1 e minori di N. Dal momento che 1 e 2 sono primi, si cominci la ricerca dei numeri primi a partire dal numero 3. Si ricordi inoltre che i numeri primi a parte il 2 sono sempre dispari.


Esercizio 14 – Numeri primi gemelli

Si definiscono numeri primi gemelli una coppia di numeri primi che differiscono tra loro di due unità (es. 5 e 7). Si modifichi il programma precedente per trovare le prime 4 coppie di numeri primi gemelli.


Esercizio 15 (Iterazione di punto fisso)Sia f(x) una funzione non lineare di cui si vuole trovare una radice (cioè x* t.c. f(x*) = 0), ad esempio f(x) = ex-x-2. Dal momento che non esista una formula risolutiva per un'equazione trascendente, è necessario utilizzare un metodo iterativo per trovarne la radice, ad esempio un'iterazione di punto fisso.

Questa può essere ricavata a partire da f(x) = 0 come x = g(x), nel nostro caso, ad esempio, f(x) = ex-x-2 = 0 -> x = ex-2 (1)

Sia x0 la stima iniziale della radice. Applicando iterativamente la (1), si ottiene una sequenza x1, x2, …, xN che converge alla radice di f(x)=0, se |g'(x)|<1.Si scriva dunque un programma che utilizzi un ciclo while per trovare una delle radici reali di f(x), partendo da x0 = 0. Si verifichi la convergenza o meno dell'iterazione di punto fisso. Si stoppi l'iterazione (break) quando la radice stimata non presenta cambiamenti significativi (cioè quando il valore della radice tra due iterazioni successive varia meno di una valore piccolo scelto a piacere).

Cosa succede al variare del valore di x0? Provare ad esempio con x0=1 e x0=100.

Soluzione → sito web.


Break e continue

Variabili, tipo, assegnamento, selezione (if), iterazione (while, do... while, for):

esercizi, approfondimenti


Programmazione ad oggettiDecomposizione di un problema:

Dividere il problema in sottoproblemi semplifica la soluzione del problema originale (si applica un approccio “dividi et impera” ripetutamente, finchè i sottoproblemi risultanti sono semplici da risolvere).

Nella programmazione Object-Oriented (OO), gli oggetti sono entità pensate per la risoluzione di particolari sottoproblemi.


Programmazione ad oggettiQuale sottoproblema deve risolvere un oggetto (cioè

l'istanza di una classe)?

Quali azioni deve svolgere per adempiere al proprio compito? → Metodi

Quali informazioni servono all'oggetto per svolgere il suo compito? → Variabili della classe, parametri nei metodi,

…

Quale interfaccia mostra ad altri oggetti?

Quali informazioni dovrà nascondere / mostrare agli altri oggetti → public, private, ...


La classe FrazioneNome della classe: Frazione (prog.utili.Frazione)(Help: E:\_Didattica_AA20082009_Programmazione\prog-1.5\prog\doc\index.html)

Task: Rappresentare delle frazioni e permettere di effettuare operazioni tra frazioni.

Informazioni necessarie (variabili di istanza): Numeratore, denominatore.

Operazioni necessarie (metodi pubblici, solo alcuni citati): - Frazione () → Crea una frazione con numeratore e denominatore dati (costruttore)- GetNumeratore () → per ottenere il numeratore- GetDenominatore () → per ottenere il denominatore- ...


Costruttori, metodi, variabili di istanzaCostruttore → permette di creare l'oggetto, in genere inizializzando alcune caratteristiche proprie dell'oggetto (es. numeratore e denominatore di una frazione).

Variabili di istanza → all'interno dell'oggetto, vengono memorizzate le informazioni che caratterizzano la particolare istanza; ad esempio, il numeratore e il denominatore di una frazione.

Metodi → Permettono di interagire con l'oggetto, ad esempio per ottenere il valore del numeratore e del denominatore di una frazione.


Esempi: ConsoleInputManager, Frazione

*******************************************************************************************

ConsoleInputManager in; // Dichiarazione di un'istanzain = new ConsoleInputManager(); // Costruzione dell'oggetto (istanza in)in.readInt(“Dammi un intero: “); // Invocazione di un metodo

*******************************************************************************************

Frazione fraz = new Frazione(5,2); // Dichiara e crea una nuova istanza della classe frazione che rappresenta la frazione 5/2 – Le variabili di istanza “numeratore” e “denominatore” saranno poste pari a 5 e 2 all'interno dell'istanza “fraz”

int numeratore;numeratore = fraz.getNumeratore(); // Invoca il metodo getNumeratore() per assegnare alla variabile “numeratore” il valore del numeratore dell'istanza fraz della classe Frazione.

*******************************************************************************************


Costruttori e metodi: sintassi*******************************************************************************************Costruttore:

<istanza> = new <costruttore>;

Esempio:

Frazione fraz;fraz = new Frazione(5,7); // Crea la frazione 5/7

*******************************************************************************************Metodi:

<istanza>.<nome metodo>;

Esempio:

int numeratore;numeratore = fraz.getNumeratore();

*******************************************************************************************


Classe Frazione

Per utilizzare la classe Frazione (così come abbiamo fatto per le classi ConsoleInputManager e ConsoleOutputManager) → dobbiamo importare la classe all'inizio del file .java.

La classe Frazione si trova in prog/utili/Frazione.class, quindi...

Import prog.utili.Frazione; // Importazione classe Frazione


Esercizio

Si scriva un programma che, dopo avere importato la classe Frazione, crei un'istanza di tale classe corrispondente alla frazione 17/16,

quindi utilizzi i metodi getNumeratore e getDenominatore per mostrare a schermo

numeratore e denominatore.


Soluzione/* Esempio di importazione e utilizzo della classe Frazione */

// Importimport prog.io.ConsoleOutputManager;import prog.utili.Frazione;

// Class Frazione1class Frazione1{

// Mainpublic static void main(String [] args){

// Dichiarazione variabiliint numeratore,denominatore;

// Dichiarazione oggettiConsoleOutputManager out;Frazione fraz;

// Creazione istanzeout = new ConsoleOutputManager(); // Creazione oggetto per la gestione dell'outputfraz = new Frazione(17,16); // Creazione oggetto frazione 17/16

// Utilizzo di metodi: esempionumeratore = fraz.getNumeratore();denominatore = fraz.getDenominatore();

// Outputout.println("Numeratore : " + numeratore);out.println("Denominatore: " + denominatore);

}}


Esercizio 3 (bis) – Somma frazioniSi scriva un programma che sia in grado di calcolare la somma di una sequenza di 4 frazioni;l'acquisizione di ogni frazione richiede l'acquisizione di numeratore e denominatore;nel caso in cui il numeratore sia uguale a zero, si proceda direttamente all'acquisizione della frazione successiva;nel caso in cui il denominatore sia uguale a zero, si termini il programma segnalando un errore.

Hint:Si modifichi il codice dell'esercizio 3 per l'utilizzo della classe Frazione.Si utilizzi il metodo “piu” per effettuare la somma tra frazione.Si utilizzi la documentazione del package prog per la sintassi del metodo “piu”.

Variabili, tipo, assegnamento, selezione (if), iterazione...

Documents

Transcript of Variabili, tipo, assegnamento, selezione (if), iterazione...