Ecco la guida definitiva con le soluzioni a **tutti gli esercizi del tuo corso**.

---

# GUIDA COMPLETA PER L'ESAME DI C

*(Paniere Completo Esami "Complementi di Programmazione")*

---

## Esercizio 1: Numeri di Harshad (28 Agosto 2025)

### Schema Logico

1. **Verifica Input:** Ciclo `do-while` per imporre $a \ge 1$, $b \ge 1$ e $a < b$.
2. **Somma delle Cifre:** Si usa il ciclo `while(n > 0)` estratte con `% 10` e tagliate con `/ 10`.
3. **Controllo Harshad:** Se `numero % somma == 0`, incrementa il contatore.
4. **Stampa:** Ciclo `for` finale per stampare "gioia" un numero di volte pari al contatore.

### Codice C

```c
#include

int main() {
int a, b;

// 1. Lettura dati controllata

do {
printf("Inserisci due numeri a e b (a >= 1, b >= 1, a < b): ");
scanf("%d %d", &a;, &b;);
} while (a < 1 || b < 1 || a >= b);

int contatore_harshad = 0;

// 2. Controllo tutti i numeri da a a b

for (int i = a; i <= b; i++) {
int temp = i;
int somma_cifre = 0;

// Somma delle cifre

while (temp > 0) {
somma_cifre += temp % 10;
temp /= 10;
}

// Verifica divisibilita
if (i % somma_cifre == 0) {
contatore_harshad++;
}
}

// 3. Stampa "gioia"
for (int i = 0; i < contatore_harshad; i++) {
printf("gioia\n");
}

return 0;
}

```

---

## Esercizio 2: Gestione Veicoli Aziendali (28 Agosto 2025)

### Schema Logico

* **Struct:** `struct veicolo { char targa[15]; int chilometraggio; char modello[30]; };`
* **Univocità targa:** Durante l'inserimento, scorrere l'array per verificare che la targa non esista già.
* **Funzioni stringa:** Utilizzare `strcmp` per confrontare le stringhe e `strstr` per cercare sottostringhe (`cercaTarga`).
* **Scrittura File:** Aprire il file `[Link]` in modalità `"w"` con `fopen` e scrivere con `fprintf`.

### Codice C

```c
#include
#include

#define MAX_VEICOLI 100

struct veicolo {
char targa[15];
int chilometraggio;
char modello[30];
};

struct veicolo flotta[MAX_VEICOLI];

int num_veicoli = 0;

// Inserisci veicolo assicurando targa univoca

struct veicolo inserisciVeicolo() {
struct veicolo v;
int univoca = 0;

do {
univoca = 1;
printf("Inserisci targa: ");
scanf("%s", [Link]);

for (int i = 0; i < num_veicoli; i++) {

if (strcmp(flotta[i].targa, [Link]) == 0) {
printf("Targa gia' esistente! Riprova.\n");
univoca = 0;
break;
}
}
} while (!univoca);

printf("Inserisci chilometraggio: ");

scanf("%d", &[Link];);
printf("Inserisci modello: ");
scanf("%s", [Link]);

return v;
}

void cercaModello(char nomeModello[30]) {

int trovati = 0;
int km_totali = 0;

printf("Targhe per il modello %s:\n", nomeModello);

for (int i = 0; i < num_veicoli; i++) {
if (strcmp(flotta[i].modello, nomeModello) == 0) {
printf("- %s\n", flotta[i].targa);
trovati++;
km_totali += flotta[i].chilometraggio;
}
}

printf("Totale trovati: %d\n", trovati);

if (trovati > 0) {
printf("Km medi: %.2f\n", (float)km_totali / trovati);
}
}

void cercaChilometraggio(int min, int max) {

printf("Veicoli con km compresi tra %d e %d:\n", min, max);
for (int i = 0; i < num_veicoli; i++) {
if (flotta[i].chilometraggio > min && flotta[i].chilometraggio < max) {
printf("- %s (%d km)\n", flotta[i].targa, flotta[i].chilometraggio);
}
}
}
void cercaTarga(char codice[3]) {
FILE *f = fopen("[Link]", "w");
if (f == NULL) {
printf("Errore nell'apertura del file!\n");
return;
}

for (int i = 0; i < num_veicoli; i++) {

if (strstr(flotta[i].targa, codice) != NULL) {
fprintf(f, "Targa: %s | Modello: %s | Km: %d\n", flotta[i].targa, flotta[i].modello, flotta[i].chilometraggio);
}
}

fclose(f);
printf("Risultati salvati su [Link]\n");
}

void ordinaEStampa() {
// Bubble sort decrescente
struct veicolo temp;
struct veicolo copia[MAX_VEICOLI];
for (int i = 0; i < num_veicoli; i++) copia[i] = flotta[i];

for (int i = 0; i < num_veicoli - 1; i++) {

for (int j = 0; j < num_veicoli - i - 1; j++) {
if (copia[j].chilometraggio < copia[j+1].chilometraggio) {
temp = copia[j];
copia[j] = copia[j+1];
copia[j+1] = temp;
}
}
}

printf("\n--- FLOTTA ORDINATA PER KM (DECRESCENTE) ---\n");

for (int i = 0; i < num_veicoli; i++) {
printf("Targa: %s | Km: %d | Modello: %s\n", copia[i].targa, copia[i].chilometraggio, copia[i].modello);
}
}

int main() {
int scelta = 0;

while (scelta != -1) {

printf("\n--- MENU ---\n");
printf("1. Inserisci veicolo\n2. Cerca modello\n3. Cerca per chilometraggio\n4. Cerca targa (salva su file)\n5. Stampa ordinata per km\n-1. Uscita\nScelta: ");
scanf("%d", &scelta;);

if (scelta == 1) {
if (num_veicoli < MAX_VEICOLI) {
flotta[num_veicoli] = inserisciVeicolo();
num_veicoli++;
} else {
printf("Flotta piena!\n");
}
} else if (scelta == 2) {
char mod[30];
printf("Inserisci modello: ");
scanf("%s", mod);
cercaModello(mod);
} else if (scelta == 3) {
int min, max;
printf("Inserisci min e max km: ");
scanf("%d %d", &min;, &max;);
cercaChilometraggio(min, max);
} else if (scelta == 4) {
char cod[3];
printf("Inserisci codice targa (max 2 car): ");
scanf("%s", cod);
cercaTarga(cod);
} else if (scelta == 5) {
ordinaEStampa();
}
}

return 0;
}

```

