Fondamenti di Informatica - A.A.

2014-2015
Ingegneria Informatica
Scuola di Ingegneria Industriale e dellInformazione
Prof.ssa Cristiana Bolchini
Appello del 28/11/2014
Cognome

Nome

E
UIR
T
I
T
TO
RES PILA
M
CO
Voto: . . . /30

Matricola

Quesito:

Tot.

Max:

30

Punti:
Quesito 1 (5 punti)
Punteggio ottenuto: . . . /5
Dati i due numeri A = 4416M S e B = +6410M S effettuare la conversione in base 2, notazione complemento a 2 (2C2),
sul numero minimo di bit necessari a rappresentare entrambi gli operandi. Si effettuino quindi le operazioni A+B e A-B
indicando esplicitamente se si verifica overflow o meno, e motivando la risposta. Mostrare i passaggi fatti.
Traccia soluzione:
|A |= 4416M S = 1000100 da cui 01000100M S = 01000100C2 = 4416M S 01000100C2 = -A = A = 10111100C2
|B |= 6410M S = 1000000 da cui 01000000M S = 01000000C2 = +6410M S = B = 01000000C2
Gli operandi hanno ugual dimensione si puo` procedere con le operazioni.
A+B
10111100 +
01000000
11111100
Operandi discordi:
non si puo` verificare overflow

A+(-B)
10111100 +
11000000
01111100
Operandi concordi, risultato discorde:
si e` verificato overflow

Quesito 2 (4 punti)
Punteggio ottenuto: . . . /4
Dato il numero A = 0.04687510M S convertirlo in base 2, notazione IEEE 754, singola precisione, riportando tutti i bit della
codifica. Rappresentare inoltre il valore risultante convertito in base 16. Mostrare i passaggi.
Traccia soluzione:
La notazione IEEE standard prevede 1 bit per il segno (1), 8 bit per il campo esponente, rappresentato con la notazione in
eccesso a 127 (eccesso = 2num bit exp1 1) e i restanti 23 bit di campo mantissa, normalizzata.
Si puo` procedere rappresentando il numero in virgola fissa ed applicando quindi il fattore di scala opportuno per portarlo
nella forma (1 + M ) 2e ; nel caso in esame, il fattore di scala e` -1.
Conversione della parte intera 010 = 02 .
Conversione della parte decimale, mediante moltiplicazioni ripetute per la base: 0.04687510 = 0000110000000000000000000002
Rappresentazione in virgola fissa: 0.000011000000000000000000000.
E` necessari normalizzare per arrivare nella forma (1 + M ) 2e :
0.000011000000000000000000000 20 = 1.10000000000000000000000 25
La notazione e` in eccesso e dunque nel campo esponente va rappresentato il valore 5 + 127 = 122. 12210 = 011110102 .
Quindi, la sequenza di 32 bit che rappresenta la codifica in base 2, notazione IEEE 754, singola precisione e` la seguente.
0.04687510M S = 1 01111010 10000000000000000000000
Per rappresentare questo valore in base 16, e` sufficiente convertire in base 16 sequenze di 4 bit:
1011
B

10111101010000000000000000000000
1101 0100 0000 0000 0000 0000
D
4
0
0
0
0
BD400000

0000
0

Quesito 3 (5 punti)
Punteggio ottenuto: . . . /5
Scrivere un programma che riceve in ingresso due stringhe di al piu` 200 caratteri e conta e visualizza il numero di volte in
cui la seconda stringa e` contenuta nella prima.
Traccia soluzione:
#include <stdio.h>
#define N 200
int main(int argc, char * argv[])
{
char s1[N+1], s2[N+1];
int i, j, count;
scanf("%s %s", s1, s2);
count = 0;
for(i = 0; s1[i] != \0;i++;){
while(s2[0] != s1[i] && s1[i] != \0)
i++;
/* s2[0] uguale a s1[i] */
j = 1;
while(s2[j] == s1[i+j] && s2[j] != \0 && s1[i+j] != \0)
j++;
if(s2[j] == \0)
count++;
/* sequenze anche sovrapposte */
/* per non sovrapposte, impostare i a i+j-1 */
}
return 0;
}

Quesito 4 (5 punti)
Punteggio ottenuto: . . . /5
Scrivere un programma che acquisisce un array di 50 numeri interi. Il programma, terminata lacquisizione, muove tutti
i valori diversi da 0 alla sinistra dellarray, e tutti gli zeri a destra dellarray. Al termine il programma visualizza larray
seguito dal numero di valori non nulli in esso presenti. Non e` importante lordine degli elementi non nulli.
Esempio:
Ingresso (con solo 7 valori):
Uscita:
Traccia soluzione:
#include <stdio.h>
#define L 50
int main(int argc, char* argv[])
{
int val[L], i, j;
int temp, nzero;
/* acquisizione */
for(i = 0; i < L; i++)
scanf("%d", &val[i]);
i = 0;
j = L-1;
nzero = 0;
while(i < j){
while(val[i] != 0 && i < j)
i++;
/* elemento nullo */
if(val[i] == 0){
nzero++;
while(val[j] == 0 && i < j)
j--;
/* elemento non nullo */
temp = val[i];
val[i] = val[j];
val[j] = temp;
j--;
}
i++;
}
if(i == j && val[j] == 0)
nzero++;
/* visualizzazione */
for(i = 0; i < L; i++)
printf("%d ", val[i]);
printf("\n%d\n", L - nzero);
return 0;
}

