Politecnico di Milano - Dipartimento di Elettronica e informazione Prof. Mauro Negri

Transcript

1 Politecnico di Milano - Dipartimento di Elettronica e informazione Prof. Mauro Negri Fondamenti di Informatica Informatica I I appello 14 febbraio 2011 Matricola Cognome Nome Durata prova: 2 ore Fondamenti di informatica 1 ora ½ Informatica I Istruzioni Non separare questi fogli. Si può utilizzare la matita. L uso di cellulari, libri, eserciziari, appunti o calcolatrici durante lo svolgimento della prova comporta l annullamento della prova. Per entrambi i corsi Esercizio 1 (FI: 4 punti Info1: 5 punti) Esercizio 2 (FI: 7 punti Info1: 9 punti) Esercizio 3 (FI: 8 punti Info1: 10 punti) Esercizio 4 (FI: 5 punti Info1: 6 punti) Solo per fondamenti di Informatica Esercizio 5 (6 punti) Punteggio totale (30 punti) Esercizio 1 1. Indicare la rappresentazione in complemento a 2 su 9 bit dei numeri: A = + 77 (base 10) B = - 65 (base 10) > Indicare la rappresentazione in base 8 e 16 di -58 (base 10) base 8 = -72 base 16 = -3A 3. Indicare quale numero decimale rappresenta la seguente sequenza di bit codificata in complemento a 2: > > Data la definizione di una variabile float v= 62, descrivere la sua rappresentazione in virgola mobile in base allo standard IEEE754 semplice precisione FP32; a) Definire prima il numero nel formato normalizzato intermedio (TRONCARE parte decimale alla terza cifra decimale): -1,937 *2 5

