Cicli annidati e array in terza informatica: cosa cambia

Metà settembre 2026, la scuola è ripartita da un paio di settimane e nelle terze degli istituti tecnici, articolazione Informatica, il programma di Informatica sta ricominciando da un punto preciso: selezione e cicli, poi array, poi funzioni e ricorsione. La prima verifica seria arriva fra sei e otto settimane, quasi sempre fra fine ottobre e metà novembre, e cambia formato rispetto al biennio: non più solo scritto teorico, ma prova pratica al PC insieme allo scritto teorico.

È questo cambio di formato, più del contenuto in sé, a cogliere di sorpresa chi si prepara studiando solo la teoria a memoria. In prima e in seconda bastava capire come funziona un if o un ciclo isolato. In terza il programma chiede di progettare un programma che risolve un problema con più dati insieme, e la verifica lo controlla facendoti scrivere codice al computer, non solo descriverlo su carta.

Cosa chiede davvero la verifica di terza

Nel biennio Informatica si muove su variabili, tipi, operatori e strutture di controllo semplici: un problema, una sequenza di istruzioni, al massimo un ciclo isolato. In terza il salto è netto, perché il docente introduce array e funzioni proprio per gestire più dati insieme e per dividere un problema in pezzi più piccoli. La prova pratica che arriva fra fine ottobre e metà novembre chiede in genere tre cose insieme:

1. un programma che usa un ciclo annidato su una struttura con più righe di dati — una tabella, una matrice, un elenco con più campi;
2. un array riempito, letto e modificato attraverso una funzione a cui viene passato come parametro;
3. spesso una funzione ricorsiva semplice, come il fattoriale, per introdurre l’idea che una funzione può richiamare se stessa.

Lo scritto teorico che accompagna la prova pratica chiede di seguire il programma riga per riga: quante volte gira un ciclo annidato, cosa contiene l’array in un certo punto dell’esecuzione, cosa restituisce una funzione con certi argomenti. È lì che si vede chi ha solo copiato la sintassi da un esempio e chi ha davvero capito cosa fa il programma mentre gira.

Nello stesso periodo, in Sistemi e reti, arrivano anche le conversioni tra base binaria ed esadecimale: è un argomento diverso da questo — qui ci concentriamo su cicli, array e funzioni — ma conviene saperlo, perché gli errori di distrazione lì (una cifra dimenticata, una base scambiata) sono lo stesso tipo di errore che vediamo qui su indici e limiti dei cicli.

Gli errori che costano punti

1. Confondere il numero di iterazioni con l’indice finale. Un ciclo for (int i = 0; i < n; i++) gira esattamente n volte, con i che va da 0 a n-1. L’errore più comune è scrivere i <= n: il ciclo gira una volta di più e, su un array dichiarato con n elementi, legge o scrive fuori dai limiti. È l’errore classico di off-by-one, e in C non dà nessun avviso a tempo di compilazione: il programma compila, a volte esegue senza crashare, e il risultato è comunque sbagliato.

2. Ciclo annidato con gli indici scambiati. Su una matrice n × m, scrivere matrice[j][i] invece di matrice[i][j] compila ed esegue senza errori — ma il risultato è sbagliato, perché stai leggendo colonna al posto di riga. Prima di scrivere il ciclo interno, conviene fissare per iscritto cosa rappresentano i e j (riga o colonna) e restare fedeli a quella scelta per tutto l’esercizio.

3. Passare un array a una funzione e aspettarsi che resti intatto. In C un array passato come parametro non viene copiato: la funzione lavora sull’array originale del chiamante. Chi si aspetta che l’array resti come prima dopo la chiamata perde punti sia nella prova pratica sia nello scritto teorico, dove spesso si chiede esplicitamente “cosa contiene l’array dopo questa chiamata?”.

4. Caso base della ricorsione assente o sbagliato. Una funzione ricorsiva senza una condizione di uscita chiara richiama se stessa senza fermarsi, finché il programma non si blocca per esaurimento della memoria dedicata alle chiamate (stack overflow). L’errore più insidioso non è l’assenza totale del caso base, ma un caso base che scatta al valore sbagliato — per esempio fermarsi a n == 1 in una sequenza che, per come è scritta la chiamata ricorsiva, non incontra mai quel valore.

Il metodo, passo per passo

Prima di scrivere codice per un esercizio con ciclo annidato, array o ricorsione, conviene seguire lo stesso ordine ogni volta:

1. Scrivere a parole cosa deve fare il programma, in una frase, prima del codice. Se non riesci a dirlo a parole, non lo scriverai giusto in C.
2. Disegnare la struttura dati su carta: per un array, una fila di caselle numerate da 0; per una matrice, una griglia con righe e colonne etichettate.
3. Scrivere l’intestazione del ciclo per ultima, non per prima: decidi da dove parte l’indice e dove deve fermarsi, poi scrivi for di conseguenza — non il contrario.
4. Per ogni funzione, scrivere prima la firma (tipo di ritorno, nome, parametri) e chiedersi: deve modificare i dati del chiamante o restituire un risultato nuovo? La risposta decide se passare l’array per modificarlo sul posto o se calcolare e restituire un valore.
5. Per la ricorsione, scrivere il caso base prima del caso generale, e verificare a mano, con un valore piccolo, che la sequenza di chiamate arrivi davvero a quel caso base.

