Note Ingegneria Informatica · UniTN
Programmazione 1
esercizi
Teoria
in corso

Espressioni, operatori e costanti (esercizi)

Esercizi tipo esame di Espressioni, operatori e costanti, dove stanno teoria, metodo ed esempi svolti a lezione. Testo in chiaro, soluzione chiusa: prima provaci da solo.

Dal più facile al livello del 30. Tutti i programmi sono stati compilati ed eseguiti; l’output nelle soluzioni è quello vero.

Esercizio 1. Valuta ogni espressione, con int dove non c’è il punto decimale.

a) 7 / 2 * 2        b) 7 / 2.0         c) 10 - 4 - 3      d) 100 / 10 / 5
e) 1 + 2 * 3 % 4    f) -7 / 2          g) -7 % 2          h) !5 + 1
i) 3 < 2 < 1        j) 5 > 3 && 2 > 4
Soluzione

Si riconosce: espressioni senza variabili, contano solo la tabella delle precedenze e il tipo degli operandi.

a) 7 / 2 * 2       / e * stesso gruppo, da sinistra:  (7 / 2) * 2  =  3 * 2  =  6
b) 7 / 2.0         un operando double:                 3.5
c) 10 - 4 - 3      da sinistra:                        (10 - 4) - 3  =  6 - 3  =  3
d) 100 / 10 / 5    da sinistra:                        (100 / 10) / 5  =  10 / 5  =  2
e) 1 + 2 * 3 % 4   * e % da sinistra:                  (2 * 3) % 4  =  6 % 4  =  2
                   poi +:                              1 + 2  =  3
f) -7 / 2          -3.5 troncato verso zero:           -3
g) -7 % 2          -7 - (-3) * 2  =  -7 + 6:           -1
h) !5 + 1          ! prima di +:  (!5) + 1             5 è vero, !5 vale 0;  0 + 1  =  1
i) 3 < 2 < 1       da sinistra:  (3 < 2) < 1           0 < 1  =  1
j) 5 > 3 && 2 > 4  confronti prima di &&:              1 && 0  =  0

La i) non è la catena matematica “3 < 2 < 1”, che sarebbe falsa: 3 < 2 produce 0, e 0<10 < 1 è vero. gcc con -Wall avvisa (comparisons like 'X<=Y<=Z' do not have their mathematical meaning). Controllo della g) con l’identità: (−3)⋅2+(−1)=−7(-3) \cdot 2 + (-1) = -7. Verificati con un programma.

Esercizio 2. Disegna l’albero sintattico di a = b + c * d - e / 2 e calcola a con b=1b = 1, c=2c = 2, d=3d = 3, e=8e = 8.

Soluzione

Si riconosce: albero sintattico, quindi prima si decide chi è la radice. È l’operatore con la precedenza più bassa, l’assegnazione.

  1. L’assegnazione = è più in basso di tutti: radice, con a a sinistra e tutto il resto a destra.
  2. Fra +, *, -, / lega di meno il gruppo additivo. + e - sono dello stesso gruppo e associano da sinistra, quindi la radice del lato destro è il -: (b + c * d) - (e / 2).
  3. Sotto il +: b e c * d. Sotto il /: e e 2.

Dal basso:

c * d          2 * 3  =  6
b + c * d      1 + 6  =  7
e / 2          8 / 2  =  4
... - ...      7 - 4  =  3
a = ...        a vale 3

Verificato: stampa 3.

Esercizio 3. Quali righe danno errore di compilazione, e perché?

const int max = 10;
int n = 3;
n = max + 1;        (1)
max = n;            (2)
max++;              (3)
const int m;        (4)
Soluzione