---

## Esercizio 3: Lancio Dadi Dodecaedri (10 Giugno 2025)

### Schema Logico

1. **Generazione Casuale:** Utilizzare `srand(time(NULL))` e la formula `(rand() % 12) + 1` per simulare un dado a 12 facce.
2. **I/O Simultaneo:** Aprire `[Link]` e scrivere sia a schermo con `printf` sia nel file con `fprintf`.
3. **Condizione di arresto:** Il ciclo `do-while` si arresta quando la somma è compresa nell'intervallo $[5, 10]$.

### Codice C

```c
#include
#include
#include

int main() {
srand(time(NULL));

FILE *f = fopen("[Link]", "w");

if (f == NULL) return 1;

int dado1, dado2, somma;

do {
dado1 = (rand() % 12) + 1; // Valore tra 1 e 12
dado2 = (rand() % 12) + 1;
somma = dado1 + dado2;

printf("Lancio: %d + %d = %d\n", dado1, dado2, somma);

fprintf(f, "Somma: %d\n", somma);

} while (somma < 5 || somma > 10); // Continua finché NON è tra 5 e 10

fclose(f);
printf("Terminato! Somma finale compresa tra 5 e 10.\n");
return 0;
}

```

---

## Esercizio 4: Radice Intera e Numeri Triangolari (12 Febbraio 2025)

### Schema Logico