1 0 2 0 0 3 4
1 4 2 3 0 0 0
4

(o anche un diverso ordine dei primi 4 valori)

Quesito 5 (5 punti)
Punteggio ottenuto: . . . /5
Unimmagine a colori viene memorizzata come una matrice A di pixel, di N righe e M colonne. Ogni pixel A[i][j] e`
rappresentato come una struttura con tre valori interi che rappresentano le sue componenti cromatiche (rosso R, verde G,
blu B). Per convertire il pixel da una scala a colore in una scala di grigi, si prenda la media dei tre colori (arrotondato al
numero intero piu` vicino) che ne definisce cos` la luminosit`a. Si definisca un tipo adatto a rappresentare i pixel supportando sia il colore sia la scala di grigi (in unimmagine solo a colori la parte della luminosit`a del grigio sar`a a -1, nel caso di
unimmagine solo in scala di grigi saranno -1 i valori del colore). Scrivere un programma che acquisisce le informazioni
di unimmagine 100x100 a colori. Una volta effettuata lacquisizione, il programma calcola limmagine corrispondente in
scala di grigi, e poi la visualizza.
Traccia soluzione:
#include <stdio.h>
#define N 100
#define M 100
typedef struct _image {
int r, g, b;
int lum;
} image_t;
int main(int argc, char * argv[])
{
image_t A[N][M];
int i, j;
float avg;
/* acquisizione */
for(i = 0; i < N; i++)
for(j = 0; j < M; j++){
scanf("%d%d%d", &(A[i][j].r), &(A[i][j].g), &(A[i][j].b));
A[i][j].lum = -1;
}
/* calcolo scala di grigi */
for(i = 0; i < N; i++)
for(j = 0; j < M; j++){
avg = (A[i][j].r + A[i][j].g + A[i][j].b)/3.0;
if(avg > 0.5)
A[i][j].lum = avg + 1;
else
A[i][j].lum = avg;
}
/* visualizzazione */
for(i = 0; i < N; i++){
for(j = 0; j < M; j++)
printf("%d ", A[i][j].lum);
printf("\n");
}
return 0;
}

Quesito 6 (6 punti)
Punteggio ottenuto: . . . /6
Scrivere un programma che acquisisce una sequenza di 80 interi positivi e ne disegna un istogramma ruotato di 90 gradi,
utilizzando il carattere *.
Esempio:
2 5 7 0 5 1 9
*
*
*
*
*
*
* *
*
*
* *
*
*
* *
*
*
* * *
*
*
* * *
* * *

*
*
*

Traccia soluzione:
#include <stdio.h>
#define L 80
int main(int argc, char * argv[])
{
int val[L], i;
int max, righe;
/* acquisizione */
for(i = 0; i < L; i++)
scanf("%d", &val[i]);
for(max = val[0], i = 1; i < L; i++)
if(val[i] > max)
max = val[i];
for(righe = max; righe > 0; righe--){
for(i = 0; i < L; i++)
if(val[i] >= righe)
printf("* ");
else
printf(" ");
printf("\n");
}
return 0;
}