Esame di Programmazione 18 Febbraio 2003 TESTO E RISPOSTE

Transcript

1 Esame di Programmazione 18 Febbraio 2003 TESTO E RISPOSTE Esercizio 1 Comprensione codice C (punti 8 in prima approssimazione) Consideriamo il seguente codice C ( NON è un esempio di buon codice C!!! ) #include <stdio.h> #define MAXS 20 char pippo [MAXS+1] = "BCDMPQRSTXW" ; int k ; char pp1 ( int ) ; void pp2 ( int, char ) ; void qqq ( int k, char aa [ ] ) ; main() { int index = 0 ; k = 2 ; printf("\n STAMPA 1 : %c", pippo[k]) ; printf("\n STAMPA 2 : %c", pp1(index) ); printf("\n STAMPA 3 : %d", index ); pp2 (1, 'W') ; printf("\n STAMPA 5 : %c \n", pippo[ 1 ]) ; qqq (3, pippo) ; char pp1( int ii ) { ii = k+1 ; return pippo [ ii ] ; void pp2( int ii, char cc ) { pippo [ ii ] = cc; printf("\n STAMPA 4 : %c", pippo[ii]) ; void qqq ( int k, char aa [ ] ) { int index ; for (index = 0 ; aa[index]!= '\0' ; index++) if ( (index % k) == 0 ) printf("%c", aa[index] ); else printf("%c", '*' ); printf("\n") ; Sul foglio risposte scrivere l'output del programma; tutto l'output! (l'unica cosa che potete ignorare sono gli spazi bianchi) Risposte: 1

2 Variante 1: quella con: char pippo [MAXS+1] = "BCDMPQRSTXW" ; pp2 (1, 'W') ; Output: STAMPA 1 : D STAMPA 2 : M STAMPA 3 : 0 ( zero ) STAMPA 4 : W STAMPA 5 : W B**M**R**X* Variante 2: quella con: char pippo [MAXS+1] = "XYZRSTABCDK" ; pp2 (1, 'E') ; Output: STAMPA 1 : Z STAMPA 2 : R STAMPA 3 : 0 ( zero ) STAMPA 4 : E STAMPA 5 : E X**R**A**D* Variante 3: quella con: char pippo [MAXS+1] = "KMNABCZYXEF" ; pp2 (1, 'P') ; Output: STAMPA 1 : N STAMPA 2 : A STAMPA 3 : 0 ( zero ) STAMPA 4 : P STAMPA 5 : P K**A**Z**E* Variante 4: quella con: char pippo [MAXS+1] = "PQRSTABCDUZ" ; pp2 (1, 'X') ; Output: STAMPA 1 : R STAMPA 2 : S STAMPA 3 : 0 ( zero ) STAMPA 4 : X STAMPA 5 : X P**S**B**U* Esercizio 2 Progetto di algoritmo (punti 16 in prima approssimazione) Testo corretto; ho levato un paio di piccoli errori... Supponiamo di avere una scacchiera di dimensione n n, quindi con n 2 caselle. 2

3 Le caselle della scacchiera NON sono colorate; sulla scacchiera ci sono pedine gialle e verdi, messe "a caso". Consideriamo una pedina P di colore C (C = giallo / verde) posta su una casella CAS della scacchiera; il problema è capire se la pedina può "uscire" dalla scacchiera. Le possibilità di uscita sono in 4 direzioni, Nord, Sud, Est, Ovest, e ci si può muovere solo in linea retta. Ad esempio, per la fuga ad Est: bisogna poter attraversare, in linea retta, tutte le caselle che ci sono tra CAS ed il bordo destro della scacchiera. Le caselle si possono attraversare solo se sono vuote o contengono una pedina dello stesso colore (C nel nosto caso). Nella figura: la scacchiera è 8 8 ; P indica la pedina che ci interessa, le altre pedine sono indicate con g (giallo) e v (verde); P può senza dubbio uscire in direzione Sud ed Ovest; in direzione Nord, P può uscire se è gialla; in direzione Est non c'è speranza (andando in linea retta verso il bordo ci sono caselle occupate da una gialla e da una verde). Nord v g v g v v P g v Est Sud Si tratta di progettare un algoritmo per questo gioco. La situazione iniziale della scacchiera, con le pedine, tranne P, è descritta in un file (di testo) di input che contiene: la dimensione n; le pedine, tranne P: colore e posizione sulla scacchiera; Fa parte dell'esercizio decidere come codificare le informazioni e come strutturare il file. L'algoritmo deve essere strutturato come segue: c'è una costante MAX = 100 (per fissare le idee) il "main" apre il file di input che si chiama partenza poi legge n (supponiamo n MAX) poi legge il resto del file e "imposta la scacchiera" poi chiede : pedina (colore e posizione) e direzione poi legge i dati di sopra da input standard e mette la pedina sulla scacchiera ( non avevo precisato cosa si fa se la casella dove dovrebbe andare la pedina è già occupata; quindi qualunque scelta sensata andava bene ) poi controlla [ tramite procedura/ funzione -- vedi sotto ] se la pedina data in input può uscire dalla scacchiera seguendo la direzione data infine stampa un messaggio sensato. 3