Tre esercizi svolti

Esercizio 1 — ciclo annidato: somma per riga di una matrice.

Data una matrice 3×4 di interi, scrivere un programma che calcola e stampa la somma degli elementi di ciascuna riga.

#include <stdio.h>

#define RIGHE 3
#define COLONNE 4

int main(void) {
    int matrice[RIGHE][COLONNE] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    for (int i = 0; i < RIGHE; i++) {
        int somma = 0;
        for (int j = 0; j < COLONNE; j++) {
            somma += matrice[i][j];
        }
        printf("Somma riga %d: %d\n", i, somma);
    }

    return 0;
}

Il ciclo esterno scorre le righe (i da 0 a RIGHE-1), il ciclo interno scorre le colonne di quella riga (j da 0 a COLONNE-1) e accumula in somma. Il dettaglio che chi sbaglia questo esercizio salta quasi sempre è che somma va azzerata a ogni nuova riga, dentro il ciclo esterno: se la dichiari fuori da entrambi i cicli, ottieni una somma cumulativa su tutta la matrice invece che una somma per riga.

Esercizio 2 — array e funzione: trovare la posizione del massimo.

Scrivere una funzione che riceve un array di interi e la sua lunghezza, e restituisce l’indice dell’elemento massimo.

#include <stdio.h>

int indice_massimo(int arr[], int lunghezza) {
    int indice = 0;
    for (int i = 1; i < lunghezza; i++) {
        if (arr[i] > arr[indice]) {
            indice = i;
        }
    }
    return indice;
}

int main(void) {
    int voti[5] = {6, 8, 5, 9, 7};
    int i_max = indice_massimo(voti, 5);

    printf("Il massimo e' %d, in posizione %d\n", voti[i_max], i_max);
    return 0;
}

Due scelte da notare, perché sono il tipo di domande che fa lo scritto teorico: il ciclo parte da i = 1, non da 0, perché la posizione 0 è già il candidato di partenza (indice = 0, quindi confrontarla con se stessa sarebbe inutile); e la funzione restituisce l’indice, non il valore massimo, perché così il chiamante ha anche l’informazione di posizione, non solo il numero. Con voti = {6, 8, 5, 9, 7} il massimo è 9, in posizione 3.

Esercizio 3 — ricorsione: il fattoriale con il caso base corretto.

#include <stdio.h>

long fattoriale(int n) {
    if (n == 0) {
        return 1;
    }
    return n * fattoriale(n - 1);
}

int main(void) {
    for (int n = 0; n <= 5; n++) {
        printf("%d! = %ld\n", n, fattoriale(n));
    }
    return 0;
}

Il caso base è n == 0, che restituisce 1 senza fare altre chiamate. Ogni chiamata successiva riduce n di uno e si affida al risultato della chiamata più piccola: fattoriale(3) chiama fattoriale(2), che chiama fattoriale(1), che chiama fattoriale(0), che finalmente restituisce 1 senza richiamare nessuno — a quel punto le chiamate si “srotolano” all’indietro, moltiplicando: 1, poi 1×1=1, poi 2×1=2, poi 3×2=6. Se il caso base fosse scritto come n == 1 invece di n == 0, la chiamata fattoriale(0) non incontrerebbe mai quella condizione e il programma continuerebbe a decrementare n senza fermarsi.

Per allenarti su logica, cicli e strutture dati prima della prova, in /simulazioni/ trovi le verifiche organizzate per materia e argomento: su informatica non abbiamo ancora una simulazione dedicata a cicli e array, e te lo dico apertamente invece di linkarti qualcosa che non c’entra. Nel frattempo la pratica migliore resta scrivere ed eseguire questi esercizi al PC, esattamente come nella prova.

Come lavoriamo in lezione

Con chi arriva bloccato su cicli annidati o array, il primo lavoro non è “spiegare la sintassi meglio”: è far disegnare la struttura dati su carta prima di scrivere codice, e far eseguire il programma a mano, riga per riga, prima di lanciarlo al PC. È lo stesso metodo che uso con chi affronta i puntatori in C più avanti nel percorso — lì il modello mentale conta ancora di più, perché non c’è più nessuno che ti protegge dagli errori di indice. Se vuoi anche esercitarti in autonomia con una sintassi più permissiva prima di tornare al rigore del C, la roadmap di Python in 6 settimane copre cicli, liste e funzioni con lo stesso tipo di logica.

Le lezioni di informatica sono online e uno a uno: si parte da dove ti sei bloccato — spesso proprio un ciclo annidato o una funzione che non fa quello che pensavi — e si costruisce da lì. Si parte con una chiamata conoscitiva gratuita di 30 minuti, oppure con una lezione di prova a 20 €; una lezione singola è 40 €, il pacchetto da 10 ore è 360 € (36 €/h). Pagamento sempre offline — bonifico, Satispay, PayPal, carta, Apple Pay o Revolut.

Se vuoi parlarne prima di prenotare, siamo su /contatti/.