Si riconosce: domanda su const. Per ogni riga si guarda se scrive una variabile const.

  • (1) va bene: si legge max (leggere una costante è permesso), si scrive n.
  • (2) errore: max è const, gcc dice assignment of read-only variable 'max'.
  • (3) errore: anche ++ è una scrittura (max = max + 1), gcc dice increment of read-only variable 'max'.
  • (4) compila, senza nemmeno un warning, ma m resta senza valore per sempre: una costante va inizializzata nella dichiarazione, dopo non si può più. In C++ è un errore. È codice sbagliato anche se passa.

Verificato con gcc 16, -std=c11 -Wall -Wextra.

Esercizio 4. Scrivi l’output esatto.

#include <stdio.h>

int main(void)
{
    char c = 'd';
    int d = c - 'a';
    char e = c + 2;
    char f = 'b' - 'a' + 'A';

    printf("%d %c %c %d\n", d, e, f, e);
    return 0;
}
Soluzione

Si riconosce: aritmetica sui caratteri. Si lavora sui codici e alla fine si guarda se la printf usa %c o %d.

variabilecontovalorecome carattere
c100d
d100−97100 - 973
e100+2100 + 2102f
f98−97+6598 - 97 + 6566B

La d è la quarta lettera, quindi dista 3 dalla a. 'b' - 'a' + 'A' è la formula minuscola-maiuscola applicata alla b. L’ultimo %d stampa il codice di e, non il carattere.

Output: 3 f B 102 (verificato).

Esercizio 5. Scrivi l’output esatto.

#include <stdio.h>

int main(void)
{
    int i = 3;
    int j = 2;
    int k;

    k = i++ * 2 + --j;
    j += k-- - i;
    i *= j - 2;
    printf("%d %d %d\n", i, j, k);
    return 0;
}
Soluzione

Si riconosce: tracing con incrementi e assegnazioni composte. Tabella, una riga per istruzione, composte riscritte in forma estesa.

istruzioneforma estesaijkconto
iniziale32?
k = i++ * 2 + --j;417i++ vale 3, --j vale 1: 3⋅2+1=73 \cdot 2 + 1 = 7
j += k-- - i;j = j + (k-- - i)446k-- vale 7, i è 4: 7−4=37 - 4 = 3, 1+3=41 + 3 = 4
i *= j - 2;i = i * (j - 2)8464⋅(4−2)=84 \cdot (4 - 2) = 8

Nella seconda riga i vale già 4: l’incremento della riga prima è avvenuto. k passa a 6 dopo aver dato 7 al conto.

Output: 8 4 6 (verificato).

Esercizio 6. Scrivi l’output esatto.

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 5;
    int r = (a > 0) && (b++ > 0);
    int s = (a == 0) || (b-- > 0);
    int t = (a == 0) && (b++ > 4);

    printf("%d %d %d %d\n", r, s, t, b);
    return 0;
}
Soluzione

Si riconosce: && e || con un ++ a destra. Per ogni riga la domanda è “la destra si valuta?“.

variabilesinistradestra valutata?valoreb dopo
r0 > 0 è 0no, && con sinistra falsa05
s0 == 0 è 1no, || con sinistra vera15
t0 == 0 è 1sì: b++ > 4 confronta 5 con 4, vero16

In t il confronto usa il valore prima dell’incremento (5), poi b diventa 6.

Output: 0 1 1 6 (verificato).

Esercizio 7. Scrivi l’output esatto.

#include <stdio.h>

int main(void)
{
    int m = 247;
    int a = m % 10;
    int b = m / 10 % 10;
    int c = m / 100;
    int x = a++ + --b;

    x += a * b % 5;
    printf("%d %d %d %d\n", a, b, c, x);
    return 0;
}
Soluzione

Si riconosce: cifre di un numero più incrementi. Prima le cifre, poi la tabella.

a = 247 % 10          = 7
b = 247 / 10 % 10     = 24 % 10 = 4
c = 247 / 100         = 2
istruzioneabcxconto
dopo le cifre742?
x = a++ + --b83210a++ vale 7, --b vale 3: 7+37 + 3
x += a * b % 5;83214* e % da sinistra: (8⋅3)%5=24%5=4(8 \cdot 3) \% 5 = 24 \% 5 = 4, 10+410 + 4