4 Il controllo (se la pedina può uscire...) va fatto usando una procedura/funzione, che chiamiamo fuga. Quindi bisogna scrivere una (unica) procedura/ funzione che, presi: scacchiera più pedine una particolare pedina (su una particolare casella) una direzione decide se la pedina può... Non si possono usare "variabili globali" (filosofia "no global"). I passaggi di dati tra main e procedure e funzioni devono avvenire tramite parametri e il risultato delle funzioni. Si possono usare procedure / funzioni ausiliarie. Domande a) Come si rappresentano scacchiera più pedine e come è fatto il file di input? Se non trovo la risposta non correggo il resto. b) Come si rappresentano le "direzioni"? Se non trovo la risposta non correggo il resto. c) Per la procedura/funzione fuga : dire quali sono i parametri ed il loro tipo (ed eventualmente il tipo del risultato) dare un'idea di come funziona (a parole o in pseudo-codice ad alto livello). Se non trovo la risposta non correggo il codice di fuga. d) Precisare, usando lo pseudo-codice utilizzato nelle dispense, oppure il C, la procedura/ funzione fuga; dettagliare solo i casi: fuga verso Sud, fuga verso Est e) Scrivere, usando lo pseudo-codice utilizzato nelle dispense, oppure il C, la parte "main", commentando, quando necessario. Risposte (si poteva anche essere piu' sintetici...) a) La cosa più semplice è rappresentare la scacchiera con un array a due dimensioni; per distinguere tra: casella con perdina gialla, con pedina verde, casella vuota, si possono usare 3 interi, oppure 3 caratteri, oppure valori di un tipo enumerazione... Per fissare le idee: scacchiera + pedine <--- > scac : array [ 1.. MAX, 1.. MAX] of char dove il valore del char è : 'g' = giallo, 'v' = verde; 'n' = nulla (vuota) una variabile dim contiene la dimensione effettiva ( cioè il valore n ), dunque righe e colonne usate sono da 1 a dim Alternativa, più corretta: si usa un record a due campi: un campo array... ed un campo dim Inoltre bisogna precisare l'orientamento : utilizzando il disegno di sopra, la casella in alto a sinistra è scac[1,1], quella in alto a destra è scac[1, 8] dunque, se sono in casella scac [ x, y ], andare a Est in linea retta fino al bordo significa attraversare (se possibile) le caselle scac [ x, y+1 ], scac [ x, y+2 ],...,scac [ x, dim ] 4