2 b) Codificare poi il numero normalizzato usando il formato FP32: S (1 bit di segno): 1 M (23 bit per la mantissa fermarsi a 6 bit): E (8 bit per l esponente): Dopo gli arrotondamenti effettuati nei precedenti punti a) e b) dell esercizio 4, indicare quale sia il vero valore (in base 10) descritto dalla sequenza di bit memorizzata in S, M ed E del punto b) dell esercizio 4 (si consiglia di esprimere la mantissa in termini frazionari). -61,5 Esercizio 2. Siano date le seguenti definizione globali di una lista monodirezionale che ha tre variabili di accesso PRIMO e ULTIMO che puntano rispettivamente al primo e all ultimo elemento della lista e CENTRALE che punta all elemento posto all elemento al centro della lista (se N sono gli elementi punta al N/2-esimo divisione tra interi). struct el {int v; struct el *next;; struct el *PRIMO=NULL, *ULTIMO=NULL, *CENTRALE =NULL; Scrivere una funzione Calcolo che riceve l indirizzo della lista e dell elemento centrale come parametro, definisce due variabili S1 e S2 inizializzate a 0 e memorizza in S1 la somma dei valori dei campi v degli elementi che precedono l elemento centrale e in S2 la somma dei valori dei campi v degli elementi che seguono l elemento centrale. La funzione ritorna come parametri i valori delle somme calcolate. Attenzione: la funzione controlla che il puntatore centrale ricevuto corrisponda ad un elemento della lista, ma non controlla che corrisponda realmente all elemento centrale (se tale puntatore non punta all elemento centrale comunque la funzione calcola le due somme in base alla regola data). L inesistenza di elementi prima (dopo) l elemento centrale comporta la generazione di un valore 0 per la somma corrispondente. int Calcolo(struct el *primo, struct el *centrale, int *S1, int *S2) { struct el *elem; int trovato = 0; *S1 = 0; *S2 = 0; //controllo lista vuota if (primo == NULL) {printf("lista vuota!\n");return 0; //controlla esistenza elemento centrale if (centrale == NULL) {printf("ricevuto elemento centrale NULL\n");return 0; //controlla che l'elemento centrale sia nella lista elem = primo; trovato = 0; while (elem!= NULL &&!trovato) if (elem == centrale) trovato = 1; else elem = elem -> next; //verifica se ho trovato l'elemento centrale if (trovato == 0) {printf("elemento centrale ricevuto estraneo alla lista!\n");return 0; //esegui somma precedenti elem = primo; while (elem!= centrale) {(*S1) = (*S1)+elem->v; elem = elem -> next; pp. 2 / 4

3 //esegui somma successivi partendo dall'elemento dopo il centrale elem = centrale-> next; while (elem!= NULL) {(*S2)= (*S2) + elem->v; elem = elem -> next; return 1; Esercizio 3. Scrivere la funzione C Delete che riceve la lista e un numero N come parametri e restituisce, sempre come parametro, la lista modificata (mantenere la correttezza dei puntatori di accesso) dopo la cancellazione del primo elemento della lista che contiene il valore N nel campo v. Ritorna inoltre 1 se ha cancellato un elemento e 0 altrimenti. int Delete(struct el **primo, struct el **centrale, struct el **ultimo, int N) { struct el *tmp = NULL, *del = NULL, *prec = NULL; int cont = 0, pos = 0,i ; //lista vuota if (*primo == NULL) {printf("lista vuota, nessuna cancellazione\n");return 0; //cicla sulla lista alla ricerca del valore da eliminare tmp = *primo; del = NULL; prec = NULL; while (tmp!= NULL && del == NULL) if (tmp -> v == N) del = tmp; else {prec = tmp; tmp = tmp -> next; //verifica se ho trovato un elemento da eliminare if (del == NULL) {printf("valore %d non trovato!\n", N);return 0; //e' il primo elemento if (prec == NULL) { //avanza il primo *primo = del->next; //era anche l'ultimo if (del == *ultimo) *ultimo = *primo; //in mezzo o ultimo else { free(del); prec->next = del->next; //era anche l'ultimo if (del == *ultimo) *ultimo = prec; //se la lista si e' svuotata, non ho piu' un centrale if (*primo == NULL) {*centrale = NULL;return 1; //conta elementi pp. 3 / 4

4 cont = 0; tmp = *primo; while(tmp!= NULL) {cont++; tmp = tmp->next; //calcola la meta' in base alla regola del testo pos = cont / 2; //cicla sulla lista per assegnare il nuovo centrale *centrale = NULL; tmp=*primo; for (i=1; i<=pos;i++) if (i == pos) *centrale = tmp; else tmp = tmp->next; return 1; Esercizio 4. Indicare cosa stampa a video il seguente programma, rispettando il formato di stampa. #include <stdio.h> #include <string.h> #include <stdlib.h> int max(int s1,int s2){if(s1>s2) return s1; else return s2; char *s(char *s1, char *s2) {char *r; int c=0; int i; r=(char *)malloc(sizeof(char)*max(strlen(s1),strlen(s2))+1); for (i=0;s1[i]!='\0';i++) { r[i]=((s1[i]-'a')+(s2[i]-'a')+c)%2+'a'; c=((s1[i]-'a')+(s2[i]-'a')+c)/2; r[i]=c+'a'; i++; r[i]='\0'; return r; int main(int argc, char **argv) {printf("%s\n", s("ddab","eflm")); printf("%s\n", s("abab","baba")); printf("%s\n", s("aaaa","bbbb")); return 0; bbabk bbbba bbbba Esercizio 5. Dato il seguente schema di programma C int main() {. F1 =fork(); if (F1==0) {F2=fork(); if (F2==0) {istruzione 3 //istante t3 else {istruzione 2 //istante t2 else {istruzione 1//istante t1 Nei seguenti casi indicare lo/gli stato/i possibili di ognuno dei 3 processi (non esiste, running, zombie, killed), riportando per i soli processi figli quale sia il padre nello/i stato/i evidenziati. Caso1: istruzione1 exit() istruzione 2:exit(); istruzione 3: exit() ipotizzando di essere ad un istante t3>t>t1 e t2>t pp. 4 / 4

5 t>t1 implica che il processo padre P abbia eseguito exit e quindi sia in stato zombie o killed t<t2 implica che figlio non abbia eseguiito exit, tuttavia se il padre ha eseguito la exit significa che la sua fork si era conclusa con la creazione del figlio F1. F1 quindi è running e suo padre sarà P se è ancora zombie, altrimenti sarà INIT se P è killed. t<t3 implica che anche il figlio F2 sia al più running, tuttavia non si è in grado di assicurare che F1 abbia già eseguito la sua fork prima di t e pertanto F2 è in stato: non esiste o running. Il padre di F2 è F1 pochè F1 esiste. Caso 2: istruzione1 exit() istruzione 2: while (1); istruzione 3: exit() ipotizzando di essere ad un istante t>t1 t>t1 implica che il padre P si trovi nelle stesse condizioni del caso 1. T può essere <t2 e per quanto detto prima F1 sarebbe in stato di running. Tale stato si mantiene anche se t>t2 poiché F1 è in ciclo infinito e quindi permane in stato di running. Per lo stato di F1 valgono le stesse considerazioni del caso 1. Per il processo F2 (vedi considerazioni caso 1) si può solo escludere che sia killed perché F1 è nel ciclo infinito e non esegue quindi una wait. Gli stati di F2 possono essere quindi: non esiste, running, zombie. Il padre di F2 sarà comunque F1. Caso 3: istruzione1 wait( ); exit(); istruzione 2: exit(); istruzione 3: while (1); ipotizzando di essere ad un istante t>t1 Per il padre P stesse considerazioni del caso 1 Figlio F1. Se il padre ha eseguito la exit significa che precedentemente abbia eseguito la wait. Ciò implica necessariamente che t > t2 e che inoltre F1 sia stato anche eliminato. Pertanto lo stato di F1 è killed. t> t2 implica che F2 sia stato creato e poiché esso al più entra nel ciclo infinito lo stato di F1 sarà running. Il padre di F2 invece sarà init dato che F1 non esiste più. pp. 5 / 4