Output: 8 3 2 14 (verificato).

Esercizio 8. Trova gli errori. Per ogni riga numerata di’ cosa succede (errore di compilazione, warning, valore inatteso) e come si corregge.

int a = 7;
int b = 2;
double media = (a + b) / 2;     (1) si vuole 4.5
int dentro = 3 < a < 5;         (2) si vuole sapere se a è fra 3 e 5
char c = "z";                   (3)
const int max = 10;
max += 1;                       (4)
int r = a % 0;                  (5)
int s = 7.5 % 2;                (6)
Soluzione

Si riconosce: “trova l’errore”. Per ogni riga si controllano tipi degli operandi, precedenze, const, apici.

  • (1) compila senza warning ma vale 4.0: (a + b) / 2 è 9/29 / 2 fra interi, cioè 4, poi convertito in double. Si corregge con (a + b) / 2.0.
  • (2) vale 1 anche se a=7a = 7: (3 < 7) < 5 è 1 < 5, cioè 1. gcc avvisa due volte (-Wparentheses e -Wbool-compare). Si scrive 3 < a && a < 5, che vale 0.
  • (3) errore con gcc 16: "z" è una stringa, non un carattere. Si scrive char c = 'z';.
  • (4) errore: assignment of read-only variable 'max', perché max += 1 è max = max + 1.
  • (5) warning division by zero, e a run-time comportamento indefinito. Il divisore di % non può essere 0.
  • (6) errore: invalid operands to binary %. % vuole due interi.

Tutti i messaggi sono quelli di gcc 16 con -std=c11 -Wall -Wextra -Wpedantic.

Esercizio 9. Scrivi un programma che legge un numero di tre cifre e stampa la somma delle cifre e il numero rovesciato (da 527: somma 14, rovesciato 725). Niente cicli.

Soluzione

Si riconosce: cifre di un numero, quindi / e % per 10. Con tre cifre bastano tre espressioni: centinaia n / 100, decine n / 10 % 10, unità n % 10. Il rovesciato si ricompone pesando le cifre al contrario: unità per 100, decine per 10, centinaia per 1.

#include <stdio.h>

int main(void)
{
    int n;
    int c;
    int d;
    int u;

    printf("Numero di tre cifre ?\n");
    scanf("%d", &n);
    c = n / 100;
    d = n / 10 % 10;
    u = n % 10;
    printf("somma cifre = %d\n", c + d + u);
    printf("rovesciato = %d\n", u * 100 + d * 10 + c);
    return 0;
}

Con input 527: c=5c = 5, d=52%10=2d = 52 \% 10 = 2, u=7u = 7; somma 5+2+7=145 + 2 + 7 = 14; rovesciato 7⋅100+2⋅10+5=7257 \cdot 100 + 2 \cdot 10 + 5 = 725.

Numero di tre cifre ?
somma cifre = 14
rovesciato = 725

Controllo su un caso limite, input 120: somma 3, rovesciato 0⋅100+2⋅10+1=210 \cdot 100 + 2 \cdot 10 + 1 = 21. È giusto: “021” come intero è 21, lo zero davanti non si stampa. Verificati entrambi.