5 andare a Ovest in linea retta fino al bordo significa attraversare (se possibile) le caselle scac [ x, y-1 ], scac [ x, y-2 ],...,scac [ x, 1 ] andare a Nord... caselle scac [ x-1, y], scac [ x-2, y ],...,scac [ 1, y ] andare a Sud... caselle scac [ x+1, y], scac [ x+2, y ],...,scac [dim, y ] Infine: il file di unput è strutturato come segue: una riga per n e poi tante righe quante sono le pedine da inserire 1a riga : n 2a riga: c1 x1 y1 3a riga: c2 x2 y2 eccetera dove c1, c2,... sono caratteri, di valore 'g' oppure 'v' x1, x2,... sono interi, indici di riga ( compresi tra 1 ed n ) y1, y2,... sono interi, indici di colonna ( compresi tra 1 ed n ) b) questo è molto più semplice (le direzioni servono solo nell'input da tastiera e poi come paramentro per la procedura fuga...) ; va bene una qualunque codifica... ad esempio usando ancora dei caratteri 'N' 'S' 'E' 'O' c) Per la fuga: la cosa piu' ragionevole è una funzione a valori booleani argomenti: scacchiera + pedine ( array e dim ) pedina (colore, indice riga, indice colonna) direzione Quindi il prototipo in pseudo-codice è function fuga (sc : array... ; dim : int; colore : char ; x, y : integer ; dir : char ) : bool La funzione si basa sul fatto che gli spostamenti si traducono in incrementi/decrementi degli indici. Un modo di realizzarla è: data la direzione, calcolare gli incrementi/decrementi Nord: inc_x = -1 inc_y = 0 Est: inc_x = 0 inc_y = +1 eccetera sempre dalla direzione, calcolare le coordinate della casella del bordo cui si cerca di arrivare: Nord: meta_x = 1 meta_y = y a questo punto: Est: meta_x = x meta_y = dim eccetera controlla se x= meta_x e y = meta_y se si' return( true) altrimenti ciclo : incrementa gli indici x e y controlla se la nuova casella e` attraversabile... controlla se è sul bordo... 5

6 ulteriori dettagli al punto d) d) pseudocodice per fuga qui ho dettagliato tutti i casi function fuga ( sc : array [1.. MAX, 1.. MAX] ; dim : integer; colore : char ; x, y : integer ; dir : char ) variabili: inc_x, inc_y, meta_x, meta_y : integer ok : boolean bruttoc : char istruzioni if colore = 'g' then bruttoc 'v' else bruttoc 'g' casi su dir: { dir = 'N' : inc_x -1 ; inc_y 0 meta_x 1 ; meta_y y dir = 'S' : inc_x 1 ; inc_y 0 meta_x dim ; meta_y y dir = 'E' : inc_x 0 ; inc_y +1 meta_x x ; meta_y dim dir = 'O' : inc_x 0 ; inc_y -1 meta_x x ; meta_y 1 if ( x = meta_x) and (y = meta_y) then return(true) else { ok true while ok and ( (x meta_x) or (y meta_y) ) do { x x + inc_x ; y y + inc_y ; if (sc [ x, y] ) = bruttoc then ok false return (ok) : boolean e) Per quanto riguarda il programma... (sempre in pseudo codice) costante MAX =... variabili: flie_in : FILE dim, x, y : integer (dimensione scacchiera e posizione pedine) col : char (colore delle pedine) dir : char (direzione) scac : array [1.. MAX, 1... MAX ] of char j, k : integer (indici) 6

7 risultato : booleano function fuga... come sopra istruzioni: apri file partenza, assegnalo a flie_in leggi (flie_in, dim) per k= 1,2..., dim: per j = 1, 2..., dim : scac[k, j] 'n' while not EOF { leggi ( flie_in, col, x, y) ; scac [ x, y] col chiudi ( flie_in ) scrivi( " dammi pedina e direzione" ) leggi ( col, x, y, dir) if scac[x, y] = 'n' then scac[x,y] col else { scrivi (" errore") ed ESCI risultato fuga ( scac, dim, col, x, y, dir) if risultato then scrivi ("successo" ) else scrivi ('fallimento") Esercizio 3 Complessità (punti 6 in prima approssimazione) L'algoritmo che segue non fa nulla di interessante... Algoritmo: const MAX =... var: n, val, q : integer pot : array [1.. MAX ] of integer leggi ( n ) qui supponiamo n MAX leggi ( val ) per q = 0, 1, 2,... n-1 : pot [q+1] val + q per q = 2, 3, 4,... n : ppp ( pot, q ) ======================= procedura ppp( aa : array [1.. MAX ] of integer IN-OUT, ind : integer IN ) { qui si suppone ind MAX var aux, cont : integer aux 1 ; cont ind while cont > 0 { aux aux * aa[ind ] cont cont -1 aa[ind] aux 7

8 Domande: a) Calcolare la complessità della chiamata: ppp ( pot, q ) in funzione di q b) Calcolare la complessità dell'algoritmo in funzione di n Possibilmente dare stime in Q(...). Non fare conti troppo dettagliati, ma non limitarsi a dare il risultato o poco più; un risultato giusto, ma non motivato, non verrà contato... Risposte: a) Nella procedura ppp tutti i costi (incluso il passaggio dei parametri) sono costanti, tranne quello del while; nel while: test e corpo sono a costo costante; l'esecuzione del corpo si ha per cont = q, q-1,...,1; quindi il while ha un costo del tipo a q + b (a, b constanti, a > 0); dunque il costo dellla chiamata è della forma a q + c ed è in Q( q ). b) Nell'algoritmo, tutto ha costo costante, tranne le due istruzioni per. La prima ( per q = 0, 1, 2,... ) ha test, incrementi e corpo a costo costante, quindi ha un costo totale della forma a n + b (a, b costanti, diverse dalle precedenti, a >0) La seconda ( per q = 2, 3, 4,... n : ppp (pot, q) ) ha un costo proporzionale a:  ( q = 2, 3,...,n) q = a' n 2 + b'n + c' [vedi nota] Quindi tutto l'algoritmo è in Q( n 2 ). Nota: molti hanno avuto problemi con la somma Nel tentativo di cavarsela hanno scritto ( piu' o meno):  ( q = 2, 3,...,n) q =  ( q = 0, 1,...,n-2) q  ( q = 2, 3,...,n) q Non va bene (basta provare a verificare con n= 3...) Era molto piu' semplice:  ( q = 2, 3,...,n) q = (  ( q = 0, 1,...,n) q )