Diploma Universitario in Ingegneria Informatica

Fondamenti di Informatica II - secondo modulo

Lezioni faccia a faccia A.A. 1999/2000

docente: Giuseppe De Giacomo

Materiale didattico: testi adottati

[T1] M. Cadoli, M. Lenzerini, P. Naggar, A. Schaerf, Fondamenti della progettazione dei programmi: principi, tecniche e loro applicazione in C++, CittáStudiEdizioni, UTET Libreria, 1997.
[T2] M. Cadoli, E. Panizzi, A. Schaerf., M. Lenzerini. Esercizi di progettazione dei programmi in C++. CittáStudiEdizioni, UTET Libreria, 1998.
[T3] T.H. Cormen, C.E. Leiserson, R.L. Rivest, Introduzione agli Algoritmi, Jackson Libri, 1999.

File contenete tutta la directory di Fondamenti II secondo modulo (inclusi tutti i programmi fatti a lezione): fond2mod2.tar

Lezioni faccia a faccia - tabella riassuntiva


Settimana	Argomento	Martedi (ore 14-17)	Giovedi (ore 11-13)	Venerdi (ore 11-13)
1:11-15gen	Ereditarietà	Ereditarietà in C++ (Lez 1,2,3)	Ereditarietà in C++ (Lez 4,5)	Ereditarietà in C++, Pile, Code (Lez 6,7)
2:17-22gen	Ereditarieà	----	Tipi astratti ed ereditarietà (Lez 8,9)	Tipi astratti ed ereditarietà (Lez 10,11)
3:24-29gen	Complessità	Complessità (Lez 12,13,14)	Complessità asintotica (Lez 15,16)	Complessità di problemi (Lez 17,18)
4:28-5feb	Strutture dati	Heap e Code di Priorità (Lez 19,20,21)	Alberi n-ari (Lez 22,23)	HeapSort (Lez 24,25)
5:7-12feb	Strutture dati	Dizionari, Alberi di Ricerca (Lez 26,27,28)	Realizz. Alberi di Ricerca (Lez 29,30)	Realizz. Dizionari (Lez 31,32)
6:14-19feb	Strutture dati	Alberi AVL (Lez 33,34,35)	Realizz. Alberi AVL (Lez 36,37)	Esercizio d'esame su uso strutture dati (Lez 38,39)
7:21-26feb	Strutture dati	Hashing (Lez 40,41,42)	Hashing (Lez 43,44)	Divide at Impera (Lez 45,46)
8:28-4mar	Tecniche algoritmiche	Algoritmi golosi (Lez 47,48,49)	Algoritmi golosi (Lez 50,51)	----
9:6-11mar	Tecniche algoritmiche	interruzione attivita didattica	Algoritmi su grafi (Lez 52,53)	Algoritmi su grafi (Lez 54,55)
10:13-18mar	Tecniche algoritmiche	Algoritmi su grafi (Lez 56,57,58)	Algoritmi su grafi (Lez 59,60)	Algoritmi su grafi (Lez 61,62)
11:20-25mar	Ripasso	Esercizi d'esame (Es)	Esercizi d'esame (Es)	Esercizi d'esame (Es)

Lezioni faccia a faccia - dettaglio

Lezione 1,2,3 - 11/1/00

Argomenti trattati[T1, Cap. 5, parr. 5.1-5.4]

Presentazione del corso
Introduzione all'ereditarietà in C++

Cosa lo studente dovrebbe sapere dopo la lezione:
- Dichiarazione di classi derivate
- Parte protetta di una classe
- Tipi di derivazione (Es. su tipi di derivazione, Es. derivazione privata)
- Ridefinizione di funzioni e dati (Es. su mascheramento basato su nome)
Esercizi proposti
- Realizzazione del tipo astratto Pila e Coda

Lezioni 4,5 - 13/1/00

Argomenti trattati [T1, Cap. 5, parr. 5.5 e 5.6]
- Costruttori e distruttori ed ereditarietà
- Costruttori di copia ed ereditarietà (Es. costuttore di copia gratis, Es. ridefinizione del costruttore di copia)
- Assegnazione ed ereditarietà (Es. costuttore di copia gratis, Es. ridefinizione del costruttore di copia)
- Ereditarietà multipla
Cosa lo studente dovrebbe sapere dopo la lezione:
- Quando e come ridefinire funzioni in una classe derivata: costruttori, distruttori, costruttori di copia, assegnazione.

