1Esame
Regole ufficiali dalla presentazione del corso (slide 29-36):
prova scritta 30% del voto questionario a risposta multipla e/o aperta su tutto il programma,
più esercizi di comprensione e analisi di (parti di) programmi
prova calcolatore 70% del voto progettare un programma piccolo in un ambiente come quello del lab
(Dev-C++ sui PC di B106)
minimo serve un punteggio minimo in entrambe le parti per la sufficienza
orale non previsto, a discrezione del docente: lo studente non può chiederlo
appelli 2 sessioni, 5 appelli: gennaio, febbraio | giugno, luglio, settembre
- Iscrizione: solo se si è sicuri di presentarsi. Ci si può cancellare fino a due giorni prima. Assenze solo per giustificati motivi; assenze consecutive non giustificate non vengono tollerate.
- All’esame niente materiale didattico, né cartaceo né digitale. Il plagio (codice o scritto) viene punito e segnalato alla commissione disciplinare.
- Negli ultimi anni le due prove sono state: teorica su carta, 40 min, 12 punti, minimo 6; calcolatore 70 min, 21 punti, minimo 10; totale 33 (vedi Esami passati). Il 12/21 è circa il 36/64, non esattamente il 30/70 della slide: va controllato sul testo del primo appello.
- La leggibilità del codice fa parte del voto in entrambe le prove. Al calcolatore il codice commentato non viene corretto: una funzione che non compila e che commenti per far girare il resto vale zero.
- Le soluzioni ufficiali sono progetti Dev-C++ con
dati.h,dati.cpp,main.cpp: allenarsi lì, non solo su onlinegdb.
1.1Prove intermedie 2026/27 (parte teorica)
(slide 34-35)
1a prova giovedì 5 novembre 2026 prima parte del programma
2a prova lunedì 21 dicembre 2026 seconda parte
- Valgono come prova teorica dell’esame. Non sono obbligatorie e sono in aggiunta ai 5 appelli. Il prof le raccomanda molto.
- Chi non supera la prima non può fare la seconda.
- Chi non supera la seconda fa l’esame intero negli appelli, come tutti.
- Chi le supera entrambe negli appelli del 2027 fa solo la parte al calcolatore.
- Il 5/11 alle 15:30 c’è anche la prova intermedia di GAL (Povo 1, A104-A106, 90 min, vedi Geometria e Algebra Lineare). L’orario della provetta di Prog non è sulla slide: va controllato sul sito del corso.
- Il piano consigliato dal prof (slide 40-41): frequentare, preparare e passare le due provette, poi puntare all’appello di gennaio (meglio) o febbraio.
1.2Ripasso della prima provetta
Tutti gli argomenti fino ai puntatori (deck 6.1) in una pagina, con metodi, trappole e crocette con output verificato: Ripasso provetta.
1.3Simulazioni della prima provetta
Il modello è la prima prova teorica del 22/10/2024, l’unica negli archivi: 50 minuti, 6 punti, sei domande (SI/NO sui puntatori, output esatto di cicli, figura con i cicli, somma fra basi, tavola di verità, algoritmo su un array di struct). La cartella “1° Prova Teorica” su Moodle per ora è vuota. Simulazioni sullo stesso modello, a tempo e con correzione: Simulazione provetta 1, Simulazione provetta 2, Simulazione provetta 3, Simulazione provetta 4 (la 4 è la più difficile).
1.4Corso
- Lezioni a Povo 2, aula B109: giovedì 10:30-13:30, venerdì 13:30-15:30. Laboratorio in B106: mercoledì 13:30-15:30 (A-L) e 15:30-17:30 (M-Z), venerdì 8:30-10:30 (M-Z) e 10:30-12:30 (A-L).
- Esercitatori Pierluigi Roberti e Carmelo Ferrante. Domande sul corso a programmazione1gr@unitn.it, con oggetto
Lab - argomento,Lecture - argomentooAltro - argomento. - Testo consigliato: Ceri, Mandrioli, Sbattella, Cremonesi, Cugola, Informatica: arte e mestiere, McGraw-Hill, 4a ed. Copre il programma fino alle liste (fine novembre).
- Programma per mesi (slide 14): settembre-ottobre algoritmi, sintassi del C, memoria e puntatori, array, funzioni; novembre-dicembre tipi di dato astratto, liste, code, pile, ordinamento e ricerca, alberi binari, complessità.
Come si prende 30 (dettagli e conteggi in Esami passati):
- Teorica a errore zero sulle due domande fisse. BST da sequenza con cammino, altezza e le quattro visite esce in 16 prove su 18; il tracing “scrivi l’output esatto”, spesso sulle cifre della matricola, in 15 su 18. Sono metà della teorica e sono meccaniche: si perdono solo per distrazione. Per il tracing, tabella delle variabili riga per riga come nelle note di questo corso.
- Scheletro A-F del calcolatore automatizzato. Da dieci anni la prova pratica ha la stessa forma: struct con costruttori in
dati.h/dati.cpp(A),mainda completare (B), generazione del dato con input controllato e valori casuali (C), inserimento nel contenitore (D), stampa (E), svuotamento con salvataggio filtrato su file (F). Cambia solo il dominio. L’obiettivo è scrivere A-E senza pensarci e tenere la testa per F e per il contenitore del giorno (coda circolare, array di liste, stack). - Ordine di preparazione che segue il corso:
ife tavole di verità, cicli e quadrati , array e matrici, funzioni, struct, file,new/delete, liste, code e stack, BST e complessità. - Temi a tempo da dicembre: un tema completo a settimana, teorica in 40 minuti e calcolatore in 70 su un progetto Dev-C++ vero, compilando spesso. Gli ultimi due anni sono il materiale più fedele.
2Lezioni
Le date delle lezioni dopo l’11 settembre non si ricavano dal materiale: il quaderno arriva alla slide 51 del deck 2.2. Il resto del 2.2, il 3.1 e il 3.2 sono stati fatti a lezione a settembre, il 3.3 fra settembre e ottobre, il 4.1 (tutto, matrici comprese) a ottobre, poi 4.2, 4.3, 4.4, 5.1, 6.1 e 6.2 (tutti, interi) sempre a ottobre, e l’8.1 (tutto) a ottobre dopo il 6.2. Il deck 2.2 è stato ricaricato a fine settembre con una slide in più (esercizio sull’assegnazione a catena, slide 64-65): le pagine dopo la 54 sono rinumerate.
| # | Data | Argomento | Slide | Nota |
|---|---|---|---|---|
| 01 | 2026-09-10 | Introduzione al corso, algoritmi | 1.1 | Introduzione al corso e algoritmi |
| 02 | 2026-09-11 | Architettura hardware e software | 1.2 | Architettura hardware e software di un calcolatore |
| 03 | 2026-09-11 | Il linguaggio C, fino all’assegnazione | 2.2 (slide 1-56, 64-65) | Il Linguaggio C |
| set | Espressioni, operatori, costanti, ASCII | 2.2 (slide 57-76) | Espressioni, operatori e costanti | |
| set | Algebra di Boole | 3.1 | Algebra di Boole | |
| set | if, if-else, ?:, blocchi, precedenze | 3.2 (slide 1-39) | Istruzioni condizionali | |
| set | while: somma, sentinella, MCD | 3.2 (slide 40-57) | Ciclo while ed esempi | |
| set | getchar, putchar, EOF | 3.2 (slide 58-68) | Input e output di caratteri | |
| set | moltiplicazione, scala a passi 1-2-3 | 3.2 (slide 69-97) | Ciclo while ed esempi | |
| set/ott | for, do-while, break, continue, Böhm-Jacopini | 3.3 (slide 3-15, 32-37) | Cicli for e do-while | |
| set/ott | switch, fall-through, conteggio cifre | 3.3 (slide 16-31) | Switch | |
| ott | array: dichiarazione, accesso, inizializzazione, esempi, VLA | 4.1 (slide 2-52, 74-92) | Array | |
| ott | matrici: memoria per righe, simmetrica, trasposta, magiche | 4.1 (slide 53-73, 93-100) | Matrici e array multidimensionali | |
| ott | stringhe: array di char, ‘\0’, %s, scanf | 4.2 (tutto) | Stringhe | |
| ott | informazione e dati, interi, CA2, virgola mobile, ASCII | 4.3 (tutto) | Rappresentazione dell’informazione | |
| ott | basi 2, 8, 16: conversioni e aritmetica binaria | 4.4 (tutto) | Rappresentazione dell’informazione | |
| ott | tipi predefiniti, sizeof, conversioni, cast, Leibniz | 5.1 (slide 3-33, 77-102) | Tipi di dati e conversioni | |
| ott | struct, typedef, enum | 5.1 (slide 34-76) | Struct, typedef ed enum | |
| ott | puntatori: & e *, aliasing, ->, aritmetica, const | 6.1 (tutto) | Puntatori | |
| ott | funzioni: sottoprogrammi, definizione, return, prototipi, pila delle chiamate, visibilità, static | 6.2 (slide 4-90, 132-149) | Funzioni | |
| ott | passaggio per valore e per indirizzo, swap, struct e array come parametri, const | 6.2 (slide 91-131, 150-154) | Passaggio dei parametri | |
| ott | ricorsione: caso base e induttivo, pila dei record, Hanoi, Fibonacci, memoization | 8.1 (tutto, slide 1-122) | Ricorsione |
3Argomenti
Nell’ordine del programma del prof:
- Introduzione al corso e algoritmi: algoritmo, esecutore, strutture di controllo, top-down, efficienza
- Architettura hardware e software di un calcolatore: Von Neumann, CPU, fetch-decode-execute, memorie, bus
- Il Linguaggio C: compilazione, struttura del programma, variabili, assegnazione,
scanfeprintf - Espressioni, operatori e costanti: albero sintattico, precedenze,
++/--,const, caratteri e ASCII - Algebra di Boole: tavole di verità, De Morgan, dalla tavola alla formula
- Istruzioni condizionali:
if, dangling else,?:, istruzione composta - Ciclo while ed esempi:
while, sentinella, MCD, moltiplicazione, scala - Input e output di caratteri:
getchar,putchar,EOF - Cicli for e do-while:
for,do-while, equivalenza con ilwhile,breakecontinue, Böhm-Jacopini - Switch: selezione multipla,
breake fall-through,caseraggruppati - Array: dichiarazione, indici da 0, fuori range, inizializzazione, cicli tipici, array di contatori, VLA
- Matrici e array multidimensionali:
a[i][j], memoria per righe, simmetrica, trasposta, matrici magiche - Stringhe: array di
charcon'\0', inizializzazione,%s,scanfsenza&, lunghezza, copia, confronto - Rappresentazione dell’informazione: basi 2, 8, 16 e conversioni, complemento a 2, virgola fissa e mobile, ASCII, somma e shift
- Tipi di dati e conversioni: tipi predefiniti e qualificatori,
sizeof,floate confronti, conversioni implicite, cast - Struct, typedef ed enum:
structe dot notation, memoria allocata,typedef,enum - Puntatori:
&e*,P = Qe aliasing,->, array e aritmetica dei puntatori,const, array di puntatori - Funzioni: definizione e prototipo,
return, invocazione come espressione, record di attivazione e pila, visibilità e mascheramento,static,rand/srand - Passaggio dei parametri: per valore e per indirizzo,
swap, struct e array come parametri, più risultati con i puntatori,conste privilegio minimo - Ricorsione: caso base e caso induttivo, ricorsione diretta e indiretta, record di attivazione e pila, Hanoi, fattoriale, MCD, Fibonacci, memoization, scala 1-2-3 e cammini del robot
4Esercizi
- Esercizi tipo esame, una pagina per argomento, separata dalla teoria (tracing e codice breve, soluzione chiusa):
- Introduzione al corso e algoritmi (esercizi)
- Architettura hardware e software di un calcolatore (esercizi)
- Il Linguaggio C (esercizi)
- Espressioni, operatori e costanti (esercizi)
- Algebra di Boole (esercizi)
- Istruzioni condizionali (esercizi)
- Ciclo while ed esempi (esercizi)
- Input e output di caratteri (esercizi)
- Cicli for e do-while (esercizi)
- Switch (esercizi)
- Array (esercizi)
- Matrici e array multidimensionali (esercizi)
- Stringhe (esercizi)
- Rappresentazione dell’informazione (esercizi)
- Tipi di dati e conversioni (esercizi)
- Struct, typedef ed enum (esercizi)
- Puntatori (esercizi)
- Funzioni (esercizi)
- Passaggio dei parametri (esercizi)
- Ricorsione (esercizi)
- Esami passati: formato dell’esame, domande più frequenti 2023-26, struttura del codice della prova al calcolatore, previsione 2026/27
5Risorse
- Slide del corso (prof. Giuseppe Riccardi) in
20 - Source Materials/Slide-Uni/:- 0 Introduzione al corso (regole d’esame, orari)
- 1.1 Algoritmi
- 1.2 Architettura hardware/software di un calcolatore
- 2.2 Programmazione in C
- 3.1 Operazioni logiche, algebra di Boole
- 3.2 Codifica di semplici algoritmi in C: condizionali e iterative
- 3.3 Strutture di controllo: for, do-while, switch
- 4.1 Array
- 4.2 Stringhe
- 4.3 Rappresentazione di informazioni
- 4.4 Operazioni e conversioni tra basi
- 5.1 Tipi di dato
- 6.1 Puntatori
- 6.2 Funzioni
- 8.1 Programmazione ricorsiva
- Figure delle note:
tools/figure_uni/prog1.pyeprog1_funzioni.py - Compilatore online usato a lezione: onlinegdb.com
- Base utile già nel vault: CS50 Introduction to programming with Python, Python - Sintassi base