Esercizio 10. Scrivi un programma che legge una lettera minuscola e stampa la sua maiuscola e la sua posizione nell’alfabeto (da g: G e' la lettera numero 7).

Soluzione

Si riconosce: aritmetica ASCII. c - 'a' è la posizione contando da 0 (a è 0, g è 6), quindi la posizione “umana” è c - 'a' + 1; la maiuscola è la stessa posizione partendo da 'A'.

#include <stdio.h>

int main(void)
{
    char c;

    printf("Lettera minuscola ?\n");
    scanf(" %c", &c);
    printf("%c e' la lettera numero %d\n", c - 'a' + 'A', c - 'a' + 1);
    return 0;
}

Con input g: c - 'a' è 103−97=6103 - 97 = 6; maiuscola 6+65=716 + 65 = 71, cioè G; posizione 6+1=76 + 1 = 7.

Lettera minuscola ?
G e' la lettera numero 7

Lo spazio in " %c" salta eventuali spazi o a capo prima della lettera. Verificato.

Esercizio 11. Vero o falso?

a) 5 / 2 e 5 / 2.0 hanno lo stesso valore.
b) x++; e ++x; scritti da soli come istruzioni hanno lo stesso effetto.
c) Con a che vale 3, dopo r = a || b++; la variabile b non è cambiata.
d) '5' - '0' vale 5.
e) "a" e 'a' sono lo stesso oggetto.
f) const int k; seguito da k = 4; compila.
g) x *= 2 + 1 triplica x.
h) -7 % 3 vale 2.
Soluzione
  1. Falso: 5 / 2 è 2 (fra interi), 5 / 2.0 è 2.5.
  2. Vero: il valore dell’espressione si butta via, resta solo l’effetto, che è lo stesso.
  3. Vero: a è 3, quindi vero, e || non valuta la destra.
  4. Vero: 53−48=553 - 48 = 5.
  5. Falso: 'a' è un carattere (il numero 97), "a" è una stringa.
  6. Falso: k è const, l’assegnazione è un errore di compilazione.
  7. Vero: è x = x * (2 + 1). Con x=5x = 5 dà 15.
  8. Falso: la divisione tronca verso zero, −7/3=−2-7 / 3 = -2, resto −7−(−2)⋅3=−1-7 - (-2) \cdot 3 = -1. Il resto ha il segno del dividendo.

a, c, d, g, h verificati con un programma; f con gcc.

Esercizio 12. (Livello 30) Una matricola fittizia, 238471. Scrivi l’output esatto.

#include <stdio.h>

int main(void)
{
    int m = 238471;
    int a = m % 10;
    int b = m / 100 % 10;
    int c = m / 10000;
    int x;
    int y;
    char ch;

    x = c % 7 * 2 + a--;
    y = a != 0 && ++b > 4;
    y += x / b * b + x % b;
    ch = 'A' + c % 26;
    x *= y - 3;
    printf("%d %d %d %d %c %d\n", a, b, x, y, ch, ch - 'A' + 1);
    return 0;
}
Soluzione

Si riconosce: tracing con la matricola che mescola tutto (cifre, precedenze, post-decremento, lazy evaluation, caratteri). Prima le cifre, poi una riga per istruzione.

a = 238471 % 10            = 1
b = 238471 / 100 % 10      = 2384 % 10 = 4
c = 238471 / 10000         = 23
istruzioneabcxychconto
dopo le cifre1423???
x = c % 7 * 2 + a--;04235??% e * da sinistra: (23%7)⋅2=2⋅2=4(23 \% 7) \cdot 2 = 2 \cdot 2 = 4; a-- vale 1; 4+1=54 + 1 = 5
y = a != 0 && ++b > 4;042350?a != 0 è 0 != 0, falso: && si ferma, ++b non avviene
y += x / b * b + x % b;042355?(5/4)⋅4+5%4=4+1=5(5 / 4) \cdot 4 + 5 \% 4 = 4 + 1 = 5; 0+50 + 5
ch = 'A' + c % 26;042355X23%26=2323 \% 26 = 23; 65+23=8865 + 23 = 88, la X
x *= y - 3;0423105X5⋅(5−3)=105 \cdot (5 - 3) = 10

Le trappole: nella seconda riga a vale già 0 per il a-- di prima, quindi la destra di && non si valuta e b resta 4. Nella terza x / b * b + x % b è l’identità del resto: vale x, cioè 5, qualunque sia b. Nell’ultimo %d, ch - 'A' + 1 è 23+1=2423 + 1 = 24: la X è la ventiquattresima lettera.

Output: 0 4 10 5 X 24 (verificato).