Lezioni 6,7 - 14/1/00

Argomenti trattati [T1, Cap. 5, parr. 5.7, 5.8, 5.9]

Realizzazione struttura dati Pila in C++ (pila realiz. con record e punt, versione template)
Realizzazione struttura dati Coda in C++ (coda realiz. con record e punt, coda realiz. con array "circolare")
Funzioni virtuali (funzione virtuale, distruttore virtuale)
Classi base astratte (classe base astratta, figure)
Derivazione e template

Cosa lo studente dovrebbe sapere dopo la lezione:

Realizzare classi per strutture dati semplici
Quando e come usare le funzioni virtuali

Esercizi proposti
- Esercizio (appello Fond II laurea del 1/07/1998)
- Esercizio (appello Fond II laurea del 5/7/1997)

Lezioni 8,9 - 20/1/00

Argomenti trattati [T1, Cap. 13, parr. 13.1, 13.2 (escluso 13.2.2)]

Usi dell'à nella realizzazione di tipi astratti
- realizzazione ISA tra tipi astratti
- raffinamento della rappresentazione
- supporto alla rappresentazione dei valori
Approfondimento della realizzazione della relazione ISA
realizzazione ISA: es. classi Persona e PersonaSposata
generalizzazione completa: es. docenti universitari (specifica, soluzione)

Cosa lo studente dovrebbe sapere dopo la lezione:

Come si realizza la relazione ISA

Esercizi proposti
- Completare esempio docenti universitari

Lezioni 10,11 - 21/1/00

Argomenti trattati [T1, Cap. 13, parr. 13.3, 13.4, 13.5]

Ereditarietà e raffinamento della rappresentazione
("ISA tra classi C++ che rappresentano lo stesso Tipo Astratto")
- uso di classi basi astratte: es. grafo
Ereditarietà e supporto alla rappresentazione dei valori
- il metodo della delegation: es. pila realizzata per delegation con vettore estendibile

Cosa lo studente dovrebbe sapere dopo la lezione:

Come si usa l'ereditarietà per il raffinamento della rappresentazione: uso di classi base astratte
Come si usa l'ereditarietà per il supporto alla rappresentazione dei valori del TA: il metodo della delegation

Esercizi proposti
- Completare esempio grafo, realizzando classe grafo con matrice di adiacenza e con lista di successori
- Tutti gli esercizi sull'ereditarietà dati all'esame di Fond. II - laurea (appelli laurea)

Lezioni 12,13,14 - 25/1/00

Argomenti trattati [T1, parr. 8.1-8.4]
- Introduzione alla complessità
- Modello di macchina astratto
- Configurazione dell'input più sfavorevole (caso peggiore)
- Valutazione della complessità come funzione della dimemsione dell'input
Cosa lo studente dovrebbe sapere dopo la lezione:

I tre aspetti fondamentali da cui astrarre per derivare un metodo per caratterizzare la complessità di un algoritmo
Modello di macchina astratta
Criteri per la scelta del parametro che caratterizza la dimensione dei dati di ingresso

Lezioni 15,16 - 27/1/00

Argomenti trattati [T1, parr. 8.5, 8.6, 8.8]
- Notazione O e Omega
- Metodi per il calcolo della complessità
- Complessità rispetto allo spazio
Cosa lo studente dovrebbe sapere dopo la lezione:

Metodi per valutare la complessità
Nozione di operazione dominante
Calcolare complessità rispetto allo spazio

Lezioni 17,18 - 28/1/00

Argomenti trattati [T1, parr. 8.7]
- Complessità di un problema
- Classi di complessità (cenni)
- Computabilità (cenni)
Cosa lo studente dovrebbe sapere dopo la lezione:

Cosa sono le delimatazioni superiore ed inferiore della complessità di un problema
Avere una idea delle classi di complessità
Sapere che esistono funzioni non calcolabili e problemi indecidibili

Esercizi proposti
- Tutti gli esercizi sulla complessità dati all'esame di Fond. II - laurea (appelli laurea)

Lezioni 19,20,21 - 1/2/00