* **Radice Intera:** Trovata mediante un ciclo `while` incrementando `y` finché $(y+1)^2 \le n$. Non si usa `math.h`.
* **Numero Triangolare:** Un numero $k$ è triangolare se la quantità $\frac{\sqrt{8k + 1} - 1}{2}$ è un intero preciso (ossia senza resto nell'estrazione della radice intera).

### Codice C

```c
#include

// Calcola la radice quadrata intera senza math.h

int radice_intera(int n) {
int y = 0;
while ((y + 1) * (y + 1) <= n) {
y++;
}
return y;
}
int main() {
int n;
printf("Inserisci un numero positivo n: ");
scanf("%d", &n;);

printf("Numeri triangolari minori di %d:\n", n);

for (int k = 1; k < n; k++) {

int rad = radice_intera(8 * k + 1);

// Verifica se 8k+1 e' un quadrato perfetto perfetto e se la formula da un intero

if (rad * rad == (8 * k + 1) && (rad - 1) % 2 == 0) {
printf("%d ", k);
}
}
printf("\n");

return 0;
}

```

---

## Esercizio 5: Array di Valori Pseudocasuali e Media (28 Marzo 2024)

### Schema Logico

1. **Generazione Range:** Per valori compresi tra 5 e 50: `(rand() % (50 - 5 + 1)) + 5`.
2. **Media Intera Inferiore:** La divisione tra interi in C (`somma / M`) esegue automaticamente il troncamento inferiore.
3. **Ricerca:** Scorrere l'array con una flag `trovato` per verificare la presenza del valore di media.

### Codice C

```c
#include
#include
#include

#define M 10

int main() {
srand(time(NULL));
int arr[M];
int somma = 0;

printf("Valori generati: ");

for (int i = 0; i < M; i++) {
arr[i] = (rand() % 46) + 5; // Genera tra 5 e 50
printf("%d ", arr[i]);
somma += arr[i];
}

int media = somma / M; // Troncamento intero automatico

printf("\nMedia approssimata all'intero inferiore: %d\n", media);

int trovato = 0;
for (int i = 0; i < M; i++) {
if (arr[i] == media) {
trovato = 1;
break;
}
}

if (trovato) {
printf("La media COINCIDE con almeno un elemento dell'array.\n");
} else {
printf("La media NON coincide con alcun elemento dell'array.\n");
}

return 0;
}

```

---

## Esercizio 6: Confronto di Similitudine tra Stringhe (22 Gennaio 2024)

### Schema Logico

* **Definizione di Similitudine:** Due stringhe $s_1$ e $s_2$ sono simili se almeno l'85% dei caratteri distinti di $s_1$ compaiono in $s_2$ **E** l'85% dei caratteri distinti di $s_2$ compaiono in $s_1$.
* **Funzione Ausiliaria:** Una funzione helper calcola la percentuale di caratteri di $s_1$ presenti in $s_2$.

### Codice C

```c
#include
#include

#define MAX 100

// Calcola la percentuale di caratteri di s1 presenti in s2

float percentuale_presenza(char *s1, char *s2) {
int len1 = strlen(s1);
int trovati = 0;

for (int i = 0; i < len1; i++) {

if (strchr(s2, s1[i]) != NULL) {
trovati++;
}
}
return ((float)trovati / len1) * 100.0;
}

int sono_simili(char *s1, char *s2) {

float perc1 = percentuale_presenza(s1, s2);
float perc2 = percentuale_presenza(s2, s1);

return (perc1 >= 85.0 && perc2 >= 85.0);

}

int main() {
char s1[MAX];

do {
printf("Inserisci la prima stringa (almeno 3 caratteri): ");
scanf("%s", s1);
} while (strlen(s1) < 3);

int scelta;
printf("Scegli un'opzione:\n1. Confronta con una seconda stringa\n2. Confronta con le parole del file [Link]\nScelta: ");
scanf("%d", &scelta;);

if (scelta == 1) {
char s2[MAX];
printf("Inserisci la seconda stringa: ");
scanf("%s", s2);

if (sono_simili(s1, s2)) {
printf("%s e %s sono simili!\n", s1, s2);
} else {
printf("%s e %s NON sono simili!\n", s1, s2);
}
} else if (scelta == 2) {
FILE *f = fopen("[Link]", "r");
if (f == NULL) {
printf("Errore apertura file [Link]\n");
return 1;
}

char parola_file[MAX];
int trovata_simile = 0;
while (fscanf(f, "%s", parola_file) != EOF) {
if (sono_simili(s1, parola_file)) {
printf("La stringa %s e' simile alla parola del file: %s\n", s1, parola_file);
trovata_simile = 1;
break;
}
}
fclose(f);

if (!trovata_simile) {
printf("Nessuna parola simile trovata nel file.\n");
}
}

return 0;
}

```

---

## Esercizio 7: Calcolatrice di Frazioni (22 Gennaio 2024)

### Schema Logico

* **MCD/MCM:** Algoritmo di Euclide per il Massimo Comune Divisore (`MCD`), usato poi per calcolare il Minimo Comune Multiplo ($mcm(a,b) = \frac{a \cdot b}{MCD(a,b)}$) e per la semplificazione.
* **Successione Irriducibile:** Generare frazioni $n/d$ tra $0$ e $1$ ordinate per $d$ crescente e $n$ crescente, con $MCD(n, d) == 1$.

### Codice C

```c
#include

struct frazione {
int numeratore;
int denominatore;
};

int mcd(int a, int b) {

while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}

int mcm(int a, int b) {

return (a * b) / mcd(a, b);
}

void semplifica(struct frazione *f) {

int divisor = mcd(f->numeratore, f->denominatore);
f->numeratore /= divisor;
f->denominatore /= divisor;
}

void stampa(struct frazione f) {

printf("%d/%d", [Link], [Link]);
}

float valoreDecimale(struct frazione f) {

return (float)[Link] / [Link];
}

struct frazione somma(struct frazione a, struct frazione b) {

struct frazione res;
int den_comune = mcm([Link], [Link]);
[Link] = ([Link] * (den_comune / [Link])) + ([Link] * (den_comune / [Link]));
[Link] = den_comune;
semplifica(&res;);
return res;
}

struct frazione prodotto(struct frazione a, struct frazione b) {

struct frazione res;
[Link] = [Link] * [Link];
[Link] = [Link] * [Link];
semplifica(&res;);
return res;
}

void successione(int n) {
int stampati = 0;
int d = 2;

while (stampati < n) {

for (int num = 1; num < d && stampati < n; num++) {
if (mcd(num, d) == 1) { // Irriducibile
struct frazione f = {num, d};
stampa(f);
printf(" ");
stampati++;
}
}
d++;
}
printf("\n");
}

int main() {
int scelta = 0;

while (scelta != 4) {
printf("\n--- CALCOLATRICE FRAZIONI ---\n1. Somma\n2. Prodotto\n3. Successione\n4. Esci\nScelta: ");
scanf("%d", &scelta;);

if (scelta == 1 || scelta == 2) {
struct frazione f1, f2, res;
printf("Inserisci Frazione 1 (num den): ");
scanf("%d %d", &[Link];, &[Link];);
printf("Inserisci Frazione 2 (num den): ");
scanf("%d %d", &[Link];, &[Link];);

if (scelta == 1) res = somma(f1, f2);

else res = prodotto(f1, f2);

printf("Risultato: ");
stampa(res);
printf(" (Valore decimale: %.2f)\n", valoreDecimale(res));
} else if (scelta == 3) {
int n;
printf("Quanti elementi stampare? ");
scanf("%d", &n;);
successione(n);
}
}

return 0;
}

```

---

## Esercizio 8: Primi di Mersenne (17 Febbraio 2023)

### Schema Logico

* **Numero Primo:** Verificato controllando l'assenza di divisori tra $2$ e $\sqrt{n}$.

* **Primo di Mersenne:** Deve essere primo **E** esprimibile come $2^p - 1$ con $p \ge 2$.
* **Funzione Potenza Custom:** Si scrive un ciclo `for` dedicato senza ricorrere a `math.h`.

### Codice C
```c
#include

int potenza(int base, int esponente) {

int res = 1;
for (int i = 0; i < esponente; i++) res *= base;
return res;
}

int numeroPrimo(int n) {
if (n < 2) return 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}

int numeroMersenne(int n) {
if (!numeroPrimo(n)) return 0;

int p = 2;
int val = 0;
while ((val = potenza(2, p) - 1) <= n) {
if (val == n) return 1;
p++;
}
return 0;
}

int main() {
int r;
do {
printf("Inserisci r > 1: ");
scanf("%d", &r;);
} while (r <= 1);

int curr = r + 1;
while (1) {
if (numeroMersenne(curr)) {
printf("%d primo di Mersenne\n", curr);
break; // Arresto alla prima occorrenza
} else if (numeroPrimo(curr)) {
printf("%d primo\n", curr);
} else {
printf("%d\n", curr);
}
curr++;
}

return 0;
}

```

---

## Esercizio 9: Numeri Felici e Infelici (30 Agosto 2021)

### Schema Logico

* **Sottosequenza:** Calcolare la somma dei quadrati delle cifre e memorizzare ogni termine in un array per tracciare le ripetizioni.
* **Arresto:** Se si raggiunge il valore `1` il numero è **felice**. Se si trova un numero già presente nell'array, è **infelice**.

### Codice C

```c
#include

int somma_quadrati_cifre(int n) {
int somma = 0;
while (n > 0) {
int cifra = n % 10;
somma += cifra * cifra;
n /= 10;
}
return somma;
}

int main() {
int n0;
printf("Inserisci un numero intero positivo: ");
scanf("%d", &n0;);

int sequenza[100];
int lungh = 0;
int corrente = n0;
int felice = -1; // 1 = felice, 0 = infelice

while (lungh < 100) {

corrente = somma_quadrati_cifre(corrente);
lungh++;

if (corrente == 1) {
felice = 1;
break;
}

// Controllo ciclo (numero gia' comparso)

for (int i = 0; i < lungh - 1; i++) {
if (sequenza[i] == corrente) {
felice = 0;
break;
}
}
if (felice == 0) break;

sequenza[lungh - 1] = corrente;
}

if (felice == 1) {
printf("Il numero %d e' FELICE. Lunghezza sequenza: %d\n", n0, lungh);
} else {
printf("Il numero %d e' INFELICE. Lunghezza sequenza: %d\n", n0, lungh);
}

return 0;
}

```

---

## Esercizio 10: Problema di Prouhet-Tarry-Escott (16 Febbraio 2021)

### Schema Logico

* Verificare che due vettori $U$ e $V$ di dimensione $n$ soddisfino l'uguaglianza $\sum u_i^m = \sum v_i^m$ per ogni grado $m$ da $1$ a $k$.

### Codice C

```c
#include

#define NMAX 100

long long potenza_int(int base, int esp) {

long long res = 1;
for (int i = 0; i < esp; i++) res *= base;
return res;
}

int main() {
int n, k;
int U[NMAX], V[NMAX];
printf("Inserisci dimensione n (<= %d) e grado k: ", NMAX);
scanf("%d %d", &n;, &k;);

printf("Inserisci %d elementi per U: ", n);

for (int i = 0; i < n; i++) scanf("%d", &U;[i]);

printf("Inserisci %d elementi per V: ", n);

for (int i = 0; i < n; i++) scanf("%d", &V;[i]);

int e_soluzione = 1;

for (int m = 1; m <= k; m++) {

long long sommaU = 0, sommaV = 0;
for (int i = 0; i < n; i++) {
sommaU += potenza_int(U[i], m);
sommaV += potenza_int(V[i], m);
}

if (sommaU != sommaV) {
e_soluzione = 0;
break;
}
}

if (e_soluzione) {
printf("Le due sequenze SONO una soluzione per il problema di grado %d.\n", k);
} else {
printf("Le due sequenze NON sono una soluzione.\n");
}

return 0;
}

```

---

## Esercizio 11: Controllo Sudoku Interattivo (8 Aprile 2021)

### Schema Logico

* Inserimento progressivo cella per cella.

* Dopo ogni inserimento, verificare la validità per **riga**, **colonna** e **sottomatrice $3 \times 3$**.
* Consentire al massimo 10 errori complessivi.

### Codice C

```c
#include

int valida(int sudoku[9][9], int r, int c, int val) {

// Controllo Riga e Colonna
for (int i = 0; i < 9; i++) {
if (i != c && sudoku[r][i] == val) return 0;
if (i != r && sudoku[i][c] == val) return 0;
}

// Controllo Sottomatrice 3x3

int startR = (r / 3) * 3;
int startC = (c / 3) * 3;

for (int i = startR; i < startR + 3; i++) {

for (int j = startC; j < startC + 3; j++) {
if ((i != r || j != c) && sudoku[i][j] == val) return 0;
}
}
return 1;
}

int main() {
int matricesudoku[9][9] = {0};
int errori = 0;

for (int r = 0; r < 9; r++) {

for (int c = 0; c < 9; c++) {
int val;
int OK = 0;

while (!OK) {
printf("[%d][%d] Inserisci valore (1-9): ", r, c);
scanf("%d", &val;);

if (val >= 1 && val <= 9 && valida(matricesudoku, r, c, val)) {

matricesudoku[r][c] = val;
OK = 1;
} else {
errori++;
printf("Mossa NON valida! Errori commessi: %d/10\n", errori);
if (errori >= 10) {
printf("Troppi errori! Programma terminato.\n");
return 0;
}
}
}
}
}

printf("Sudoku completato con successo!\n");

return 0;
}

```

---

## Esercizio 12: Insiemi Unione, Intersezione, Differenza (14 Giugno 2021)

### Schema Logico

* **Unione ($A \cup B$):** Copiare gli elementi di $A$, poi inserire gli elementi di $B$ che non compaiono già nell'unione.
* **Intersezione ($A \cap B$):** Inserire solo gli elementi di $A$ presenti anche in $B$.
* **Differenza ($A \setminus B$):** Inserire gli elementi di $A$ assenti in $B$.

### Codice C

```c
#include

#define N 5

int presente(int *arr, int len, int val) {

for (int i = 0; i < len; i++) {
if (arr[i] == val) return 1;
}
return 0;
}

int main() {
int A[N], B[N];

printf("Inserisci prima sequenza (%d elementi): ", N);

for (int i = 0; i < N; i++) scanf("%d", &A;[i]);

printf("Inserisci seconda sequenza (%d elementi): ", N);

for (int i = 0; i < N; i++) scanf("%d", &B;[i]);

// 1. UNIONE
int unione[2 * N], len_u = 0;
for (int i = 0; i < N; i++) {
if (!presente(unione, len_u, A[i])) unione[len_u++] = A[i];
}
for (int i = 0; i < N; i++) {
if (!presente(unione, len_u, B[i])) unione[len_u++] = B[i];
}
// 2. INTERSEZIONE
int inters[N], len_i = 0;
for (int i = 0; i < N; i++) {
if (presente(B, N, A[i]) && !presente(inters, len_i, A[i])) {
inters[len_i++] = A[i];
}
}

// 3. DIFFERENZA (A \ B)
int diff[N], len_d = 0;
for (int i = 0; i < N; i++) {
if (!presente(B, N, A[i]) && !presente(diff, len_d, A[i])) {
diff[len_d++] = A[i];
}
}

// Stampa Risultati
printf("\nUnione: ");
if (len_u == 0) printf("VUOTO");
else for (int i = 0; i < len_u; i++) printf("%d ", unione[i]);

printf("\nIntersezione: ");
if (len_i == 0) printf("VUOTO");
else for (int i = 0; i < len_i; i++) printf("%d ", inters[i]);

printf("\nDifferenza: ");
if (len_d == 0) printf("VUOTO");
else for (int i = 0; i < len_d; i++) printf("%d ", diff[i]);
printf("\n");

return 0;
}

```

---

## Esercizio 13: Generator e Self-Numbers (16 Febbraio 2022)

### Schema Logico

* Un generatore $g$ per $n$ soddisfa la relazione $g + D(g) = n$, dove $D(g) < n$.
* È sufficiente verificare tutti i valori di $g$ nell'intervallo $[1, n-1]$. Se nessuno soddisfa la relazione, $n$ è un **self-number**.

### Codice C

```c
#include

int somma_cifre(int g) {
int somma = 0;
while (g > 0) {
somma += g % 10;
g /= 10;
}
return somma;
}

int main() {
int n;
do {
printf("Inserisci un numero positivo n: ");
scanf("%d", &n;);
} while (n <= 0);

int generatore = -1;

for (int g = 1; g < n; g++) {

if (g + somma_cifre(g) == n) {
generatore = g;
break;
}
}

if (generatore != -1) {
printf("Il generatore di %d e' %d\n", n, generatore);
} else {
printf("%d e' un self-number (non possiede generatore)\n", n);
}

return 0;
}

```

---

## Esercizio 14: Validazione Email senza string.h (26 Gennaio 2022)

### Schema Logico

* Si scorre la stringa manualmente con un ciclo `while` o `for`.

* **Regole di validità:**
1. Presenza di esattamente un carattere `@`.
2. Presenza di esattamente un punto `.` collocato dopo la `@`.
3. Almeno un carattere prima di `@`.
4. Almeno un carattere tra `@` e `.`.
5. Almeno un carattere dopo `.`.

### Codice C

```c
#include

int e_valida(char *email) {

int idx_at = -1;
int idx_dot = -1;
int num_at = 0;
int num_dot_after_at = 0;
int len = 0;

while (email[len] != '\0') {

if (email[len] == '@') {
num_at++;
idx_at = len;
}
len++;
}

if (num_at != 1 || idx_at == 0) return 0; // Regole su '@' e caratteri precedenti

for (int i = idx_at + 1; i < len; i++) {

if (email[i] == '.') {
num_dot_after_at++;
idx_dot = i;
}
}

if (num_dot_after_at != 1) return 0;
if (idx_dot == idx_at + 1) return 0; // Nessun carattere tra '@' e '.'
if (idx_dot == len - 1) return 0; // Nessun carattere dopo '.'

return 1;
}

int main() {
char email[30];
int tentativi = 0;

while (tentativi < 5) {

printf("Inserisci indirizzo email: ");
scanf("%s", email);
if (e_valida(email)) {
printf("Indirizzo email VALIDO!\n");
return 0;
} else {
tentativi++;
printf("Indirizzo ERRATO. Tentativi rimasti: %d\n", 5 - tentativi);
}
}

printf("Raggiunto limite di errori. Uscita dal programma.\n");

return 0;
}

```

---

## Esercizio 15: Vettori Ortogonali (12 Settembre 2022)

### Schema Logico

1. Generare un array $A$ di valori distinti compresi nell'intervallo $[LB, UB]$.

2. Calcolare il prodotto scalare $\sum A[i] \cdot B[i]$. Se uguale a $0$, i vettori sono ortogonali.
3. Ripetere l'inserimento di $B$ fino all'inserimento del vettore nullo (tutti zero).

### Codice C

```c
#include
#include
#include

#define NUM 5
#define LB 2
#define UB 14

int main() {
srand(time(NULL));
int A[NUM], B[NUM];

// Generazione di A con elementi distinti

for (int i = 0; i < NUM; i++) {
int val, gia_presente;
do {
gia_presente = 0;
val = (rand() % (UB - LB + 1)) + LB;
for (int j = 0; j < i; j++) {
if (A[j] == val) { gia_presente = 1; break; }
}
} while (gia_presente);
A[i] = val;
}

while (1) {
printf("\nInserisci %d elementi per B: ", NUM);
int tutto_zero = 1;

for (int i = 0; i < NUM; i++) {

scanf("%d", &B;[i]);
if (B[i] != 0) tutto_zero = 0;
}

if (tutto_zero) break; // Condizione di uscita

int prod_scalare = 0;
for (int i = 0; i < NUM; i++) {
prod_scalare += A[i] * B[i];
}

if (prod_scalare == 0) {
printf("I due vettori SONO ortogonali!\n");
} else {
printf("NON ortogonali (Prodotto scalare = %d)\n", prod_scalare);
}
}

return 0;
}

```

---

## Esercizio 16: Ricettario Intelligente (30 Agosto 2021)

### Schema Logico

* **Strutture:** `ingrediente` e `ricetta`.

* **Calcolo Prezzo:** $\sum \text{quantita}[i] \times \text{prezzo\_al\_kg} / 10.0$ (conversione da hg a kg).
* **Ricetta Massima:** Ricerca del massimo relativo all'uso di un singolo ingrediente.

### Codice C

```c
#include
#include

struct ingrediente {
char nome[15];
float calorie_kg;
float prezzo_kg;
};

struct ricetta {
char titolo[30];
char ingredienti_necessari[20][15];
float quantita[20]; // in hg
int tempo;
int difficolta;
};

struct ingrediente ingredienti[100];

struct ricetta ricette[20];

int cercaPosizioneRicetta(char nomericetta[30]) {

for (int i = 0; i < 20; i++) {
if (strcmp(ricette[i].titolo, nomericetta) == 0) return i;
}
return -1;
}

void stampaRicettaDaPosizione(int p) {
printf("Ricetta: %s | Tempo: %d min | Difficolta': %d\n", ricette[p].titolo, ricette[p].tempo, ricette[p].difficolta);
printf("Lista ingredienti:\n");
for (int i = 0; i < 20; i++) {
if (ricette[p].quantita[i] > 0) {
printf("- %s %.2f hg\n", ricette[p].ingredienti_necessari[i], ricette[p].quantita[i]);
}
}
}

float prezzoRicetta(int p) {
float totale = 0.0;
for (int i = 0; i < 20; i++) {
if (ricette[p].quantita[i] > 0) {
for (int j = 0; j < 100; j++) {
if (strcmp(ricette[p].ingredienti_necessari[i], ingredienti[j].nome) == 0) {
totale += (ricette[p].quantita[i] / 10.0) * ingredienti[j].prezzo_kg;
}
}
}
}
return totale;
}
void stampaRicettaDaPuntatore(struct ricetta *r) {
if (r == NULL) return;
printf("Ricetta: %s | Tempo: %d min | Difficolta': %d\n", r->titolo, r->tempo, r->difficolta);
}

struct ricetta* ricettaMassima(char nomeringrediente[15]) {

int max_idx = -1;
float max_q = -1.0;

for (int i = 0; i < 20; i++) {

for (int k = 0; k < 20; k++) {
if (strcmp(ricette[i].ingredienti_necessari[k], nomeringrediente) == 0) {
if (ricette[i].quantita[k] > max_q) {
max_q = ricette[i].quantita[k];
max_idx = i;
}
}
}
}
return (max_idx != -1) ? &ricette;[max_idx] : NULL;
}

int main() {
char nome_r[30];
printf("Inserisci nome ricetta: ");
scanf("%s", nome_r);

int pos = cercaPosizioneRicetta(nome_r);

if (pos != -1) {
stampaRicettaDaPosizione(pos);
printf("Prezzo totale: %.2f euro\n", prezzoRicetta(pos));
} else {
printf("Ricetta non trovata!\n");
}

char nome_i[15];
printf("\nInserisci nome ingrediente: ");
scanf("%s", nome_i);

struct ricetta *ric_max = ricettaMassima(nome_i);

if (ric_max != NULL) {
printf("Ricetta con il maggior uso di %s:\n", nome_i);
stampaRicettaDaPuntatore(ric_max);
}

return 0;
}

```

---

## Esercizio 17: Prenotazione Multisala (12 Luglio 2021)

### Schema Logico

* **Visualizzazione:** Stampa la dicitura `ESAURITI` se `num_posti_liberi == 0`.

* **Prenotazione:** Controlla che i posti richiesti siano $\le$ posti liberi, poi aggiorna il valore per indirizzo.

### Codice C

```c
#include
#include

#define N 5

struct sala {
char nome_sala[6];
int num_posti_totali;
int num_posti_liberi;
char film[20];
};

struct sala multisala[N];

void stampa_dettaglio_sale() {
for (int i = 0; i < N; i++) {
printf("Sala %s - Posti tot: %d - Posti liberi: ", multisala[i].nome_sala, multisala[i].num_posti_totali);
if (multisala[i].num_posti_liberi == 0) {
printf("ESAURITI");
} else {
printf("%d", multisala[i].num_posti_liberi);
}
printf(" - Film: %s\n", multisala[i].film);
}
}

void prenotazione(char sala_scelta[6], int *posti) {

for (int i = 0; i < N; i++) {
if (strcmp(multisala[i].nome_sala, sala_scelta) == 0) {
if (multisala[i].num_posti_liberi >= *posti) {
multisala[i].num_posti_liberi -= *posti;
printf("PRENOTAZIONE EFFETTUATA!\n");
} else {
printf("Posti insufficienti! Disponibili solo: %d\n", multisala[i].num_posti_liberi);
}
return;
}
}
printf("Sala non trovata.\n");
}

void sale_comuni(char nome_film[20]) {

printf("Sale in cui si proietta %s:\n", nome_film);
for (int i = 0; i < N; i++) {
if (strcmp(multisala[i].film, nome_film) == 0) {
printf("- Sala %s\n", multisala[i].nome_sala);
}
}
}

struct sala sala_piu_piena() {

int idx_min = 0;
for (int i = 1; i < N; i++) {
if (multisala[i].num_posti_liberi < multisala[idx_min].num_posti_liberi) {
idx_min = i;
}
}
return multisala[idx_min];
}

int main() {
int scelta = -1;

while (scelta != 0) {
printf("\n*** MENU MULTISALA ***\n1. Elenco sale\n2. Prenota\n3. Cerca film\n4. Sala piu' piena\n0. Esci\nScelta: ");
scanf("%d", &scelta;);

if (scelta == 1) stampa_dettaglio_sale();
else if (scelta == 2) {
int tot_liberi = 0;
for (int i = 0; i < N; i++) tot_liberi += multisala[i].num_posti_liberi;

if (tot_liberi == 0) {
printf("Tutte le sale sono esaurite! Prenotazioni bloccate.\n");
} else {
char s[6]; int p;
printf("Nome sala e posti da prenotare: ");
scanf("%s %d", s, &p;);
prenotazione(s, &p;);
}
} else if (scelta == 3) {
char f[20];
printf("Nome film: ");
scanf("%s", f);
sale_comuni(f);
} else if (scelta == 4) {
struct sala piena = sala_piu_piena();
printf("La sala piu' piena e' %s (%d posti liberi)\n", piena.nome_sala, piena.num_posti_liberi);
}
}

return 0;
}

```

---

## Esercizio 18: Gestione Orario Corso di Laurea (14 Giugno 2021)

### Schema Logico

* Matrice `orario[5][10]` (5 giorni x 10 ore).

* Validazione vincolo docente: impedire l'assegnazione di un'ora nel giorno in cui l'attributo `libero` del docente corrisponde al giorno corrente ($1 = \text{Lunedì}, \dots$).

### Codice C

```c
#include

#define N 4
#define M 4

struct insegnamento {
char denominazione[15];
int h_req;
int id;
};

struct prof {
char cognome[15];
int libero; // 1 = Lunedi', ...
int id_insegnamento;
};

int orario[5][10];

struct insegnamento inserisciInsegnamento() {

struct insegnamento ins;
printf("Denominazione, Ore richieste, ID: ");
scanf("%s %d %d", [Link], &ins.h;_req, &[Link];);
return ins;
}

struct prof inserisciProf(struct prof profs[], int attuali) {

struct prof p;
int ok = 0;

while (!ok) {
printf("Cognome, giorno libero (1-5), ID insegnamento: ");
scanf("%s %d %d", [Link], &[Link];, &[Link];_insegnamento);

ok = 1;
for (int i = 0; i < attuali; i++) {
if (profs[i].id_insegnamento == p.id_insegnamento) {
printf("Insegnamento gia' assegnato ad un altro docente! Riprova.\n");
ok = 0;
break;
}
}
}
return p;
}

void stampaRecap() {
int totale_ore = 0;
int ore_giorno[5] = {0};

for (int g = 0; g < 5; g++) {

for (int h = 0; h < 10; h++) {
if (orario[g][h] != 0) {
ore_giorno[g]++;
totale_ore++;
}
}
}

int max_giorno = 0;
for (int g = 1; g < 5; g++) {
if (ore_giorno[g] > ore_giorno[max_giorno]) max_giorno = g;
}

printf("Media ore occupate = %.1f\n", totale_ore / 5.0);

printf("Indice giorno piu' occupato = %d\n", max_giorno);
printf("Indici giorni liberi = ");
for (int g = 0; g < 5; g++) {
if (ore_giorno[g] == 0) printf("%d ", g);
}
printf("\n");
}

int main() {
struct insegnamento insegnamenti[N];
struct prof professori[M];

for (int i = 0; i < N; i++) insegnamenti[i] = inserisciInsegnamento();

for (int i = 0; i < M; i++) professori[i] = inserisciProf(professori, i);

// Inserimento lezioni
for (int i = 0; i < N; i++) {
int id_curr = insegnamenti[i].id;
int giorno_vietato = -1;

for (int k = 0; k < M; k++) {

if (professori[k].id_insegnamento == id_curr) {
giorno_vietato = professori[k].libero - 1; // Conversione a indice 0-4
break;
}
}

printf("Inserisci le %d ore per insegnamento ID %d:\n", insegnamenti[i].h_req, id_curr);

for (int h_i = 0; h_i < insegnamenti[i].h_req; h_i++) {
int g, h;
do {
printf("Coppia giorno (0-4) ed ora (0-9): ");
scanf("%d %d", &g;, &h;);
if (g == giorno_vietato) {
printf("Il professore e' LIBERO il giorno %d! Inserimento non valido.\n", g + 1);
}
} while (g == giorno_vietato);

orario[g][h] = id_curr;
}
}

stampaRecap();
return 0;
}

```

---

## Esercizio 19: App Serie TV Mania (8 Aprile 2021)

### Schema Logico

* **Maratona:** Calcolare i minuti totali come $\text{stagioni} \times \text{episodi} \times \text{durata}$ e convertirli in $Ore = M / 60$ e $Minuti = M \% 60$.
* **Playlist:** Uso di `strstr` per verificare la presenza della sottostringa `key` nel nome della serie.

### Codice C

```c
#include
#include

struct serietv {
char nome[20];
int stagioni;
int episodi_per_stagione;
int durata_episodio;
};

struct serietv elenco[100];

int num_serie = 0;

struct serietv inserisciSerieTv() {

struct serietv s;
do {
printf("Nome, Stagioni, Episodi/Stagione, Durata episodio (min): ");
scanf("%s %d %d %d", [Link], &[Link];, &[Link];_per_stagione, &[Link];_episodio);
} while ([Link] <= 0 || s.episodi_per_stagione <= 0 || s.durata_episodio <= 0);
return s;
}

void consigliaMaratona() {
if (num_serie == 0) return;

int max_idx = 0;
int max_ep = elenco[0].stagioni * elenco[0].episodi_per_stagione;

for (int i = 1; i < num_serie; i++) {

int tot_ep = elenco[i].stagioni * elenco[i].episodi_per_stagione;
if (tot_ep > max_ep) {
max_ep = tot_ep;
max_idx = i;
}
}

int minuti_totali = max_ep * elenco[max_idx].durata_episodio;

int ore = minuti_totali / 60;
int minuti = minuti_totali % 60;

printf("Serie consigliata: %s (%d episodi totali)\n", elenco[max_idx].nome, max_ep);

printf("Tempo necessario: %d ore e %d minuti\n", ore, minuti);
}

void creaPlaylist(char key[10]) {

printf("Playlist per la parola chiave '%s':\n", key);
for (int i = 0; i < num_serie; i++) {
if (strstr(elenco[i].nome, key) != NULL) {
printf("- %s\n", elenco[i].nome);
}
}
}

int main() {
int scelta = -1;

while (scelta != 0) {
printf("\n**** App serietv-mania ****\n1 - Nuova serie\n2 - Consigliami maratona\n3 - Crea playlist\n0 - Esci\nScelta: ");
scanf("%d", &scelta;);

if (scelta == 1) {
elenco[num_serie++] = inserisciSerieTv();
} else if (scelta == 2) {
consigliaMaratona();
} else if (scelta == 3) {
char k[10];
printf("Inserisci parola chiave: ");
scanf("%s", k);
creaPlaylist(k);
}
}

return 0;
}

```

---

## Esercizio 20: Gestione Appuntamenti Clinica Medica (16 Febbraio 2021)

### Schema Logico

* Collegare la struttura `paziente` e la struttura `appuntamento` tramite il `codice_fiscale`.

* Verificare il codice di esenzione per applicare sconti o esenzioni sul costo della prestazione.

### Codice C

```c
#include
#include

struct timestamp {
int giorno, mese, anno, ora, minuti;
};

struct paziente {
char nome[16];
char cognome[16];
char cf[16];
int exe; // Esenzione
};

struct appuntamento {
char cf_paziente[16];
struct timestamp ts;
char ambulatorio[15];
float costo;
};

struct paziente pazienti[100];

struct appuntamento appuntamenti[100];
int num_p = 0, num_a = 0;

void stampaAppuntamentiPaziente(char cf[16]) {

printf("Appuntamenti per il Paziente CF: %s\n", cf);
for (int i = 0; i < num_a; i++) {
if (strcmp(appuntamenti[i].cf_paziente, cf) == 0) {
printf("Data: %02d/%02d/%d %02d:%02d | Amb: %s | Costo: %.2f euro\n",
appuntamenti[i].[Link], appuntamenti[i].[Link], appuntamenti[i].[Link],
appuntamenti[i].[Link], appuntamenti[i].[Link],
appuntamenti[i].ambulatorio, appuntamenti[i].costo);
}
}
}

int main() {
// Dimostrazione basica di inserimento
printf("Sistema di gestione clinica avviato.\n");
return 0;
}

```