Argomenti trattati [T2, cap. 11, T2 cap. 7]
- Coda di priorità
- Heap
- Realizzazione di heap con array (heap.h e heap.cpp)
- Realizzazione Coda di Priorita con Heap (coda_priorita.h)
Cosa lo studente dovrebbe sapere dopo la lezione:

Quali sono le operazioni fondamentali di un heap (incluse FaiScendere e FaiSalire) e la loro complessità
Come realizzare Code di Priorità usando heap

Esercizi proposti
- Introdurre nel tipo astratto Coda di Priorità le operazioni: Elimina i-esimo elemento; CampiaPriorita dell'i-esimo elemento assegnandogli un nuovo valore. Realizzare dette operationi (soluzione)

Lezioni 22,23 - 3/2/00 - in laboratorio

Argomenti trattati [T1, parr. 10 e 14]
- Alberi n-ari, visita in preordine ed in postordine
- Rappresentazione tramite liste e tramite alberi
- Tipo astratto Albero
Cosa lo studente dovrebbe sapere dopo la lezione:

Conoscere alberi n-ari e loro rappresentazione
Realizzare il tipo astratto albero n-ario in C++

Esercizi proposti
- Esercizio su alberi n-ari (testo e soluzione)
- Realizzare esercizio proposto reppresntando alberi n-ari con alberi binari

Lezioni 24,25 - 4/2/00

Argomenti trattati [T2, cap. 11, T3 cap. 7]
- SelectionSort - alg. per l'ordinamento O(n^2)
- HeapSort (facendo uso di un heap ausiliario) - alg. per l'ordinamento O(n log n) (heapsort)
- Delimitazione inferiore della complessità del problema dell'ordinamento Omega(n log n)
- Costruzione di un heap a partire da un array in tempo O(n) (BuildHeap.cpp)
- HeapSort non facendo uso di un heap ausiliaro (BuildHeap.cpp)
Cosa lo studente dovrebbe sapere dopo la lezione:

Delimitazione inferiore della complessità del problema dell'ordinamiento
HeapSort

Esercizi proposti
- Realizzare in C++ HeapSort senza fare uso di heap (soluzione)

Lezioni 26,27,28 - 8/2/00

Argomenti trattati [T2, cap. 12, T3 cap. 13]
- Dizionari
- Alberi di ricerca
- Inserimento e cancellazione da alberi di ricerca
- Operazioni dei dizionari su alberi di ricerca
Cosa lo studente dovrebbe sapere dopo la lezione:

Quali sono le operazioni fondamentali di un albero di ricerca e la loro complessità
Come i dizionari possono essere basati su alberi di ricerca

Lezioni 29,30 - 10/2/00

Argomenti trattati [T2, cap. 12, T3 cap. 13]
- Tipi Astratti per le stutture dati Albero Binario e Albero di Ricerca (astrazioni d'entità)
- Realizzazione Albero Binario con figli in sharing (AlbBin.h, AlbBin.cpp)
- Realizzazione Albero di Ricerca derivato da Albero Binario (AlbRic.h, AlbRic.cpp)
Cosa lo studente dovrebbe sapere dopo la lezione:

Avere compreso esattamente le realizzazioni proposte, in particolare come esse usano lo sharing per mantenere la complessità asintotica studiata, e perchà questo non pregiudica la correttezza della realizzazione
Sapere concettualizzare le strutture dati Albero Binario e Albero di Ricerca utilizzando astrazione d'entità
Sapere realizzare Albero Binario e Albero di Ricerca in C++

Lezioni 30,31 - 11/2/00

Argomenti trattati [T2, cap. 12]
- Realizzazione del tipo astratto Dizionario utilizzando la classe AlbRic (Dizionario.h, Dizionario.cpp)
Cosa lo studente dovrebbe sapere dopo la lezione:

Come affrontare realizzazioni di tipi astratti utilizzando strutture di dati avanzate

Esercizi proposti
- Completare la realizzazione di Dizionario (soluzione)

Lezioni 33,34,35 - 15/2/00

Argomenti trattati [T2, cap. 12]
- Alberi AVL
- Profondità di alberi AVL: O(log n)
- Bilanciamento: rotazioneSS, rotazione SD, rotazioneDD, rotazioneDS
- Inserimento e cancellazione
Cosa lo studente dovrebbe sapere dopo la lezione:

Come ribilanciare albero AVL: rotazioni
Quando ribilanciare albero AVL durante inserimento e cancellazione
La profondità di un albero AVL e la complessità dell'inserimento e cancellazione

Lezioni 36,37 - 17/2/00

Argomenti trattati [T2, cap. 12]
- Tipi Astratti per le stutture dati Albero AVL utilizzando realizzazione Albero Binario (astrazioni d'entità)
- Realizzazione Albero AVL derivato da Albero Binario (AlbAVL.h, AlbAVL.cpp)
Cosa lo studente dovrebbe sapere dopo la lezione:

Avere compreso esattamente le realizzazioni proposte, in particolare in quali punti la realizzazione di albero AVL differisce dalla realizzazione di Albero di Ricerca
Sapere realizzare Albero AVL in C++

Esercizi proposti
- Realizzazione del tipo astratto Dizionario utilizzando la classe AlbAVL (soluzione)

Lezioni 38,39 - 18/2/00

Argomenti trattati Esercizio d'esame su strutture dati
- Realizzazione del tipo astratto Prestiti facedo uso di opportune strutture dati al fine di ottenere la massima efficienza delle operazioni (Testo)
Cosa lo studente dovrebbe sapere dopo la lezione:

Come affrontare realizzazioni di tipi astratti utilizzando strutture di dati avanzate

Esercizi proposti
- Completare la realizzazione di Prestiti (soluzione)

Lezioni 40,41,42 - 22/2/00

Argomenti trattati [T3, cap. 12]
- Tavole Hash
- Funzioni di Hashing su interi (K mod dimTavola). Nota la scelta di dimTavola è critica:
  - cattive scelte: potenze di 10, potenze di 2
  - buone scelte: numeri dispari, numeri primi (migliore)
- Funzioni di Hashing su altri tipi di dato:
  - Trasformare la chiave in un intero
    - Reali: es. sommare mantissa ed esponente come interi
    - Oggetti (astrazione d'entità): es. considerare indirizzo come un intero (nota, solo se oggetti distinti rappresentano entità distinte)
    - Stringhe: es. sommare codice ASCII dei caratteri (HashingStringhe.cpp)
  - Usare funzione di hashing su interi
- Fattore di carico
- Gestione delle collisioni per concatenazione, usando liste di trabocco (soluzione più usata)
- Analisi complessità nel caso peggiore e nel caso medio (solo caso ricerca senza successo con liste di trabocco)
Cosa lo studente dovrebbe sapere dopo la lezione:

Come progettare una Tavola Hash
Come realizzare Tavole Hash in C++.

Esercizi proposti
- Realizzazione del tipo astratto Tavola Hash

Lezioni 43,44 - 24/2/00

Argomenti trattati [T3, cap. 12]
- Hashing aperto (gestire le collisioni nella tavola hash stessa senza uso di liste di trabocco). Risparmio in spazio ma accesso più lento.
- Scansione Lineare (pseudocodice), fenomeno del clustering primario
- Scansione Quadratica (pseudocodice), evita clustering primario, ma non clustering secondario
- Doppio Hashing (pseudocodice), evita clustering primario e secondario
Cosa lo studente dovrebbe sapere dopo la lezione:

Conoscere metodi di scansione
Avere compreso perché si guadagna in termini di spazio ma si perde in termini di tempo

Lezioni 45,46 - 25/2/00

Argomenti trattati [T1 cap. 19]
- Tecnica algoritmica Divide et Impera
- MergeSort (MergeSort)
- Equazione di ricorrenza del MergeSort.
- Metodo delle sostituzioni successive per risolvere eq. ricorrenza, es. soluzione eq. ricorrenza del MergeSort
- Equazione di ricorrenza generale per Divide et Impera
- Teorema sulla soluzione delle eq. ricorrenza Divide et Impera
Cosa lo studente dovrebbe sapere dopo la lezione:

Conoscere la tecnica divide et impera
Saper risolvere semplici eq. ricorrenza attraverso il metodo delle sostituzioni
MergeSort

Esercizi proposti
- Utilizzare Divide et Impera per realizzare un algoritmo per il calcolo del minimo e del massimo di un vettore di interi non ordinato (soluzione, vedere T1, cap 19)

Lezioni 47,48,49 - 29/2/00

Argomenti trattati [T1, cap. 18]
- Tecnica algoritmica Greedy (o Golosa)
- Problemi di ottimizzazione, ottimo globale
- Spazio di ricerca, esplorazione dello spazio di ricerca
- Tecnica Greedy: evita l'esplorazione dello spazio di ricerca, ottiene un ottimo "locale" che in certe circostanze è anche un ottimo globale
- Considerazioni sulla complessità della tecnica greedy
- Problema del resto [T1, Es. 18.9]
- Problema della bisaccia
- Realizzazione in C++: Algoritmi generici
  - Classe esploratore greedy (esp-greedy.h)
  - Algoritmo generico greedy (esp-greedy.cpp)
- Algoritmo greedy per problema della bisaccia basato sul algoritmo generico Greedy (greedy-bisaccia)
Cosa lo studente dovrebbe sapere dopo la lezione:

Conoscere la tecnica greedy
Avere compreso a fondo l'algoritmo generico Greedy

Esercizi proposti
- Realizzare soluzione greedy per problema del resto facendo uso dell'algoritmo generico Greedy (greedy-monete)

Lezioni 50,51 - 2/3/00

Argomenti trattati [T1 cap. 18]
- Applicabilità della tecnica greedy: proprietà della scelta greedy e proprietà della sottostruttura ottima
- Problema della risorsa
- Realizzazione della soluzione greedy per problema della risorsa facendo uso dell'algoritmo generico Greedy (greedy-risorsa)
Cosa lo studente dovrebbe sapere dopo la lezione:

Sapere realizzare soluzioni greedy per problemi di ottimizzazione facendo uso dell'algoritmo generico Greedy

Lezioni 52,53 - 9/3/00

Argomenti trattati [T3, cap. 23]
- Grafi
  - rappresentazione con liste di successori (ripasso)
  - rappresentazione con matrici di adiacenza (ripasso)
- Visita in Ampiezza (BFS)
- Struttura della visita in ampiezza:
  - inizio visita
  - previsita del nodo (il nodo diviene grigio)
  - postvisita del nodo (il nodo diviene nero)
  - fine visita
- Costo della visita in ampiezza:
  - O(num_nodi + num_archi), se rappresento grafi con liste di successori
  - O(num_nodi^2), se rappresento grafi con matrici di adiacenza
- Iteratori: un modo efficiente per realizzare in C++ la scansione di collezioni.
- Realizzazione in C++ della visita in ampiezza
- Cosa lo studente dovrebbe sapere dopo la lezione:

Lezioni 54,55 - 10/3/00

Argomenti trattati [T3, cap. 23]
- Grafi
- Visita in profondità (DFS): versione non ricorsiva (usando una pila)
- Visita in profondità (DFS): versione definitiva (ricorsiva)
- Struttura della visita in profondità:
  - inizio visita
  - previsita del nodo (il nodo diviene grigio)
  - postvisita del nodo (il nodo diviene nero)
  - fine visita
  Nota: quando la visita di un nodo termina (il nodo diviene nero) la visita dei suoi successori non solo è già iniziata ma è già terminata (solo per visita ricorsiva)!
- Costo della visita in profondità:
  - O(num_nodi + num_archi), se rappresento grafi con liste di successori
  - O(num_nodi^2), se rappresento grafi con matrici di adiacenza
- Realizzazione in C++ della visita in profondità
- Cosa lo studente dovrebbe sapere dopo la lezione:

Lezioni 56,57,58 - 14/3/00

Argomenti trattati [T3, cap. 23]
- Uso di visita in ampiezza [BFS] e visita in profondità [DFS] per risolvere diversi problemi su grafi:
  - Calcolo della distanza da un nodo rad [BFS]
  - Calcolo dei cammini minimi per raggiungere tutti i nodi da rad (calcolo del vettore dei predecessori) [BFS]
  - Raggiungibilità di un dato nodo da rad [DFS/BFS]
  - Calcolo di un cammino tra rad ed un dato nodo [DFS/BFS]
  - Calcolo della chiusura transitiva di un grafo (uso num_nodi volte [BFS/DFS])
  - Realizzazione in C++ (codice)
- Grafi diretti aciclici (DAG)
- Ordinamento topologico di un DAG
- Algoritmo che calcola l'ordinamento topologico di un grafo, se il grafo è un DAG, oppure mette in evidenza che un grafo non è un DAG.
- Realizzazione in C++ (codice)
Cosa lo studente dovrebbe sapere dopo la lezione:

Sapere come modificare visita in ampiezza e visita in profondità per risolvere problemi relativi ai grafi
Sapere cosa è un grafo aciclico
Avere compreso a fondo l'algoritmo per il calcolo dell'ordine topologico

Esercizi proposti
- Svilippare un algoritmo di visita in ampiezza e profondità generico che si appoggino ad opportune classi esploratore (soluzione)

Lezioni 59,60 - 16/3/00

Argomenti trattati [T3 cap. 25.1 (no teoremi), 25.2]
- Grafi con pesi (non negativi) sugli archi
- Rappresentazioni di grafi con pesi sugli archi
  - liste di successori: inserendo campo ausiliario nei recod della lista dove memorizzare il peso dell'arco
  - matrici di adiacenza: memorizzando i pesi nella matrice
  - usando una tavola hash separata per mantenere i pesi degli archi
- Algoritmo di Dijkstra
  - idea intuitiva
  - analisi della correttezza
  - analisi di complessità
    - mantenendo le distanze in un vettore non ordinato O(num_nodi^2)
    - mantenendo i nodi da visitare in un heap ordinato secondo le distanze O((num_nodi+num_archi)*log num_nodi)
  - algoritmo di Dijkstra è un algoritmo greedy
Cosa lo studente dovrebbe sapere dopo la lezione:

Conoscere in modo approfondito l'algoritmo di Dijkstra

Esercizi proposti
- Realizzare l'algoritmo di Dijkstra facendo uso dell'algoritmo generico Greedy

Lezioni 61,62 - 17/3/00

Argomenti trattati [T3 cap. 26.2, 16 introduzione]
- Algoritmo di Floyd-Warshall per calcolare le distanze minime tra tutti i nodi di un grafo con pesi sugli archi
  - Osservazione sulla possibilità di strutturare un cammino minimo che passa in per i nodi {0,..,k} in uno o due cammini che passano per i nodi {0,..,k-1}
  - Algoritmo per calcolare le distanze minime tra tutti i nodi di un grafo con pesi sugli archi, che usa un algoritmo ricorsivo per calcolare il cammino minimo tra due nodi basato sull'osservazione precedente. Costo di tale algoritmo: esponenziale!
  - Calcolare la solizione bottom-up: ottengo l'algoritmo di Floyd-Warshall
- analisi della complessità dell'algoritmo di Floyd-Warshall: O(num_nodi^3)
- L'algoritmo di Floyd-Warshall è basato sulla Programmazione Dinamica
- Concetti base della Programmazione Dinamica: dividere il problema in modo ricorsivo, calcolare la soluzione bottom-up usando tavole.
Cosa lo studente dovrebbe sapere dopo la lezione:

L'algoritmo di Floyd-Warshall. Come modificarlo per ottenere i cammini minimi tra tutti i nodi e per ottenere la chiusura transitiva di un grafo.
I concetti base della Programmazione Dinamica

Esercizi d'esame - 21/3/00, 23/3/00, 24/3/00

Esempi prima parte (parte progettuale)
- GestoreProcessi (Code di Priorità, Heap): testo, soluzione (soluzione con locator)
- VisitaMuseo (Algoritmi su Grafi): testo, soluzione
- Provider (Algoritmo Generico Greedy): testo, soluzione
- Deposito (Tavole Hash): testo, soluzione
- DepositoOggetti (Dizionari, Alberi AVL): testo, soluzione
- Prestiti (Dizionari, Alberi AVL - oppure Tavole Hash) Si veda Lez 38,39
Esempi seconda parte (domanda sul programma):

Tutti gli esercizi sull'ereditarietà dati all'esame di Fond. II - laurea (appelli laurea)
Tutti gli esercizi sulla complessità dati all'esame di Fond. II - laurea (appelli laurea)
Domande più teoriche, ad esempio:
- illustrare su un esempio la tecnica Divide et Impera (MergeSort)
- illustrare la tecnica di programmazione dinamica (Floyd-WarShall)
- illustrare l'alg. di inserimento in un albero di ricerca
- illustrare, con un esempio, il concetto di rotazione per mantenere bilanciato un alb. AVL
- ecc.

Home page del Corso di Fondamenti di Informatica II - secondo modulo
del Diploma Universitario in Ingegneria Informatica dell'Università di Roma "La Sapienza"