Tracce Lab Asd

Algoritmi e Strutture Dati / Programmazione II
Corso di Laurea in Informatica e Tecnologie per la Produzione del Software

Anno Accademico 2014/2015
Docente: Donato Malerba
Prova di laboratorio: ore 15:00 17:00
Si vuole progettare una struttura dati per rappresentare una graduatoria di progetti
sottomessi a una specifica chiamata dell'ottavo programma quadro (H2020). La graduatoria
una sequenza ordinata in senso decrescente di una o pi occorrenze di valori reali

nell'intervallo [0,100] che rappresentano i punteggi assegnati ai progetti valutati.
Esempio:
80.5 LHM 75.7 THOR 55.6 FEED 55.6 AGAIN .... 0.0 ZERO
In caso di ex aequo, l'ordine stabilito dalla cronologia di inserimento nella
graduatoria. Quando la graduatoria viene bloccata, non pi possibile modificarla.
Le specifiche sintattiche del dato astratto graduatoria sono le seguenti:
sorts: graduatoria, punteggio, progetto, intero, booleano
operations:
creaG() graduatoria
crea una nuova graduatoria
aggG(graduatoria, punteggio, progetto) graduatoria
aggiunge alla graduatoria una coppia
(progetto, punteggio) in modo da mantenerla ordinata
primoV(graduatoria) punteggio
restituisce il punteggio massimo in graduatoria
primoP(graduatoria) progetto
restituisce il primo progetto in graduatoria
restoG(graduatoria) graduatoria
restituisce il resto della graduatoria dopo aver
rimosso la prima coppia
dim(graduatoria) intero
restituisce il numero di progetti in graduatoria
Vuota(graduatoria) booleano
predica se la graduatoria vuota
media(graduatoria) valore
restituisce la media dei punteggi di una graduatoria
contenuta(graduatoria, graduatoria) booleano predica che la prima contenuta nella seconda
Pertanto si definiscano:
1) Una classe Progetto che permette di costruire un progetto dandogli un nome (non
necessariamente univoco) e un codice univoco generato automaticamente e restituito
dal metodo
int codice();
2) Una classe Record che implementa l'interfaccia Comparable e memorizza
nell'attributo progetto il riferimento a un progetto e nell'attributo

punteggio il relativo punteggio (un float con valori compresi fra 0 e 15);
3) Una classe WOListLinked che implementa la seguente interfaccia
public interface ListaOrdinata extends Iterable {
public void insert(Comparable e);
public int numElementi();
}
che permette di definire delle liste write-only, cio nelle quali possibile scrivere
una sola volta, di elementi memorizzati in modo ordinato. La classe
WOListLinked rappresenta la lista mediante puntatori:

head
a1
a2
an-1
an
Il metodo numElementi() restituisce il numero di elementi effettivamente

memorizzati nella lista.
4) Una classe Graduatoria che implementa tutte le operazioni del dato astratto
graduatoria. Essa parzialmente definita come segue:
public class Graduatoria {
private ListaOrdinata graduatoria;
...
}
5) Una classe Test con metodo main che crea una graduatoria di 20 progetti il cui
punteggio generato casualmente, stampa la graduatoria (utilizzando le sole operazioni
indicate nella specifica), la media dei punteggi e verifica che la graduatoria priva della
prima e terza e ultima coppia (progetto, punteggio) sia inclusa nella graduatoria intera.
Al termine della prova lasciare sul Desktop un file:
<postazione>_<cognome>_<matricola>.zip
contenente i file sorgente (.java) del progetto sviluppati ai punti 1) - 5), il file eseguibile
(prova.jar) e un file output.txt contenente loutput del programma. Assicurarsi
che prova.jar sia eseguibile lanciando il comando
java jar prova.jar
Algoritmi e Strutture Dati

Si vuole progettare una struttura dati per rappresentare e gestire i risultati delle prossime
elezioni politiche regionali. Le specifiche sintattiche del dato astratto elezione sono le
seguenti:
sorts: elezione, lista (elettorale), voto, naturale, elenco, boolean
operations:
creaElezioni(naturale) elezione
crea la struttura passando il numero di aventi
diritto al voto
aggiungiLista(elezione, lista) elezione
aggiunge una lista elettorale
scrutinaVoto(elezione, voto) elezione
attribuisce un voto scrutinato alla specifica lista
elettorale, se non n nullo n bianco.
numVoti(elezione, lista) naturale
restituisce il numero di voti scrutinati a favore
della lista elettorale
nulle(elezione) naturale
restituisce il numero di schede nulle
bianche(elezione) naturale
restituisce il numero di schede bianche
elencoOrdinato(elezione) elenco
restituisce lelenco delle liste elettorali ordinato
in modo crescente per numero di voti attribuiti.
Si ricorda che un voto pu riferirsi a una lista elettorale, oppure essere considerato nullo o
ancora scheda bianca.
1) una classe ListaElettorale che rappresenta una lista elettorale. La classe deve
disporre di un costruttore che consente di attribuire un nome (di tipo String) alla
lista, oltre che un elenco (del tipo Java List) di nominativi di candidati. La classe
implementa linterfaccia Comparable (il confronto si basa solo sul nome) e dispone
anche di un metodo che consente la stampa, ricorrendo al metodo println, della lista
elettorale (solo il nome, in caratteri maiuscoli).
2) Una classe Voto che dispone di due costruttori:
a. Voto(ListaElettorale s) crea un voto per una lista elettorale s; se s
null allora il voto nullo;
b. Voto() crea un voto corrispondente a una scheda bianca;
e di tre metodi:
c. boolean nullo() stabilisce se il voto nullo;
d. boolean bianca() stabilisce se il voto una scheda bianca;
e. ListaElettorale voto() restituisce una istanza di ListaElettorale
nel caso di voto non nullo o di scheda non bianca, mentre restituisce null
altrimenti.
3) Una classe Elezione che implementa tutte le operazioni del dato astratto elezione.
Essa permette quindi di memorizzare:
a. Il numero degli aventi diritti al voto;

b. Il numero di schede nulle e di schede bianche;
c. Le liste elettorali con il numero dei voti attribuiti.
Per il punto c. la classe Elezione dispone di un attributo:
protected Dictionary<Integer> listeElettorali
dove Dictionary cos definita:
public interface Dictionary<S> extends Iterable<Comparable>{
public void insert(S e, Comparable k);
public void delete(Comparable k);
public S search(Comparable k);
}
Lattributo listeElettorali memorizza le liste elettorali associandole a un intero
che rappresenta il numero di voti attribuiti alla lista.
4) Una classe HashDict<S> che implementa linterfaccia Dictionary<S>
ricorrendo all'uso di una funzione hash e a liste di collisione. Una sua parziale
definizione :
public class HashDict<S> implements Dictionary<S> {
LinkedList s[];
HashDict(int n){
S= new LinkedList[n];
}
private int h(Comparable k){ // funzione hash
return Math.abs(k.hashCode()) % s.length;
}
...
5) Una classe che implementa literatore su un HashDict<S>.
6) Una classe Test con metodo main che crea una elezione con almeno le seguenti tre
liste elettorali:
Todos Caballeros,
Non ci siamo
Futuro incerto,
e 30 aventi diritto al voto. Quindi genera in modo casuale, stampa e scrutina 20 voti (fra
validi, nulli e schede bianche). Infine stampa il numero delle schede nulle e bianche e
lelenco delle liste elettorali ordinate in ordine crescente per numero di voti attribuiti.
Per lelenco dei nomi dei candidati o per lelenco ordinato delle liste elettorali si pu
utilizzare qualunque classe che implementa linterfaccia Java List.
(prova.jar) e un file output.txt contenente loutput del programma. Assicurarsi
che prova.jar sia eseguibile lanciando il comando
java jar prova.jar
Programmazione II
Si vuole realizzare un semplice sistema software per lanalisi del carrello della spesa
al supermercato. A tale scopo un carrello della spesa viene descritto mediante un
vettore binario che riporta la presenza (1) o lassenza (0) di un articolo fra quelli in
vendita al supermercato. I diversi carrelli, nel complesso, saranno pertanto
rappresentati da una matrice binaria, dove le
colonne rappresenteranno gli articoli, mentre le
righe rappresenteranno i carrelli della spesa che
passano dalla cassa. Un valore 1 (0)
allintersezione di riga i e colonna j indica che il
carrello i-esimo contiene (non contiene) l'articolo j.
Come si pu osservare la matrice sparsa, perch
ha quasi tutti gli elementi uguali a 0.
Pertanto si vuole definire il dato astratto Matrice Sparsa tenuto conto delle seguenti
specifiche sintattiche:
creaMatrice(intero, intero, valore) matrice
crea una nuova matrice di dimensione NM

fissando il valore di default
cambiaValore(matrice, intero, intero, valore) matrice cambia il valore di un elemento della matrice
valore(matrice, intero, intero) valore
restituisce il valore di un elemento della matrice
numRighe(matrice) intero
restituisce il numero delle righe della matrice
numColonne(matrice) intero
restituisce il numero delle colonne della matrice
numValoriSignificativi(matrice) intero
restituisce il numero di valori valore di default
Pertanto si chiede quanto segue:

1) implementare
una
classe
MatriceSparsa<T>
che
implementa
Iterable<T> e mette a disposizione dei metodi corrispondenti alle operazioni
di cui sopra. Per implementare efficientemente la matrice sparsa si utilizza una
classe Record<E> con due attributi:
E valore
int colonna
La classe MatriceSparsa<T> ha, fra laltro, un attributo:
protected ArrayList<Record<T>>[] valori
dove sono memorizzati, riga per riga, solo i valori significativi (diversi dal valore
di default). Quindi, ad esempio, valori[0] punter ad un ArrayList di
elementi di tipo Record<T> che conterranno solo i valori significativi con la
corrispondente colonna della riga 0 in cui sono posizionati.
Literatore restituir tutti i valori (significativi o di default) presenti nella matrice,

scandendoli riga per riga a partire dalla posizione (0,0).
2) Implementare una classe Test che ha un membro privato:
private MatriceSparsa<String> text
inizializzato a una matrice sparsa di 9 colonne e 4 righe, con valore di default
uguale allintero 0, e un altro membro privato che contiene il seguente elenco di
articoli presenti nel supermercato:
private String[] dizionario =
{pane,burro,marmellata,biscotti,patatine,
aranciata,cioccolata,prosciutto,"formaggio"};
Il metodo main della classe Test riempie quattro carrelli con i seguenti articoli:
carrello 1: pane, burro, formaggio
carrello 2: cioccolata, biscotti, patatine
carrello 3: prosciutto, formaggio, aranciata
carrello 4: pane, prosciutto, marmellata, formaggio, patatine,
stampa la matrice sparsa e calcola le 'similarit' fra i quattro carrelli. La similarit
calcolata come numero di articoli comuni fra due carrelli (es.: la similarit fra
carrello 1 e 2 0, mentre fra 1 e 3 1, e fra carrello 3 e 4 2).
Al termine della prova lasciare sulla cartella Documenti un file:

contenente i file sorgente (.java) del progetto sviluppati ai punti 1) - 2), il file
eseguibile (prova.jar), e un file output.txt contenente loutput del
programma. Assicurarsi che prova.jar sia eseguibile lanciando il comando
java jar prova.jar

Si vuole progettare una struttura dati per gestire una biblioteca. Le specifiche
sintattiche del dato astratto biblioteca, sono le seguenti:
sorts: biblioteca, posizione, volume, naturale, booleano
operations:
creaBiblioteca() biblioteca
crea una nuova biblioteca,
bibliotecaVuota(biblioteca) boolean
verifica se ci sono volumi nella biblioteca
addVol(biblioteca, posizione, volume) biblioteca registra un nuovo testo, identificato
univocamente dalla sua posizione (armadio-scaffale-progressivo nello scaffale).
volume(biblioteca, posizione) volume
ritorna il volume che occupa una certa posizione
prestito(biblioteca, posizione) biblioteca
registra il prestito di un volume
restituzione(biblioteca, posizione) biblioteca registra la restituzione del volume
prestato(biblioteca, posizione) boolean
prdica se un volume prestato o meno
posizione(biblioteca, volume) lista
restituisce la lista delle posizioni di volumi
uguali a quello specificato in input (possono esserci pi volumi uguali).
1) Una classe DoubleLinkedList<S> che implementi la seguente interfaccia:
public interface AddOnlyList<S> extends Iterable<S>{
public void add(S e);
public String toString();
}
La classe permette di creare una lista di elementi, eventualmente ripetuti, di tipo
S, accodandoli uno per volta, e di scorrere la lista di elementi mediante un
iteratore. Si usi una rappresentazione collegata.
2) Una classe Volume che permette di creare un volume prendendo in input i dati
sul titolo e casa editrice (di tipo String), anno di pubblicazione (di tipo int) e
lista degli autori (di tipo AddOnlyList<String>), e dispone di un metodo per
stabilire se due volumi sono uguali.
3) Una classe Record che memorizza il riferimento a un volume e un flag
booleano che indica se il volume prestato o meno.
4) Una classe ArrayDict<K,V> che implementa linterfaccia
public interface Dictionary<K,V> extends Iterable<K> {
public void insert(K key, V value );
public void delete(K key);
public V search(K key);
}
ricorrendo ad una rappresentazione indicizzata. Si suggerisce di utilizzare il

metodo equals per stabilire se due chiavi sono uguali oppure no.
5) Una classe astratta BibliotecaAbs che realizza il dato astratto biblioteca.
Essa parzialmente definita come segue:
public abstract class BibliotecaAbs {
protected Dictionary<String,Record> volumi;
//metodi ...
}
in quanto la posizione di un volume rappresentata da una stringa.
6) Una classe concreta
Biblioteca derivata da BibliotecaAbs, il cui
costruttore
avvalora
volumi
con
una
istanza
di
ArrayDict<String,Record>.
7) Una classe Test con metodo main che crea una biblioteca memorizzando i
seguenti volumi:
2 copie
1 copia
3 copie
2 copie
Camil Demetrescu, Umberto Ferraro Petrillo, Irene Finocchi, Giuseppe F. Italiano

Progetto di algoritmi e strutture dati in Java
McGraw Hill, 2007
Alan Bertossi
Algoritmi e Strutture di Dati
CittaStudi Edizioni, 2009
Deitel & Deitel
Programmazione Java: Fondamenti
Pearson-Prentice Hall, 2008
John Lewis, Joseph Chase
Java Software Structures
Pearson Education, 2010
quindi ricerca e presta una copia del volume di Lewis & Chase e quella di
Bertossi, e infine stampa tutte le informazioni relative ai volumi della biblioteca
(autori, titolo, anno di pubblicazione, casa editrice, posizione, disponibilit).
java jar prova.jar

Si vuole simulare il funzionamento di una bussola. La struttura dati pi appropriata
per realizzarla la lista circolare, le cui specifiche sintattiche sono riportate di
seguito:
sorts: circlist, item, booleano, integer
1.
2.
3.
4.
5.
6.
7.
8.
operations:
creaCircList()circlist
addCircList(circlist, item) circlist
delCircList(circlist) circlist
value(circlist) item
isEmpty(circlist) boolean
ruotaAvanti(circlist) circlist
ruotaIndietro(circlist) circlist
numItem(circlist) integer
crea una nuova lista circolare

aggiunge item come ultimo elemento della lista circ.
rimuove il primo elemento dalla lista circolare
restituisce il primo elemento della lista circolare
verifica che la lista circolare sia vuota
ruota la lista circolare di un elemento in avanti
ruota la lista circolare di un elemento indietro
restituisce il numero di elementi nella lista circolare
Pertanto si definisca una interfaccia generica CircList<T> che estende

Iterable<T> e definisce le operazioni 2-7. Quindi si definisca una classe
ListaCircDC<T> che implementi l'interfacciae CircList<T> e rappresenti
una lista circolare mediante una rappresentazione doppiamente collegata con
puntatore allelemento successivo e uno all'elemento precedente. La classe
ListaCircDC<T> dispone di un main che testa i metodi implementati, inserendo
in una lista circolare le stringhe:
nord nord-est est sud-est sud sud-ovest ovest nord-ovest,
stampando la lista circolare, ruotando in avanti la lista di due elementi, rimuovendo
lelemento di testa e poi stampando nuovamente la lista ruotata:
sud-est
sud
sud-ovest
ovest nord-ovest nord nord-est.
Definire una classe Bussola caratterizzata da un ago che pu essere posizionato su

uno degli otto punti cardinali elencati nell'esempio riportato sopra. La posizione
dell'ago simulata dal primo elemento di una lista circolare che contiene gli otto
punti cardinali. Pertanto la classe Bussola si compone con:
CircList<Cardinale> ago;
dove Cardinale un tipo enumerativo relativo gli otto punti cardinali. I metodi
della classe Bussola sono:
public void ruotaA();
public void ruotaI();
public Cardinale direzione();
/* ruota in avanti */
/* ruota indietro */
/* restituisce la direz.*/
Definire una classe Navigazione che registra la direzione seguita da una nave
durante la navigazione. La registrazione avviene a intervalli regolari ed
memorizzata in una LinkedList<Record> dove ogni Record contiene la
direzione di navigazione e l'istante in cui la navigazione stata rilevata. La direzione
registrata ottenuta dalla bussola a bordo.
Dotare la classe Navigazione di un metodo naviga(int N) che genera in
modo casuale N punti di rilevazione a intervalli regolari e che a ogni rilevazione
decide, con uguale probabilit (pari a 1/3), se far ruotare la nave di 45 oppure no.
Dotare la stessa classe del metodo toString() che restituisce una stringa
corrispondente alla traiettoria seguita.
Testare il metodo naviga nel main di Navigazione, in modo da far navigare una
nave per trenta punti di rilevazione e stamparli.
contenente i file sorgente (.java) del progetto sviluppato, il file eseguibile
(prova.jar), e un file output.txt contenente loutput del programma.
Assicurarsi che prova.jar sia eseguibile lanciando il comando
java jar prova.jar
Programmazione II / Algoritmi e Strutture Dati


Si vuole progettare una struttura dati per gestire la ricezione di comunicazioni
via Skype. La comunicazione uno stream di diversi pacchetti inviati da un
utente Skype mittente a un utente Skype destinatario e che possono giungere in
un ordine qualunque. Un pacchetto contiene le seguenti informazioni: indirizzo
utente mittente, utente destinatario, identificativo pacchetto, dati (in forma di
stringa) e un flag che indica se il pacchetto lultimo della comunicazione.
Lidentificativo un numero progressivo (0, 1, 2, 3, ), che identifica lordine
in cui i dati convogliati nei diversi pacchetti devono essere ricomposti. Si
definisca quindi una classe Pacchetto con i seguenti attributi:
- Utente mittente
- Utente destinatario
- int identificativo
- String dati
- boolean ultimo
La struttura dati utilizzata per memorizzare i pacchetti di una comunicazione
la lista indicizzata, che consente di inserire e rimuovere gli elementi nelle
posizioni stabilite da un indice, che assume valori 0, 1, 2, 3, . La lista
indicizzata ha una interfaccia cos definita:
public interface IndexedList<T> extends Iterable<T>{
public boolean isEmpty(int i);
public void addItem(T e, int i);
public void delItem(int i);
public T getItem(int i); //
public int numberItems();
}
dove il primo metodo serve a verificare che la posizione i-esima sia occupata, il
secondo metodo aggiunge un elemento non nullo in posizione i-esima se libera e
solleva l'eccezione ItemAlreadyPresent altrimenti, il terzo metodo
rimuove l'elemento di posizione i-esima se presente e solleva una eccezione
ItemNotPresent altrimenti, il quarto metodo restituisce lelemento di
posizione i-esima se questa occupata e solleva l'eccezione
ItemNotPresent altrimenti, e il quinto metodo restituisce il numero di
posizioni effettivamente occupate.
Definire una classe IndexedLL<T> che implementa linterfaccia di cui sopra,
utilizzando una rappresentazione doppiamente collegata.
Quindi definire una classe Skype che destinata a contenere i pacchetti di una
singola comunicazione skype. Essa parzialmente definita come segue:
public class Skype implements Comparable {
private IndexedList<Pacchetto> comunicazione =
new IndexedList<Pacchetto>();
...
}
I metodi di cui dotata la classe Skype sono i seguenti:
addPacchetto(Pacchetto) void
complete() boolean
toString() String
aggiunge
un
pacchetto
alla
comunicazione skype posizionandolo
nella posizione corretta
verifica se una comunicazione
completa, cio sono stati aggiunti tutti i
pacchetti che la compongono
restituisce la composizione dei dati di
tutti i pacchetti della comunicazione,
anche non completo, scandendo la lista
con indice che varia da 0 fino allultimo
valore valido.
Il confronto di due messaggi restituisce un valore negativo/zero/positivo, se e

solo se sono entrambi completi e le corrispondenti stringhe sono
minori/uguali/maggiori.
Implementare la classe SkypeTest dotata di un metodo public static
void main(), che genera tre comunicazioni rispettivamente di 7, 9, 13
pacchetti. I pacchetti di ogni comunicazione sono generati in ordine casuale
rispetto allindice. Quando la comunicazione completa, viene stampata. Si
effettui un test del metodo compareTo con i messaggi generati.
contenente i file sorgente (.java) del progetto, il file eseguibile (prova.jar), e
un file output.txt contenente loutput del programma. Assicurarsi che
prova.jar sia eseguibile lanciando il comando
java jar prova.jar

Si vuole progettare una struttura dati per gestire una rivista scientifica. Le specifiche
sintattiche del dato astratto rivista, sono le seguenti:
sorts: rivista, titolo, autore, volume, naturale, booleano
operations:
creaRivista() rivista
crea una nuova rivista
rivistaNuova(rivista) boolean
verifica se la rivista ha pubblicato degli articoli
addArt(rivista, titolo, volume) rivista
registra un nuovo articolo, identificato univocamente
dal titolo, ma con volume eventualmente uguale a uno gi indicato per un altro articolo
addAut(rivista, titolo, autore) rivista
aggiunge un autore a un articolo gi registrato ma
non ancora pubblicato
pubblicaVol(rivista, volume) rivista
vengono pubblicati gli articoli registrati per un
volume della rivista
pubblicato(rivista, volume) boolean prdica se il volume stato pubblicato o meno
1) Una classe VectorList<S> che implementi la seguente interfaccia:
}
La classe permette di creare, una lista di elementi, eventualmente ripetuti, di tipo
iteratore. Si usi un array per realizzare tale classe.
2) Una classe Articolo che permette di memorizzare i dati associati a un articolo:
gli autori (di tipo AddOnlyList<String>) e il volume (di tipo int);
3) Una classe LinkedDict<K,V> che implementa linterfaccia
}
ricorrendo ad una rappresentazione collegata. Si suggerisce di utilizzare il metodo
equals per stabilire se due chiavi sono uguali oppure no.
4) Una classe Rivista che realizza il dato astratto rivista. Essa definita come
segue:
public class Rivista {
protected Dictionary<String,Articolo> articoli;
protected Dictionary<Integer,Boolean> volumi;
//metodi ...
}
che memorizza
- in articoli i titoli degli articoli (di tipo String) con i dati associati,
- in volumi i numeri dei volumi e l'informazione se questi siano stati pubblicati
o meno.
5) Una classe Test con metodo main che crea una rivista memorizzando i seguenti
articoli:
Autori:
Titolo:
Volume:
Autori:
Titolo:
Volume:
Autori:
Titolo:
Volume:
Autori:
Titolo:
Volume:
Donato Malerba
A relational perspective on spatial data mining
1
Clay Woolam, Latifur Khan
Multi-label large margin hierarchical perceptron
1
Vassilios S. Verykios, Alexandros Karakasidis, Vassilios K. Mitrogiannis
Privacy preserving record linkage approaches
2
Massimiliano Caramia, Stefano Giordani
On the selection of k efficient paths by clustering techniques
3
quindi pubblica i tre volumi e ne fa una stampa.

java jar prova.jar

Si vuole realizzare un semplice sistema software per la scoperta automatica di plagi,
attraverso il calcolo della similarit fra due document.i A tale scopo un documento
viene descritto mediante un multi-insieme (bag) di parole, cio come una collezione
di parole non necessariamente distinte, di cui ci interessa conoscere la frequenza
assoluta. Ad esempio, il documento:
Per plagio si intende sia la appropriazione di una opera altrui che viene spacciata
come propria che la opera stessa.
associato al multi-insieme:
parola
per
plagio
che
opera
#occorrenze
1
1
2
2
Le parole del multi-insieme sono formate esclusivamente dalle 26 lettere

dellalfabeto inglese, inoltre non si fa distinzione se una lettera maiuscola o
minuscola.
Le specifiche sintattiche del multi-insieme sono le seguenti:
newBag()bag
addItem(bag, item) bag
delItem(bag, item) bag
occurrences(bag,item) integer
isEmpty(bag) boolean
crea un nuovo multi-insieme

aggiunge un elemento al multi-insieme.
rimuove una occorrenza dellelemento passato
restituisce in numero di occorrenze dellelemento
prdica se il multi-insieme vuoto oppure no
Un multi-insieme realizzabile tramite un dizionario, dove la chiave la parola

mentre il valore associato la frequenza assoluta della parola. Pertanto si chiede di:
1) Implementare una classe Bag che implementa Iterable<String> e mette a
disposizione dei metodi corrispondenti alle operazioni di cui sopra. La classe Bag
ha, fra laltro, un attributo:
protected Dictionary<Integer> freqParole
dove Dictionary<S> una interfaccia cos definita:
}
2) Implementare Dictionary<S> mediante un array.
3) Implementare una classe BagOfWords che ha due attributi:

protected Bag bagOfWords
protected int Occurrences
che contiene il multi-insieme delle parole associate a uno o pi testi e il totale
complessivo delle occorrenze delle parole nel multi-insieme. Inizialmente
bagOfWords un multi-insieme vuoto, ma mediante linvocazione del metodo
void addText(String txt);
possibile estrarre dal testo txt le parole da aggiungere al bagOfWords
sommando, eventualmente, il numero di occorrenze delle parole gi presenti. La
stessa classe dispone di un metodo:
float similarit(BagOfWords bow);
che calcola la similarit fra due testi. La similarit di due bag-of-words
B' = {(wi', fi') } e B" = {(wi", fi")}
calcolata in base alla seguente formula:
f j 1 f j 1
N
2
N 2
wj
dove wj una parola presente o in B' o in B" o in entrambi, f'j (f"j) leventuale
numero di occorrenze di wj nel bag B' (B"), e N' (N") il numero di occorrenze
totale nel bag B' (B").
4) Implementare una classe Test che crea le bag-of-words dei seguenti tre testi:
A: Questo un sistema innovativo per la scoperta automatica di plagi
B: Questo sistema innovativo permette la scoperta automatica di plagi
C: Questo sistema non fa proprio nulla di interessante
elenca le parole di ogni bag-of-words con le relative occorrenze, calcola e stampa
le similarit fra A e B, B e C, A e C.
java jar prova.jar
Programmazione II (Algoritmi e Strutture Dati)


Si vuole progettare una struttura dati per gestire le code di processi di un sistema
operativo. Per ogni processo, che identificato da un numero naturale, si
riportano informazioni sullo stato (unrunnable, runnable, stopped) e sul
percorso (path) delleseguibile. Una coda con priorit (Priority Queue, abbr.
PQ) di processi consente di associare una priorit ad ogni processo. La priorit
espressa mediante un valore intero non negativo compreso fra 0 e 100, dove 0
la priorit massima mentre 100 la priorit minima. La coda ordinata in base:
1. alla priorit dei processi, dalla massima alla minima, cio secondo un
ordine decrescente per priorit,
2. a parit di priorit, in base allordine cronologico di accodamento.
Le specifiche sintattiche del dato astratto coda con priorit sono le seguenti:
sorts: pq, item, priority, Boolean, integer
operations:
1. newPQ() pq
crea una coda con priorit
2. isNew(pq) booleano
verifica che la coda con priorit non sia vuota
3. insert(pq, item, priority) pq
inserisce un elemento con una data priorit
4. first(pq) item
restituisce il primo elemento con priorit massima
5. delFirst(pq) pq
rimuove il primo elemento con priorit massima
6. changePriority(pq, item, priority) pq
cambia la priorit dellelemento
7. getPriority(pq, item) priority
restituisce la priorit di un elemento
8. size(pq) integer
restituisce il numero di elementi nella coda
Pertanto si definisca una interfaccia PQ<Item> con metodi che corrispondono

alle operazioni 2-8 e che estenda Iterable<Item>. Quindi si definisca una
classe PQA<Item>
che implementa PQ<Item>
sfruttando una
rappresentazione collegata di cui si offre frammento di definizione:
public class PQA<Item> implements PQ<Item> {
protected Record coda;
private class Record {
public Item
elem;
public int
priority;
public Record
next;
}
//altro ...
}
Il metodo getPriority(Item i) invoca elem .equals(i) nel corpo.
Corredare la classe di un metodo main utile a testare il corretto funzionamento
di tutti gli operatori, ipotizzando che gli Item siano delle stringhe.
Implementare una classe Process con i metodi:

- public Process(String path)
- public int getID()
- public String getPath()
- public String toString()
Il costruttore garantisce che ad ogni istanza di processo sia automaticamente
associato un identificatore univoco di tipo int restituito del metodo getID().
Definire una classe Test che mantiene tre code di processi, cio istanze di
PQA<Process>, una per lo stato unrunnable, una per lo stato runnable, e una
per lo stato stopped. Il passaggio di un processo da una coda allaltra indica un
cambiamento di stato. La priorit degli elementi di ognuna delle tre code
definita in base alla priorit associata alle istanze di Process quando queste
vengono inserite nella coda. Dotare la classe di un metodo main che genera 17
istanze di processo, le memorizza nella coda degli unrunnable scegliendo la
priorit di ognuno in modo casuale e stampa la coda.
Quindi ripete per 20 volte quanto segue: seleziona a caso una coda, e, se non
vuota, prende il primo processo e lo cambia di stato, rispettando il seguente
diagramma degli stati:
unrunnable
runnable
stopped
quindi inserendolo nella coda opportuna ed eventualmente cambiandogli la

priorit (la probabilit di cambiare la priorit del 10%). Si osservi che mentre
per un processo in stato unrunnable o stopped il cambiamento deterministico,
per processi runnable ci sono due possibilit equiprobabili. Incapsulare in un
metodo changeStatePriority(Process p) la logica del cambio di
stato ed eventualmente di priorit.
contenente i file sorgente (.java) del progetto, il file eseguibile (prova.jar) e
un file output.txt contenente loutput del programma. Assicurarsi che
java jar prova.jar
Programmazione II (Algoritmi e Strutture Dati)


riportano informazioni sullo stato (unrunnable, runnable, stopped) e sul
percorso (path) delleseguibile. Una coda con priorit (Priority Queue, abbr.
PQ) di processi consente di associare una priorit ad ogni processo. La priorit
espressa mediante un valore intero non negativo compreso fra 0 e 100, dove 0
la priorit massima mentre 100 la priorit minima. La coda ordinata in base:
Le code gestite dal sistema operativo sono omogenee per stato, quindi ci
saranno tre code, una per lo stato unrunnable, una per lo stato runnable, e una
per lo stato stopped. I processi potranno passare da una coda allaltra quando
cambieranno di stato.
operations:
1. newPQ() pq
4. first(pq) item
5. delFirst(pq) pq
8. size(pq) integer

alle operazioni 2-8 e che estenda Iterable<Item>. Quindi si definisca una
classe PQA<Item> che implementa PQ<Item> sfruttando un array per poter
memorizzare gli elementi. Segue un frammento di definizione:
public class PQA<Item> implements PQ<Item> {
protected Record[] coda = new PQA.Record[1];
private class Record {
public Item
elem;
public int
priority;
}
//altro ...
}
Gestire larray con la tecnica del raddoppiamento/dimezzamento.

Il metodo getPriority(Item i) invoca elem .equals(i) nel corpo.
Corredare la classe di un metodo main utile a testare il corretto funzionamento
di tutti gli operatori, ipotizzando che gli Item siano delle stringhe.
- public Process(String path)
associato un identificatore univoco di tipo int restituito del metodo getID().
Definire una classe Test che mantiene tre code di processi, una per ogni
diverso stato (unrunnable, runnable, stopped), tutte istanze di
PQA<Process>: la priorit degli Item di ognuna delle tre code definita in
base alla priorit associata alle istanze di Process. Dotare la classe di un
metodo main che genera 20 istanze di processo, le memorizza nella coda degli
unrunnable scegliendo la priorit di ognuno in modo casuale e stampa la coda.
Quindi ripete per 20 volte quanto segue: seleziona a caso una coda, e, se non
vuota, prende il primo processo e lo cambia di stato, rispettando il seguente
unrunnable
runnable
stopped
inserendolo nella coda opportuna ed eventualmente cambiandogli la priorit (la

probabilit di cambiare la priorit pari a 0.2). Si osservi che mentre per un
processo in stato unrunnable o stopped il cambiamento deterministico, per
processi runnable ci sono due possibilit equiprobabili. Incapsulare in un
metodo changeStatePriority(Process p) la logica del cambio di
stato ed eventualmente di priorit.
eseguibile (prova.jar) e un file output.txt contenente loutput del
java jar prova.jar
Simpo PDF Password Remover Unregistered Version - http://www.simpopdf.com


riportano informazioni sullo stato (unrunnable, runnable, stopped), sul percorso
(path) delleseguibile e sulla priorit. Questa espressa mediante un valore
intero non negativo compreso fra 0 e 100, dove 0 la priorit massima mentre
100 la priorit minima. Ogni coda di processi ordinata in base:
Quindi, una coda di processi una coda con priorit (Priority Queue, abbr. PQ).
operations:
1. newPQ() pq
4. first(pq) item
5. delFirst(pq) pq
8. size(pq) integer

alle operazioni 2-8. Quindi si definisca una classe astratta PQL<Item> che
implementa PQ<Item> sfruttando una lista (interfaccia List<T> di Java) per
poter memorizzare gli elementi. Segue un frammento di definizione:
public abstract class PQL<Item> implements PQ<Item> {
protected List<Item> coda; //punta al primo elemento
//altro ...
}
Si definisca una classe CodaLL<Item> non astratta che inizializza coda con
un oggetto della classe LinkedList<Item>). Corredare questa classe non
astratta di un metodo main utile a testare il corretto funzionamento dei diversi
operatori implementati.
Definire un tipo enumerativo State con valori UNRUNNABLE, RUNNABLE,

e STOPPED.
- public Process(String path, int priority)
- public void setState(State s)
- public State getState()
- public int getPriority()
associato un identificatore univoco di tipo int e che lo stato sia inizializzato a
UNRUNNABLE. Il metodo getID() restituisce lidentificatore associato
automaticamente, mentre i metodi di tipo get restituiscono le relative propriet
di una istanza di processo. Il metodo setState() serve a variare lo stato di
un processo, in modo da garantire transizioni lecite, come indicato dal seguente
UNRUNNABLE
RUNNABLE
STOP
Definire una classe Test che mantiene tre code di processi, tutte istanze di
CodaLL<Process>: la priorit degli Item di ognuna delle tre code definita
in base alla priorit associata alle istanze di Process. Dotare la classe di un
metodo main che genera 15 istanze di processo, le stampa e le memorizza nella
coda degli UNRUNNABLE scegliendo la priorit di ognuno in modo casuale.
Quindi inizia a svuotare la coda degli UNRUNNABLE cambiando lo stato di
processo e mettendo i processi estratti nella coda dei RUNNABLE. Infine svuota
la coda questa coda cambiando casualmente di stato e di priorit i processi
runnable e riempiendo le code UNRUNNABLE o STOP. Stampare i processi man
mano che si inseriscono in queste tre code.
java jar prova.jar

Si vuole realizzare un semplice sistema software per lanalisi di carrelli degli acquisti
effettuati presso un supermercato. A tale scopo un carrello viene descritto mediante
come una collezione di articoli non necessariamente distinti, di cui ci interessa
conoscere la frequenza assoluta. Ad esempio, il carrello che contiene gli articoli:
Frollini Dixie 500gr, latte Galactica 1 lt, latte Galactica 1 lt, Detersivo Macchianera 2Kg
descritto come segue:

articolo
quantit
1
Frollini Dixie 500gr
2
latte Galactica 1 lt
1
Detersivo Macchianera 2Kg
Le specifiche sintattiche del carrello sono le seguenti:

nuovoCarrello()carrello
aggArticolo(carrello, articolo) carrello
togliArticolo(carrello, articolo) carrello
quantit(carrello, articolo) intero
Vuoto(carrello) booleano
appartiene(carrello, articolo) booleano
numArticoliDistinti(carrello) intero
crea un nuovo carrello

aggiunge un articolo al carrello
rimuove un articolo dal carrello
restituisce la quantit dellarticolo nel carrello
prdica se il carrello vuoto oppure no
stabilisce se un articolo nel carrello
restituisce il numero di articoli distinti nel carrello
Un carrello realizzabile tramite un dizionario, dove la chiave larticolo mentre il

valore associato la quantit. Pertanto si chiede quanto segue:
1) Programmare una classe Articolo
che implementa
Comparable e che permette di memorizzare i seguenti attributi:
linterfaccia
String nome relativa al nome del prodotto (es. Frollini Dixie)

String misura relativa alla misura del prodotto (es. 500 gr)
Oltre al costruttore, la classe Articolo ha anche un metodo toString.
2) Programmare una classe Carrello che implementa Iterable<Articolo>
e mette a disposizione dei metodi corrispondenti alle operazioni di cui sopra. La
classe Carrello ha, fra laltro, un attributo:
protected Dictionary<Integer> carrello
dove Dictionary<V> una interfaccia cos definita:
public interface Dictionary<V>

extends Iterable<Comparable> {
public void insert(Comparable key, V value);
public void delete(Comparable key);
public V search(Comparable key);
}
3) Implementare Dictionary<V> ricorrendo ad una rappresentazione collegata.
4) Implementare una classe Market che inizializza un array
protected Articolo[] merce
relativo alla merce acquistabile in un supermercato. La specifica della merce a
discrezione dello studente (es. Frollini Dixie 500gr, latte Galactica 1 lt, Detersivo
Macchianera 2Kg). La classe dispone anche di un array:
protected Carrello[] acquisti
relativo ai diversi acquisti effettuati nel supermercato (ogni acquisto corrisponde
a un carrello). Larray acquisti inizializzato in modo casuale dal costruttore di
Market che prende in input il numero di acquisti effettuati.
La classe Market anche dotata di un metodo
void stampa();
che stampa tutti gli acquisti effettuali nel supermercato, e di un metodo:
void istogramma();
che stampa, per ogni articolo in merce, la quantit complessivamente acquistata,
cio presente nei carrelli.
5) Implementare una classe Test che costruisce una istanza di Market in modo
tale che ci siano almeno dieci acquisti nel supermercato, stampi gli acquisti e
infine stampi il relativo istogramma.
java jar prova.jar

Docente: Donato Malerba, Michelangelo Ceci
Si vuole sviluppare un recommendation system che suggerisce lacquisto online di
prodotti ritenuti di interesse per un utente basandosi su acquisti associati effettuati da
tutti i clienti nel tempo. Ad ogni sessione di acquisto online, infatti, si registrano tutti
i prodotti acquistati da un cliente. Lanalisi consiste nel riportare per ogni coppia di
prodotti il numero di sessioni in cui sono stati acquistati insieme.
Pertanto si chiede di:
1) Scrivere una classe LinkedList<S> che implementi la seguente interfaccia:
}
mantenendo una rappresentazione collegata con un solo puntatore in avanti. Il
metodo add accoda lelemento e a quelli gi inseriti.
2) Scrivere una classe Prodotto che contiene due campi:
un campo nome di tipo String.
un campo prezzo di tipo int.
in modo da rappresentare il prodotto acquistato e il prezzo di acquisto. La classe
Prodotto permette solo di creare delle istanze e di ispezionarne i valori di nome e
prezzo (ma non di modificare le istanze create).
3) Scrivere una classe astratta SessioneAbs che permette di rappresentare una
sessione di acquisto mantenendo informazioni su tutti i prodotti (oggetti di classe
Prodotto) acquistati nella sessione. Essa parzialmente definita come segue:
public abstract class SessioneAbs {
protected AddOnlyList<Prodotto> prodotti;
//metodi ...
}
4) Scrivere una classe SessioneLL derivata da SessioneAbs che inizializza
prodotti con una istanza di LinkedList<S> .
5) Definire una classe Sessioni che permette di rappresentare tutte le sessioni di
acquisto. Alluopo riutilizzare linterfaccia AddOnlyList<S> per rappresentare
la composizione di Sessioni con istanze di SessioneLL.
6) Definire una classe ItemRecommender che conserva un attributo:
Sessioni sessioni;
Il costruttore di ItemRecommender dotato di un parametro int N che

rappresenta il numero di sessioni di acquisto online da generare in modo
pseudocasuale. Ogni sessione di acquisto generata in modo pseudocasuale contiene
almeno un paio di prodotti selezionati casualmente da una lista di otto prodotti
distinti. Una sessione di acquisto non ha mai pi di 5 prodotti acquistati.
La classe ItemRecommender anche dotata di un metodo
int acquistiAssociati(Prodotto a, Prodotto b)
che prende in input due Prodotti, e restituisce la frequenza di cooccorrenza dei due prodotti nelle sessioni generate.
7) Scrivere una classe Test con metodo main che genera casualmente 20 sessioni
di acquisto, stampa le sessioni, e stampa il numero di co-occorrenze per tutte le
coppie di prodotti, in modo da suggerire quale prodotto acquistare, a seguito
dell'acquisto di un prodotto.
programma. Assicurarsi che prova.jar sia eseguibile lanciando il comando:
java jar prova.jar

Si vuole progettare una struttura dati per rappresentare i testi di una biblioteca. Le
specifiche sintattiche del dato astratto biblioteca, sono le seguenti:
sorts: biblioteca, posizione, volume, naturale, booleano
operations:
bibliotecaVuota(biblioteca) boolean verifica se ci sono volumi nella biblioteca
addVol(biblioteca, posizione, volume) biblioteca registra un nuovo testo, identificato
univocamente dalla sua posizione (armadio-scaffale-progressivo nello scaffale).
volume(biblioteca, posizione) volume il volume che occupa una certa posizione
prestito(biblioteca, posizione) biblioteca permette di prestare un volume
restituzione(biblioteca, posizione) biblioteca permette di restituire un volume
prestato(biblioteca, posizione) boolean prdica se un volume prestato o meno
posizione(biblioteca, volume) lista restituisce la lista delle posizioni di volumi uguali a
quello specificato in input (possono esserci pi volumi uguali).
1) Una classe VectorList<S> che implementi la seguente interfaccia:
}
La classe permette di creare, una lista di elementi, eventualmente ripetuti, di tipo
iteratore. Si usi un array per realizzare tale classe.
2) Una classe Volume che permette di creare un volume prendendo in input i dati
sul titolo e casa editrice (di tipo String), anno di pubblicazione (di tipo int) e
lista degli autori (di tipo AddOnlyList<String>), e dispone di un metodo per
stabilire se due volumi sono uguali.
3) Una classe Record che memorizza il riferimento a un volume e un flag
booleano che indica se il volume prestato o meno.
4) Una classe LinkedDict<K,V> che implementa linterfaccia
}
ricorrendo ad una rappresentazione collegata. Si suggerisce di utilizzare il metodo

equals per stabilire se due chiavi sono uguali oppure no.
5) Una classe astratta BibliotecaAbs che realizza il dato astratto biblioteca.
Essa parzialmente definita come segue:
public abstract class BibliotecaAbs {
protected Dictionary<String,Record> volumi;
//metodi ...
}
in quanto la posizione di un volume rappresentata da una stringa.
6) Una classe concreta
Biblioteca derivata da BibliotecaAbs, il cui
costruttore
avvalora
volumi
con
una
istanza
di
LinkedDict<String,Record>.
7) Una classe Test con metodo main che crea una biblioteca memorizzando i
seguenti volumi:
3 copie
1 copia
2 copie
1 copia
Camil Demetrescu, Umberto Ferraro Petrillo, Irene Finocchi, Giuseppe F. Italiano

Progetto di algoritmi e strutture dati in Java
McGraw Hill, 2007
Alan Bertossi
Algoritmi e Strutture di Dati
CittaStudi Edizioni, 2009
Deitel & Deitel
Programmazione Java: Fondamenti
Pearson-Prentice Hall, 2008
John Lewis, Joseph Chase
Java Software Structures
Pearson Education, 2010
quindi ricerca e presta una copia del volume di Deitel & Deitel e quella di
Bertossi, e infine stampa tutte le informazioni relative ai volumi della biblioteca
(autori, titolo, anno di pubblicazione, casa editrice, posizione, disponibilit).
java jar prova.jar

Si vuole sviluppare un programma per gestire un orologio complesso. Ogni orologio
complesso si compone di pi orologi semplici, caratterizzati dalla circolarit delle
frazioni di tempo (ovvero il successore dellultima frazione di tempo nuovamente
la prima frazione). Le frazioni di tempo possono essere ore, minuti, secondi. Un
orologio con due lancette, una per le ore e laltra per i minuti, si comporr, ad
esempio, di due orologi semplici, uno in cui le frazioni sono ore e laltro in cui le
frazioni sono minuti. Le specifiche del dato astratto orologio (semplice) sono le
seguenti:
sorts: orologio, frazione, booleano, intero
operations:
create(intero)orologio
crea un nuovo orologio con un numero di frazioni di
tempo specificato dal parametro
add (orologio, frazione) orologio
aggiunge frazione come ultima frazione di tempo
dellorologio.
value(orologio) frazione
restituisce la prima frazione di tempo dellorologio
isFull(orologio) booleano
verifica che tutte le frazioni siano state accodate
rotatef(orologio) orologio
ruota la lancetta dellorologio in avanti di una frazione
size(orologio) intero
restituisce il numero di frazioni nellorologio
stop(orologio) orologio
ferma la lancetta dellorologio impedendo la rotatef
restart(orologio) orologio
riattiva la lancetta dellorologio consentendo la rotatef
equals(orologio, orologio) booleano stabilisce che due orologi siano uguali per frazioni e
posizione della lancetta

1) Implementare una classe Orologio<S> che si aggreghi con una classe che
implementa la seguente interfaccia:
public interface CircQueue<S> extends Iterable<S>{
public void add(S e); /* accoda un elemento */
public S value();
/* restituisce il primo elem */
public boolean isEmpty(); /* controlla se vuoto */
public void rotateF(); /* ruota la coda circolare */
public int size();
/* dimensione coda circ. */
public boolean equals(CircQueue<S> s);
public void stop();
public restart();
}
La classe Orologio<S> consente di definire un orologio semplice costituito da
frazioni di tempo di tipo S. Le frazioni di tempo sono memorizzate in un array di

oggetti.
2) Implementare tre classi
attributo:
Ora, Minuto, Secondo che condividano un
String nome: che definisce il nome della frazione di tempo (per esempio, I,
II, III, IV, ecc. )
3) Implementare una classe OrologioDaPolso che si compone di due istanze di
orologio:
Orologio<Ora> ore;
Orologio<Minuto> minuti;
e permette di costruire un orologio dove le ore sono espresse in numeri arabi. Il
costruttore stampa tutte le frazioni associate sia a ore che a minuti. La classe
OrologioDaPolso dispone di un metodo stopAt(Ora o, Minuto m)
che invocando ripetutamente il metodo rotateF sia su ore che su minuti,
simuli lo scorrimento del tempo fermando le lancette dellorologio allora indicata
e stampando lorario nel formato ore:minuti.
Estendere a OrologioDaPolso il metodo equals previsto per
Orologio, in modo da verificare che due orologi da polso siano uguali (stesse
frazioni e stesso orario).
4) Implementare una classe Test che istanzia due volte OrologioDaPolso,
invoca il metodo start() su una delle due istanze, blocca un orologio alle 3:59
e stabilisce se i due orologi sono uguali o meno. Quindi fa ripartire lorologio
bloccato e completa la giornata, al termine della quale verifica che i due orologi
siano uguali.
java jar prova.jar

Si vuole sviluppare unapplicazione di analisi degli acquisti effettuati dai clienti di un
supermercato nel corso di un certo periodo di tempo (ad esempio, sei mesi). Ad ogni
visita, un cliente riempie un carrello di prodotti di vario genere. I prodotti sono
organizzati in categorie. Lanalisi, molto semplice, consiste nel riportare, per ogni
prodotto o categoria, la quantit totale acquistata nel periodo di riferimento.
1) Scrivere una classe Carrello che implementi la seguente interfaccia:
public void forward();
public void backward();
}
La classe Carrello aggiunge un Item in coda, mediante il metodo add, e
permette di esaminare tutti gli articoli nel carrello procedendo dal primo aggiunto
fino allultimo (direzione forward) o dallultimo fino al primo (direzione
backward). Per questa ragione la classe Carrello mantiene una
rappresentazione doppiamente collegata, in modo da garantire lefficienza nello
scorrimento degli articoli indipendentemente dal verso. I metodi forward e
backward servono a impostare il verso di scorrimento.
La classe Item contiene due campi:

1. un campo articolo di tipo Articolo.
2. un campo quantita di tipo int.
in modo da rappresentare un articolo messo nel carrello e la quantit acquistata (ad
esempio, il numero di bottiglie, lattine, confezioni, etc.). La classe Item permette
solo di creare delle istanze e di ispezionarne i valori di articolo e quantita
(ma non di modificare le istanze create).
2) Creare le seguenti classi per rappresentare diversi tipi di articoli: Pane, Burro,
Spaghetti, Cereali, Sapone, Dentifricio, Tovagliolini,
Piatti, Alimenti, Igiene, Casalinghi. Le classi sono dotate di

costruttore standard e non hanno attributi. Si tenga presente che le prime quattro
classi sono derivate da Alimenti, le seconde due da Igiene, e infine
Tovagliolini e Piatti sono sottoclassi di Casalinghi. Tutte queste
classi derivano, direttamente o indirettamente da Articolo.
3) Definire una classe MarketBasketAnalysis che conserva un attributo:
HashMap<Class,Integer> qTotArticolo;
ed dotata dei seguenti metodi pubblici:
Un metodo void add(Carrello<Item> trolley) che prende in
input un carrello (trolley), stampa il contenuto e aggiorna la quantit
totale, inizialmente nulla, associata ai diversi tipi di articoli (Articolo e
sue sottoclassi) sulla base della quantit presente in trolley. Il metodo
add non conserva il trolley passato come argomento.
Un metodo toString utile a stampare per ogni tipo di articolo o
categoria, la quantit totale acquistata nei diversi carrelli passati. Ad
esempio:
Pane 100
Burro 23
Alimenti 123
Sapone 3
Igiene 3
Articolo 126
4) Scrivere una classe Test con metodo main che riempie casualmente 10 carrelli
con alcuni articoli scelti fra Pane, Burro, Spaghetti, Cereali, Sapone,
Dentifricio, Tovagliolini, Piatti, scegliendo la quantit in modo
casuale (non pi di 5). Man mano che la classe Test genera i carrelli li passa a
una istanza di MarketBasketAnalysis. Alla fine stampa le quantit totali
acquistate invocando il metodo toString di MarketBasketAnalysis.
java jar prova.jar
Algoritmi e Strutture Dati - Programmazione 2

Docente: Donato Malerba, Esercitatore: Michelangelo Ceci

Si vuole sviluppare unapplicazione che consenta di gestire delle fatture. Si ricorda che una fattura
un documento in cui devono figurare tutti i dati necessari per individuare tanto gli operatori
(venditore e compratore) che la natura e la consistenza dell'operazione commerciale compiuta
(prodotti e quantit). Le specifiche sintattiche del dato astratto Fattura sono le seguenti:
sorts: fattura, data, venditore, compratore, alfanumerico, bene, quantit, importo, intero, boolean;
operations:
creaFattura(alfanumerico, data, venditore, compratore)
fattura
crea una nuova fattura
aggiungiBene(fattura, bene, quantit, importo) fattura
aggiunge un bene alla fattura
ultimoBene(fattura)
bene
restituisce lultimo bene immesso in fattura
quantitUltimoBene(fattura)
quantit
restituisce la quantit dellultimo bene in fattura
importoUltimoBene(fattura)
importo
restituisce limporto dellultimo bene in fattura
rimuoviUltimoBene(fattura) fattura
rimuove lultimo bene immesso in fattura
totaleImporto(fattura) importo
restituisce limporto totale dei beni in fattura
numeroBeniFatturati(fattura) intero
restituisce il numero di beni in fattura
uguali(fattura, fattura) boolean
controlla che due fatture siano uguali
Due fatture sono uguali se pur avendo identificatore alfanumerico diverso, sono state emesse
nella stessa data, hanno stesso venditore e compratore, e i beni sono gli stessi in numero, tipologia e
ordine di presentazione.
Pertanto si definisca una interfaccia generica Pila<T> con le seguenti operazioni:
boolean isEmpty();
void push(T e);
T top();
void pop();
Si doti linterfaccia Pila<T> di un iteratore, in modo da ottenere le informazioni sui suoi
elementi.
Si definiscano le classi Persona e Bene per rappresentare i compratori/venditori e i beni.
Si definisca una classe astratta Fattura con un membro dato
Pila<Bene> beni;
che non verr inizializzato. Si implementino tutti gli operatori previsti per Fattura.
Si definisca una classe PilaHD<T> che implementa Pila<T> ricorrendo a un array gestito
mediante la tecnica del raddoppiamento/dimezzamento.
Si derivi da Fattura una classe concreta FatturaHD inizializzando il membro dato beni a una
istanza di PilaHD<T>.
Definire una classe Test con un main che crea tre istanze distinte di FatturaHD, di cui le prime
due uguali secondo loperatore di uguaglianza di cui sopra. Stampare le tre istanze di
FatturaHD e lesito delloperazione di uguaglianza fra la prima e la seconda, e la seconda e la
terza.
contenente i file sorgente (.java) del progetto, il file eseguibile (prova.jar), e un file
output.txt contenente loutput del programma.

Si vuole realizzare un semplice sistema software per lanalisi di testi e lo studio della
loro similarit. A tale scopo un testo viene descritto mediante un vettore binario che
riporta la presenza (1) o lassenza (0) di alcuni termini di un dizionario predefinito. I
diversi testi, nel complesso, saranno pertanto rappresentati da una matrice binaria,
dove le colonne rappresenteranno i termini, mentre
le righe rappresenteranno i testi. Un valore 1 (0)
allintersezione di riga i e colonna j indica che il
testo i-esimo contiene (non contiene) il termine j.
Come si pu osservare la matrice sparsa, perch
ha quasi tutti gli elementi uguali a 0.
Pertanto si vuole definire il dato astratto Matrice Sparsa tenuto conto delle seguenti
specifiche sintattiche:
creaMatrice(intero, intero, valore) matrice
crea una nuova matrice di dimensione NM

fissando il valore di default
cambiaValore(matrice, intero, intero, valore) matrice cambia il valore di un elemento della matrice
valore(matrice, intero, intero) valore
restituisce il valore di un elemento della matrice
numRighe(matrice) intero
restituisce il numero delle righe della matrice
numColonne(matrice) intero
restituisce il numero delle colonne della matrice
numValoriSignificativi(matrice) intero
restituisce il numero di valori valore di default

1) implementare
una
classe
MatriceSparsa<T>
che
implementa
Iterable<T> e mette a disposizione dei metodi corrispondenti alle operazioni
di cui sopra. Per implementare efficientemente la matrice sparsa si utilizza una
classe Record<E> con due attributi:
E valore
int colonna
La classe MatriceSparsa<T> ha, fra laltro, un attributo:
protected ArrayList<Record<T>>[] valori
dove sono memorizzati, riga per riga, solo i valori significativi (diversi dal valore
di default). Quindi, ad esempio, valori[0] punter ad un ArrayList di
elementi di tipo Record<T> che conterranno solo i valori significativi con la
corrispondente colonna della riga 0 in cui sono posizionati.
Literatore restituir solo i valori significativi presenti nella matrice, scandendoli
riga per riga a partire dalla posizione (0,0).
2) Derivare da MatriceSparsa<T> una classe MatriceSparsaD<T> che in

pi dispone di un metodo similarit che prende in input gli indici di due
righe e calcola il numero di valori uguali che si trovano nella stessa posizione. Ad
esempio, la similarit della prima e della seconda riga 0 mentre la similarit
della prima e quinta riga 1.
3) Implementare una classe Test che contiene il seguente dizionario:
private String[] dizionario =
{those,who,cannot,the,madness,are,to};
estrae dai seguenti tre testi le parole:
those who cannot remember the past are condemned to repeat it
those who misquote santayana are condemned to paraphrase him
sanity is a madness put to good uses
e se sono presenti nel dizionario aggiunge 1 alla rappresentazione del testo
mediante matrice sparsa. La classe Test ha un membro privato:
private MatriceSparsa<Integer> text
inizializzato a una matrice sparsa di 7 colonne e 3 righe, con valore di default
uguale allintero 0. Quindi calcola le similarit del primo testo con s stesso, del
primo testo con il secondo e del secondo testo con il terzo.
java jar prova.jar

loro similarit. A tale scopo un testo viene descritto mediante un multi-insieme (bag)
di parole, cio come una collezione di parole non necessariamente distinte, di cui ci
interessa conoscere la frequenza assoluta. Ad esempio, il testo:
sopra la panca la capra campa sotto la panca la capra crepa
parola #occorrenze
sopra
1
la
4
panca
2
capra
2
Assumiamo il testo sia formato esclusivamente dalle 26 lettere minuscole

dellalfabeto inglese.
newBag()bag

aggiunge un elemento al multi-insieme
restituisce il numero di occorrenze dellelemento
Un multi-insieme realizzabile tramite un dizionario, dove la chiave lelemento

mentre il valore associato la frequenza assoluta della parola.
1) implementare una classe Bag<T> che implementa Iterable<T> e mette a
disposizione dei metodi corrispondenti alle operazioni di cui sopra. La classe
Bag<T> ha, fra laltro, un attributo:
protected Dictionary<T,Integer> freqParole
dove Dictionary<K,V> una interfaccia cos definita:
}
2) Implementare Dictionary<K,V> ricorrendo ad un array. Si suggerisce di

utilizzare il metodo equals per stabilire se due chiavi sono uguali oppure no.
protected Bag<String> bow
complessivo delle occorrenze delle parole nel multi-insieme. Inizialmente bow
un multi-insieme vuoto, ma mediante linvocazione del metodo
void addText(String testo);
possibile estrarre da testo le parole da aggiungere a bow sommando,
eventualmente, il numero di occorrenze delle parole gi presenti. La stessa classe
dispone di un metodo:
float similarit(BagOfWords b);
che calcola la similarit fra due testi. La similarit di due bag-of-word
b' = { (wi', fi') } e b" = { (wi", fi") }
f j + 1 f j + 1
+
N
2
N + 2
wj
dove wj una parola presente o in b' o in b" o in entrambe, f'j (f"j) leventuale
numero di occorrenze di wj nel bag b' (b"), e N' (N") il numero di occorrenze
totale nel bag b' (b").
4) Implementare una classe Test che crea tre bag-of-word per i seguenti testi:
a: Those who cannot remember the past are condemned to repeat it
b: Those who misquote Santayana are condemned to paraphrase him
c: Sanity is a madness put to good uses
elenca le parole distinte di ogni testo con le relative occorrenze, calcola e stampa
le similarit fra le coppie di testi (a, b), (b, c) e (a, c).
java jar prova.jar


Si progettino delle strutture dati adatte a mantenere lo stato di una rete di sensori, che
sono distribuiti su unarea e che rilevano una propriet geofisica (ad esempio, la
temperatura) dellarea di riferimento. I sensori hanno posizioni fisse nellarea di
riferimento, identificate da una coppia di coordinate. I sensori che sono posti a una
distanza inferiore a un valore definito dallapplicazione sono in grado di scambiarsi
dei dati, e quindi sono collegati. Al contrario i sensori che si trovano a una distanza
superiore a non sono collegati. I sensori sono sempre collegati con se stessi.
Oltre a essere in grado di effettuare una comunicazione tra pari (peer-to-peer) mediante
un protocollo dedicato (ad esempio, Bluetooth), i sensori sono in grado di comunicare
via radio con una centralina remota, che periodicamente li interroga (polling) per
ricevere la rilevazione. Le rilevazioni effettuate dalla centralina a un instante t per tutti i
sensori detta istantanea (snapshot) al tempo t dei sensori.
Quando viene interrogato, un sensore pu inviare il dato oppure no. Se un sensore non
invia un dato viene considerato inattivo ed rimosso dalla rappresentazione della rete.
Rete di sensori attivi
Server che effettua

linterrogazione dei sensori
Le strutture dati che la centralina manterr sono dunque:

1) snapshot, che rappresenta lultima istantanea dei sensori presenti nellarea.
2) rete, che rappresenta i sensori attivi e le loro connessioni tra pari nel caso in
cui la distanza sia inferiore a .
Pertanto si definisca una classe Sensore con i seguenti attributi:
- int x
- int y
dove lidentificativo un numero che identifica univocamente un sensore
dellapplicazione, mentre x e y sono le coordinate (rispetto a un qualche sistema di
riferimento) della posizione in cui il sensore piazzato.
La classe Sensore dotata, fra laltro, di un metodo di istanza pubblico:
- float poll()
che restituisce il valore della propriet geofisica allistante di tempo di interrogazione.
Per simulare un comportamento diverso nel tempo, il metodo restituir un valore
generato in modo pseudo casuale nellintervallo [-5, 35]. sufficiente una precisione di
una sola cifra decimale. Se il metodo poll() restituisce il valore costante statico
pubblico NO_VALUE definito in Sensore e non compreso in [-5, 35], allora vuol
dire che il sensore non ha risposto al polling.
Si definisca inoltre una classe ReteSensori che:
1) piazza n sensori della rete
2) interroga periodicamente tutti i sensori piazzati per t istanti di tempo successivi,
e aggiorna ad ogni istante di tempo sia la struttura dati snapshot che la
struttura dati rete, stampandone il contenuto.
I valori di n e t sono impostati mediante il costruttore della classe che provveder a

piazzare i sensori e a interrogarli. Gli attributi snapshot e rete della classe sono
definiti come segue:
HashMap<Integer,Float> snapshot;
Lista<Collegamento> rete;
dove Collegamento una classe che conserva una coppia di sensori collegati
(larco fra i due sensori), mentre Lista<T> una interfaccia cos definita:
public interface Lista<T> extends Iterable<T> {
public
public
public
public
public
public
public
boolean isEmpty();
Posizione firstList();
boolean endList(Posizione<T> p);
Posizione succ(Posizione<T> p);
Posizione pred(Posizione<T> p);
void insert(T e, Posizione<T> p);
T read(Posizione<T> p);
}
e Posizione<T> una interfaccia cos definita:
public interface Posizione<T> {}
Si definiscano due classi LinkedList<T> e Pointer<T> che implementano
rispettivamente Lista<T> e Posizione<T> ricorrendo a una rappresentazione
collegata.
Implementare la classe Test dotata di un metodo public static void
main(), che genera una rete con 6 sensori e che effettua il polling dei sensori per 10
istanti di tempo consecutivi. Assicurarsi che di tanto in tanto qualche sensore non
trasmetta un valore, cio restituisca un NO_VALUE.
contenente i file sorgente (.java) del progetto, il file eseguibile (prova.jar), e un file
output.txt contenente loutput del programma. Assicurarsi che prova.jar sia
eseguibile lanciando il comando
java jar prova.jar

Si vuole progettare una struttura dati per gestire la ricezione di messaggi comunicati
con protocollo TCP/IP. Il messaggio composto di diversi datagrammi (detti anche
pacchetti) che possono giungere in un ordine qualunque (non necessariamente nello
stesso ordine logico di frammentazione del messaggio). Un datagramma contiene le
seguenti informazioni: indirizzo IP sorgente, indirizzo IP destinazione, identificativo,
dati (in forma di stringa) e un flag che indica se il datagramma lultimo del
messaggio. Lidentificativo un numero progressivo (0, 1, 2, 3, ), che identifica
lordine in cui i dati convogliati nei diversi datagrammi devono essere ricomposti. Si
definisca quindi una classe Datagramma con i seguenti attributi:
- InetAddress sorgente
- InetAddress destinazione
- String dati
- boolean ultimo
La struttura dati utilizzata per memorizzare i datagrammi di un messaggio la lista
indicizzata, che consente di inserire gli elementi nelle posizioni stabilite da un indice,
che assume valori 0, 1, 2, 3, . La lista indicizzata ha una interfaccia cos definita:
public interface ListaIndicizzata<T> extends Iterable<T>{
public void addElement(T e, int i);
public T getElement(int i); //
public int numberElements();
}
secondo metodo aggiunge un elemento non nullo in posizione i-esima, il terzo
metodo restituisce lelemento di posizione i-esima se questa occupata e solleva una
eccezione undefinedElement altrimenti, e il quarto metodo restituisce il numero
di posizioni effettivamente occupate.
Definire una classe IndexedList<T> che implementa linterfaccia di cui sopra,
utilizzando un array di oggetti di tipo T. Gestire la variabilit della lunghezza dei
messaggi.
Quindi definire una classe Messaggio che destinata a contenere i datagrammi di
un singolo messaggio. Essa parzialmente definita come segue:
public class Messaggio {
private ListaIndicizzata<Datagramma> messaggio =

new IndexedList<Datagramma>();
private int ultimo = -1; // indice dg chiusura msg
...
}
I metodi di cui dotata la classe Messaggio sono i seguenti:
addDatagramma(Datagramma) void aggiunge un datagramma al messaggio
posizionandolo nella posizione corretta
completo() boolean
verifica se un messaggio completo,
cio sono stati aggiunti tutti i
datagrammi che lo compongono
toString() String
tutti i pacchetti del messaggio, anche
non completo, scandendo la lista con
indice che varia da 0 fino allultimo
valore valido.
confronta(messaggio) Boolean
stabilisce se due messaggi completi sono
uguali
Implementare la classe testaMessaggio dotata di un metodo public static
void main(), che genera tre messaggi rispettivamente di 10, 15, 20 datagrammi. I
datagrammi di ogni messaggio sono generati in ordine casuale rispetto allindice.
Quando il messaggio completo, viene stampato. Si effettui un test del metodo
confronta con i messaggi generati.
contenente i file sorgente (.java) del progetto, il file eseguibile (prova.jar), e un
file output.txt contenente loutput del programma. Assicurarsi che
java jar prova.jar

loro similarit. A tale scopo un testo viene descritto mediante un multi-insieme (bag)
di parole, cio come una collezione di parole non necessariamente distinte, di cui ci
interessa conoscere la frequenza assoluta. Ad esempio, il testo:
Un testo descritto da un multi-insieme di parole, cio come una collezione di
parole non necessariamente distinte
parola
un
testo
descritto
#occorrenze
2
2
1
1
Le parole del multi-insieme sono formate esclusivamente dalle 26 lettere

dellalfabeto inglese, inoltre non si fa distinzione se una lettera maiuscola o
minuscola.
newBag()bag
aggiunge un elemento al multi-insieme.
restituisce in numero di occorrenze dellelemento
add(bag,bag) bag
restituisce un multi-insieme contenente tutti gli elementi
degli insiemi in input, riportando la somma delle occorrenze
Un multi-insieme realizzabile tramite un dizionario, dove la chiave la parola

mentre il valore associato la frequenza assoluta della parola.
1) implementare una classe Bag che implementa Iterable<String> e mette a
disposizione dei metodi corrispondenti alle operazioni di cui sopra. La classe Bag
ha, fra laltro, un attributo:
protected Dictionary<Integer> freqParole

}
2) Implementare Dictionary<String> mediante rappresentazione collegata.

protected Bag bagOfWords
complessivo delle occorrenze delle parole nel multi-insieme. Inizialmente
bagOfWords un multi-insieme vuoto, ma mediante linvocazione del metodo
void addText(String txt);
possibile estrarre dal testo txt le parole da aggiungere al bagOfWords
sommando, eventualmente, il numero di occorrenze delle parole gi presenti. La
stessa classe dispone di un metodo:
float similarit(BagOfWords bow);
che calcola la similarit fra due testi. La similarit di due bag-of-words
B' = {(wi', fi') } e B" = {(wi", fi")}
f j + 1 f j + 1
+
N
2
N + 2
wj
dove wj una parola presente o in B' o in B" o in entrambi, f'j (f"j) leventuale
numero di occorrenze di wj nel bag B' (B"), e N' (N") il numero di occorrenze
totale nel bag B' (B").
4) Implementare una classe Test che crea le bag-of-words dei seguenti tre testi:
A: La scienza vale pi delle perle e nessuna cosa preziosa la uguaglia
B: Le perle di scienza popolare sono tante, ma la pi preziosa quella di sopra
C: Non ci sono molti termini comuni con le altre frasi
elenca le parole di ogni bag-of-words con le relative occorrenze, calcola e stampa
le similarit fra A e B, B e C, A e C.
java jar prova.jar

Si vuole realizzare un semplice sistema software per la memorizzazione dei volumi di
una biblioteca. Il sistema talmente semplice che consente di associare un solo
autore ad ogni volume. Le specifiche sintattiche del dato astratto biblioteca sono
riportate di seguito:
sorts: biblioteca, codice, titolo, autore, anno, naturale, booleano
operations:
volumi(biblioteca) naturale
restituisce il numero di volumi registrati nella biblioteca
registra(biblioteca, codice, titolo, autore, anno) biblioteca
registra un nuovo volume,
identificato univocamente dal codice alfanumerico, ma con titolo, autore e anno eventualmente
uguali a uno preesistente.
titolo(biblioteca, codice) titolo
restituisce il titolo di un volume registrato
autore(biblioteca, codice) autore
restituisce lautore di un volume registrato
anno(biblioteca, codice) anno
restituisce lanno di un volume registrato
codice(biblioteca, titolo, autore, anno) lista restituisce la lista dei codici di volumi registrati che
hanno stesso titolo, stesso autore e stesso anno
prestito(biblioteca, codice) biblioteca permette di prestare un volume
prestato(biblioteca, codice) boolean prdica se un volume prestato o no.
copie(biblioteca, titolo, autore, anno) naturale restituisce il numero di volumi presenti in
biblioteca (non prestati) che hanno lo stesso titolo, lo stesso autore e lo stesso anno di pubblicazione.
Il codice alfanumerico (String in Java). Pertanto si chiede quanto segue:

1) implementare una classe Volume che permette di costruire un volume
specificando titolo, autore, anno e stato (prestato, non prestato). La classe dispone
dei metodi getTitolo, getAutore, getAnno, getStato, setStato.
2) Implementare una classe Biblioteca che mette a disposizione dei metodi
corrispondenti alle operazioni di cui sopra. La classe Biblioteca ha, fra
laltro, un attributo:
protected Dictionary<Volume> library;
public interface Dictionary<S> extends Iterable<S>{
}
Lattributo library serve a memorizzare i volumi associandoli ai codici.
3) Definire una classe TabellaHashLL<S> che implementa linterfaccia

Dictionary<S> ricorrendo a delle liste di collisione. In pratica essa dispone di
due attributi:
LinkeList<R> elementi[];
Hash fHash;
dove larray elementi[]conterr le liste di collisione associate a una posizione
restituita dalla funzione hash specificata da fHash. La dimensione dellarray e la
funzione hash sono fissate dal costruttore di TabellaHashLL<S>:
TabellaHashLL(int n, Hash f);
Si ricorda che Hash una interfaccia
public interface Hash {
public int h(Comparable k, int n); //funzione hash
}
e che una sua possibile implementazione quella in cui la funzione hash
ottenuta per semplice divisione:
public class HashDivisione implements Hash {
public int h(Comparable k, int n) {
return Math.abs(k.hashCode()) % n;
}
}
Si ricorda altres che la funzione hashCode di String restituisce un int in
base al valore della stringa.
4) Implementare una classe Test che
registra (e stampa) 15 volumi nella biblioteca, usando codici progressivi (A10, B-10, C-10, A-11, B-11, C-11, , A-14, B-14, C-14),
poi ne ricerca 3 (uno con codice che termina per 10, uno per codice che
termina per 13 e uno per codice che termina per 14), stampando lesito della
ricerca (titolo, autore, anno),
quindi presta tutti i volumi con codice che inizia per A e cancella quelli con
codice che inizia per B,
e infine stampa il numero di volumi registrati e il numero di volumi presenti in
biblioteca.
Al fine di testare la correttezza della implementazione, si chiede di impostare la
dimensione dellarray elementi[] al valore 13.
java jar prova.jar

Si vuole sviluppare un programma per gestire un orologio complesso. Ogni orologio
complesso si compone di pi orologi semplici, caratterizzati dalla circolarit delle
frazioni di tempo (ovvero il successore dellultima frazione di tempo nuovamente
la prima frazione). Le frazioni di tempo possono essere ore, minuti, secondi. Un
orologio con due lancette, una per le ore e laltra per i minuti, si comporr, ad
esempio, di due orologi semplici, uno in cui le frazioni sono ore e laltro in cui le
frazioni sono minuti. Le specifiche del dato astratto orologio (semplice) sono le
seguenti:
sorts: orologio, frazione, booleano, intero
operations:
create()orologio
crea un nuovo orologio
add (orologio, frazione) orologio
aggiunge frazione come la prima frazione di tempo
dellorologio.
value(orologio) frazione
restituisce la prima frazione di tempo dellorologio
isEmpty(orologio) booleano
verifica che lorologio non abbia frazioni di tempo
rotatef(orologio) orologio
ruota la lancetta dellorologio in avanti di una frazione
size(orologio) intero
restituisce il numero di frazioni nellorologio
equals(orologio, orologio) booleano stabilisce che due orologi siano uguali per frazioni e
posizione della lancetta

1) Implementare una classe Orologio<S> che implementi la seguente interfaccia:
public interface CircList<S> extends Iterable<S>{
public S value();
public boolean isEmpty();
public void rotateF();
public int size();
public boolean equals(CircList<S> s);
}
La classe Orologio<S> consente di definire un orologio semplice costituito da
frazioni di tempo di tipo S. Le frazioni di tempo sono memorizzate in un array di
oggetti.
2) Implementare tre classi Ora, Minuto, Secondo che abbiano un solo
costruttore a due argomenti:
String nome: che definisce il nome della frazione di tempo (per esempio, I,
II, III, IV, ecc. )

Event e: che definisce un evento associato alla frazione di tempo (per
esempio, appuntamento, allarme, etc. ).
Le classi consentono di leggere il nome della frazione (ma non di modificarlo)
mediante un metodo getName, e di leggere e modificare il singolo evento
associato mediante due metodi, rispettivamente getEvent e setEvent.
3) Implementare una classe Event che permette di costruire (ma non modificare) un
evento specificando una stringa che descrive levento. La classe dispone di un
metodo toString per la conversione di un evento in stringa.
4) Implementare una classe OrologioDaPolso che si compone di due istanze di
orologio:
Orologio<Ora> ore;
Orologio<Minuto> minuti;
e permette di costruire un orologio dove le ore sono espresse in numeri arabi,
associando un evento Bip allo scoccare delle mezzore e un evento Bip Bip
allo scoccare di ogni ora a partire dalla mezzanotte. Il costruttore stampa tutte le
frazioni associate sia a ore che a minuti. La classe OrologioDaPolso
dispone di un metodo start() che invocando ripetutamente il metodo
rotateF sia su ore che su minuti, simuli lo scorrimento del tempo dalle ore
0:00 alle ore 23:59 e stampi, alloccorrenza di ogni evento significativo (non
nullo), lorario nel formato ore:minuti e levento che si verificato. Loutput
sar il seguente:
0:30 Bip
1:00 Bip Bip
1:30 Bip
2:00 Bip Bip
...
Estendere a OrologioDaPolso il metodo equals previsto per
Orologio, in modo da verificare che due orologi da polso siano uguali (stesse
frazioni e stesso orario).
5) Implementare una classe Test che istanzia due volte OrologioDaPolso,
invoca il metodo start() su una delle due istanza e quindi stabilisce se i due
orologi sono uguali o meno.
java jar prova.jar

Si vuole sviluppare unapplicazione di analisi degli acquisti effettuati dai clienti di un
supermercato nel corso di un certo periodo di tempo (ad esempio, sei mesi). Ad ogni
visita, un cliente riempie un carrello di prodotti di vario genere. I prodotti sono
organizzati in categorie. Lanalisi, molto semplice, consiste nel riportare, per ogni
prodotto o categoria, la quantit totale acquistata nel periodo di riferimento.
1) Scrivere una classe Carrello che implementi la seguente interfaccia:
public void forward();
public void backward();
}
La classe Carrello aggiunge un Item in coda, mediante il metodo add, e
permette di esaminare tutti gli articoli nel carrello procedendo dal primo aggiunto
fino allultimo (direzione forward) o dallultimo fino al primo (direzione
backward). Per questa ragione la classe Carrello mantiene una
rappresentazione doppiamente collegata, in modo da garantire lefficienza nello
scorrimento degli articoli indipendentemente dal verso. I metodi forward e
backward servono a impostare il verso di scorrimento.
La classe Item contiene due campi:

1. un campo articolo di tipo Articolo.
2. un campo quantita di tipo int.
in modo da rappresentare un articolo messo nel carrello e la quantit acquistata (ad
esempio, il numero di bottiglie, lattine, confezioni, etc.). La classe Item permette
solo di creare delle istanze e di ispezionarne i valori di articolo e quantita
(ma non di modificare le istanze create).
2) Creare le seguenti classi per rappresentare diversi tipi di articoli: Pane, Burro,
Spaghetti, Cereali, Sapone, Dentifricio, Tovagliolini,
Piatti, Alimenti, Igiene, Casalinghi. Le classi sono dotate di

costruttore standard e non hanno attributi. Si tenga presente che le prime quattro
classi sono derivate da Alimenti, le seconde due da Igiene, e infine
Tovagliolini e Piatti sono sottoclassi di Casalinghi. Tutte queste
classi derivano, direttamente o indirettamente da Articolo.
3) Definire una classe MarketBasketAnalysis che conserva un attributo:
HashMap<Class,Integer> qTotArticolo;
ed dotata dei seguenti metodi pubblici:
Un metodo void add(Carrello trolley) che prende in input un
carrello (trolley), stampa il contenuto e aggiorna la quantit totale,
inizialmente nulla, associata ai diversi tipi di articoli (Articolo e sue
sottoclassi) sulla base della quantit presente in trolley. Il metodo add
non conserva il trolley passato come argomento.
Un metodo toString utile a stampare per ogni tipo di articolo o
categoria, la quantit totale acquistata nei diversi carrelli passati. Ad
esempio:
Pane 100
Burro 23
Alimenti 123
Sapone 3
Igiene 3
Articolo 126
4) Scrivere una classe Test con metodo main che riempie casualmente 10 carrelli
con alcuni articoli scelti fra Pane, Burro, Spaghetti, Cereali, Sapone,
Dentifricio, Tovagliolini, Piatti, scegliendo la quantit in modo
casuale (non pi di 5). Man mano che la classe Test genera i carrelli li passa a
una istanza di MarketBasketAnalysis. Alla fine stampa le quantit totali
acquistate invocando il metodo toString di MarketBasketAnalysis.
java jar prova.jar

Si vuole progettare una struttura dati per rappresentare e gestire i risultati delle
prossime elezioni politiche. Le specifiche sintattiche del dato astratto elezione sono le
seguenti:
sorts: elezione, lista (elettorale), voto, naturale, elenco, boolean
operations:
creaElezioni(naturale) elezione
crea la struttura passando il numero di aventi
diritto al voto
aggiungiLista(elezione, lista) elezione
aggiunge una lista elettorale
scrutinaVoto(elezione, voto) elezione
attribuisce un voto scrutinato alla specifica lista
elettorale, se non n nullo n bianco.
numVoti(elezione, lista) naturale
restituisce il numero di voti scrutinati a favore
della lista elettorale
nulle(elezione) naturale
restituisce il numero di schede nulle
bianche(elezione) naturale
restituisce il numero di schede bianche
elencoOrdinato(elezione) elenco
restituisce lelenco delle liste elettorali ordinato
in modo crescente per numero di voti attribuiti.
Si ricorda che un voto pu riferirsi a una lista elettorale, oppure essere considerato
nullo o ancora scheda bianca.
1) una classe ListaElettorale che rappresenta una lista elettorale. La classe
deve disporre di un costruttore che consente di attribuire un nome (di tipo
String) alla lista, oltre che un elenco (del tipo Java List) di nominativi di
candidati. La classe implementa linterfaccia Comparable (il confronto si basa
solo sul nome) e dispone anche di un metodo che consente la stampa, ricorrendo
al metodo println, della lista elettorale (solo il nome, in caratteri maiuscoli).
2) Una classe Voto che dispone di due costruttori:
a. Voto(ListaElettorale s) crea un voto per una lista elettorale s; se
s null allora il voto nullo;
b. Voto() crea un voto corrispondente a una scheda bianca;
e di tre metodi:
c. boolean nullo() stabilisce se il voto nullo;
d. boolean sbianca() stabilisce se il voto una scheda bianca;
e. ListaElettorale
voto()
restituisce
una
istanza
di
ListaElettorale nel caso di voto non nullo o di scheda non bianca,
mentre restituisce null altrimenti.
3) Una classe Elezione che implementa tutte le operazioni del dato astratto
elezione. Essa permette quindi di memorizzare:
a. Il numero degli aventi diritti al voto;
b. Il numero di schede nulle e di schede bianche;
c. Le liste elettorali con il numero dei voti attribuiti.
Per il punto c. la classe Elezione dispone di un attributo:
protected Dictionary<Integer> listeElettorali
dove Dictionary cos definita:
}
Lattributo listeElettorali memorizza le liste elettorali associandole a un
intero che rappresenta il numero di voti attribuiti alla lista.
4) Una classe LinkedDict<S> che implementa linterfaccia Dictionary<S>
ricorrendo una struttura collegata (anche semplice, con solo puntatore in avanti).
5) Una classe che implementa literatore su un LinkedDict<S>.
6) Una classe Test con metodo main che crea una elezione con almeno le
seguenti quattro liste elettorali:
W lItalia,
In medio stat virtus
Ecumenismo a sinistra,
Metamorfosi,
e 50 aventi diritto al voto. Quindi genera in modo casuale, stampa e scrutina 30
voti attribuendoli alle varie liste elettorali, se validi. Infine stampa il numero delle
schede nulle, delle schede bianche e lelenco delle liste elettorali ordinate in
ordine crescente in base al numero di voti attribuiti.
Per lelenco dei nomi dei candidati o per lelenco ordinato delle liste elettorali si pu
utilizzare qualunque classe che implementa linterfaccia Java List.
java jar prova.jar

Si vuole progettare una struttura dati per rappresentare e gestire le collaborazioni scientifiche
fra dei ricercatori. Queste sono indicate da articoli scientifici scritti insieme, cio di cui sono
coautori. Per ogni articolo, sono noti linsieme degli autori (i ricercatori), il titolo
dellarticolo, lanno di pubblicazione. Le specifiche sintattiche del dato astratto
collaborazioni, sono le seguenti:
sorts: collaborazioni (abbr. coll), autori, autore, titolo, anno, naturale, boolean
operations:
creaCollaborazioni() coll
crea una collaborazione
aggiungiColl(coll, autori, titolo, anno) coll aggiunge una collaborazione fra linsieme di autori
collaboratori(coll, autore) autori
trova gli autori con cui lautore collabora ( autore stesso)
numAutori(coll) naturale
restituisce il numero di autori in collaborazione
numColl(coll) naturale
restituisce il numero di articoli in collaborazione
collaborano(coll, autori) boolean
stabilisce se linsieme degli autori ha collaborato ad almeno un
articolo scientifico
autori(coll, titolo, anno) autori
restituisce linsieme degli autori che hanno collaborato ad un
articolo scientifico
incluso(coll, coll) boolean
stabilisce se una collaborazione include unaltra
1) una classe Autore che permette di creare un autore specificandone cognome, nome e
affiliazione (tutti di tipo String), e dispone di un metodo:
public String toString(); //converte un autore in stringa
2) una classe Autori che implementa Iterable<Autore> e consente di creare un
insieme di istanze di Autore mediante i seguenti metodi;
public Autori();//costruisce un insieme vuoto
public void add(Autore a); //aggiunge un autore distinto
3) una classe Collaborazione che conserva i riferimenti ai due autori (distinti) che
collaborano, il titolo (di tipo String) dellarticolo comune e lanno di pubblicazione (di
tipo integer, non superiore allanno della data di sistema), e dispone di un metodo:
public String toString(); //converte una collab. in stringa
4) una classe Collaborazioni che implementa Iterable<Collaborazione> e ha
due attributi:
private Autore[] nodi = new Autore[0];
private Collaborazione[] archi = new Collaborazione[0];
che permettono di memorizzare i dati di una collaborazione. La classe implementa le
operazioni indicate nelle specifiche sintattiche.
5) una classe Test con metodo main che crea due collaborazioni, quella specifica di
ricercatori in Algoritmi e Strutture Dati e quella pi generale di ricercatori in Informatica,
stampa le collaborazioni e verifica che la prima sia inclusa nella seconda. I nomi degli
autori, i titoli degli articoli, e gli anni di pubblicazione sono scelti dallo studente, che deve
comunque assicurare la presenza di almeno quattro pubblicazioni per ognuna delle due
collaborazioni.
java jar prova.jar


Si vuole progettare una struttura dati per rappresentare e gestire i risultati di un
referendum. Le specifiche sintattiche del dato astratto referendum sono le
seguenti:
sorts: referendum (abbr. ref), quesito, voto, naturale, intpos, boolean
operations:
creaReferendum(naturale) ref
crea un referendum passando il numero dei votanti
aggiungiQuesito(ref, quesito) ref
aggiunge un quesito referendario
scrutinaVoto(ref, quesito, voto) ref aggiunge un voto scrutinato sul quesito specifico
numVoti(ref, quesito) naturale
restituisce il numero di voti scrutinati per un quesito
voto(ref, quesito, intpos) voto
restituisce il voto i-esimo scrutinato per il quesito,
dove i lintero positivo passato
quorum(ref, quesito) boolean
stabilisce se il quorum raggiunto per un quesito
Pertanto si definisca una classe Quesito che implementa la seguente

interfaccia:
public interface AddOnlyQueue<T> {
public void add(T dato); //accoda elem. dato
public T getElement(int i); //ritorna elem. i-esimo
public int numberElements(); //ritorna num elementi
}
La classe Quesito ha anche un attributo di istanza pubblico:
public String quesito;
che permette di memorizzare il quesito referendario.
La classe Referendum ha un attributo:
protected Dictionary<Quesito> referendum;
dove Dictionary una interfaccia
}
relativa al dato astratto dizionario. Si ricorda che S il tipo dellelemento da
memorizzare, mentre la chiave una classe che implementa linterfaccia
Comparable. Nellesempio specifico gli elementi saranno le istanze di
Quesito, mentre le chiavi saranno i quesiti referendari.
Si definisca il voto come un tipo enumerativo che assume valori si, no,
nulla, bianca.
Ci premesso:
1) implementare una classe ArrayOrdinato per linterfaccia Dictionary
ed eventuali classi per la gestione di eccezioni e per literatore;
2) le classi Quesito e Referendum.
3) Scrivere una classe Test con metodo main che crea un referendum con i
seguenti quattro quesiti referendari:
abrogazione delle prove di esame,
abrogazione della frequenza obbligatoria,
abrogazione delle tasse universitarie,
abrogazione del diritto allo studio,
per 20 votanti. Quindi genera N voti diversi per ognuno dei quesiti, con N
generato casualmente e compreso fra 7 e 13, e li scrutina. Infine stampa, per
tutti i quesiti referendari, gli N voti scrutinati, il numero complessivo dei voti
scrutinati (N) e se stato raggiunto il quorum (usando il metodo quorum).
java jar prova.jar

Si vuole simulare il funzionamento di un sistema operativo in
time sharing che riserva, a turno, una fetta di tempo di CPU ad
ognuno dei processi che vengono accodati. La struttura dati pi
appropriata per gestire i processi accodati la lista circolare, le
cui specifiche sintattiche sono riportate di seguito:
sorts: circlist, item, booleano, integer, direzione
1.
2.
3.
4.
5.
6.
7.
8.
operations:
setDir (circlist, direzione) circlist
ruota (circlist) circlist

imposta la direzione in avanti o in indietro per la rotazione
ruota la lista circolare di un elemento nella direzione impostata
Pertanto si definisca una interfaccia CircList<T> con metodi che corrispondono

alle operazioni 2-8. Si definisca la direzione come un tipo enumerativo che assume
valori forward, backward. Linterfaccia CircList<T> eredita da
Iterable<T>.
Quindi si definisca una classe ListaCircDL<T> che implementi linterfaccia
CircList<T> rappresenti una lista circolare mediante una rappresentazione
collegata di celle dove ogni Cella ha un doppio riferimento, a quella precedente e a
quella successiva nella lista circolare.
Si implementi anche una classe TestCircList con un main che prova i metodi
implementati, eseguendo le operazioni indicate di seguito:
1) Inserisce cinque stringhe: alfa beta gamma delta epsilon
2) Stampa la lista in direzione forward, usando literatore in un ciclo for-each;
3) Ruota di una posizione in direzione backward la lista. Risultato:
epsilon alfa beta gamma delta
3) Stampa la lista in direzione backward, a partire dal primo elemento corrente,
usando sempre literatore in un ciclo for-each. Risultato:
epsilon delta gamma beta alfa
4) Ruota di una posizione in direzione forward la lista. Risultato:
alfa beta gamma delta epsilon
5) Ricerca la prima stringa che comincia con d e la cancella.
6) Stampa la lista circolare, in direzione forward. Risultato:
alfa beta gamma epsilon
Definire una classe Processo con i seguenti metodi:

Processo(): costruttore che istanzia un processo e assegna ad esso un
identificatore (id) in modo automatico generandolo come numero naturale
progressivo. Il costruttore assegna al processo anche una durata compresa fra
50 e 800 millisecondi. La durata generata in modo (pseudo-)casuale.
boolean execute(int time_slice): metodo che esegue un
processo, decrementando la sua durata del time_slice fornito e restituisce
true se il processo stato completato, false altrimenti.
getID() e getDurata(): restituiscono i due attributi di istanza.
Definire uno schedulatore di processi (classe Scheduler) dotato di un main che
dichiara una CircList processi e itera 6 volte come segue:
a. genera un nuovo processo, avente durata definita in modo casuale, e lo aggiunge
in coda alla lista processi;
b. stampa la lista dei processi e dei tempi necessari al loro completamento;
c. esegue, per un fattore costante TIME_SLICE = 100, il primo processo in
processi;
d. ruota in avanti la lista processi, passando al processo successivo.
Al termine delle nove iterate, lo schedulatore non riceve pi altri processi in input e
continua a eseguire a turno i processi nella lista processi, finch non ci sono pi
processi in coda.
Esempio di risultato:
Iterata 1:
(1, 266)
Iterata 2:
(1, 166) (2, 201)
Iterata 3:
(2, 201) (1, 66) (3, 750)
Iterata 4:
(1, 66) (3, 750) (2, 101) (4, 725)
Processo 1 completato
Iterata 5:
(3, 750) (2, 101) (4, 725) (5, 348)
Iterata 6:
(2, 101) (4, 725) (5, 348) (3, 650) (6, 743)
Iterata 7:
(4, 725) (5, 348) (3, 650) (6, 743) (2, 1)
Iterata 8:
(5, 348) (3, 650) (6, 743) (2, 1) (4, 625)

Assicurarsi che prova.jar sia eseguibile lanciando il comando:
java jar prova.jar

Si vuole simulare il funzionamento di un sistema operativo in time sharing che
riserva, a turno, una fetta di tempo di CPU ad ognuno dei processi
che vengono accodati. La struttura dati pi appropriata per gestire
i processi accodati la lista circolare, le cui specifiche sintattiche
sono riportate di seguito:
1.
2.
3.
4.
5.
6.
7.
operations:

ruota la lista circolare in avanti di un elemento

alle operazioni 2-7. Quindi si definisca una classe ListaCircCollegata<T>
che implementi le interfacce CircList<T> e Iterable<T> e rappresenti una
lista circolare mediante una rappresentazione collegata con puntatore allelemento
successivo. La classe ListaCircCollegata<T> dispone di un main che testa
i metodi implementati, inserendo in una lista circolare le stringhe:
alfa
beta
gamma
delta
epsilon
zeta
eta
theta,

delta
epsilon
zeta
eta
theta
alfa
beta.
Definire una classe Processo in cui per ogni processo si conserva lidentificatore
(id) del processo (un numero naturale) e la durata del processo (espresso in numero
di millisecondi). Si suppone di conoscere a priori la durata del processo. Il numero
del processo generato automaticamente ed progressivo.
Definire uno schedulatore di processi (classe Scheduler) che ha i seguenti metodi:
1) un costruttore che crea una lista circolare vuota di processi.
2) Un metodo void addProcess() che aggiunge un nuovo processo in coda
alla lista circolare di processi, assegnando ad esso una durata in millisecondi
compresa fra 50 e 800.
3) Un metodo void executeProcess() che esegue per una fetta di tempo
TIME_SLICE il primo processo nella lista circolare di processi, riduce il
tempo necessario al suo completamento per un tempo TIME_SLICE e lo

rimuove dalla lista nel caso in cui sia stato completato.
4) Un metodo main che itera 9 volte come segue:
a. stampa la lista dei processi e dei tempi necessari al loro completamento;
b. genera un nuovo processo, avente durata definita in modo casuale, e lo
aggiunge alla lista processi mediante il metodo addProcess();
c. esegue, per un TIME_SLICE = 100, il primo processo nella lista
circolare di processi;
d. ruota in avanti la lista processi, passando al processo successivo.
Al termine delle nove iterate, lo scheduler non riceve pi altri processi in input
e continua a eseguire a turno i processi nella lista processi, finch non ci
sono pi processi in coda.
Esempio di risultato:
Iterata 1:
(1, 466)
Iterata 2:
(1, 366) (2, 201)
Iterata 3:
(2, 201) (1, 266) (3, 750)
Iterata 4:
(1, 266) (3, 750) (2, 101) (4, 725)
Iterata 5:
(3, 750) (2, 101) (4, 725) (1, 166) (5, 348)
Iterata 6:
(2, 101) (4, 725) (1, 166) (5, 348) (3, 650) (6, 743)
Iterata 7:
(4, 725) (1, 166) (5, 348) (3, 650) (6, 743) (2, 1) (7, 86)
Iterata 8:
(1, 166) (5, 348) (3, 650) (6, 743) (2, 1) (7, 86) (4, 625) (8, 321)
Iterata 9:
(5, 348) (3, 650) (6, 743) (2, 1) (7, 86) (4, 625) (8, 321) (1, 66) (9,
Iterata 10:
(3, 650) (6, 743) (2, 1) (7, 86) (4, 625) (8, 321) (1, 66) (9, 494) (5,
Iterata 11:
(6, 743) (2, 1) (7, 86) (4, 625) (8, 321) (1, 66) (9, 494) (5, 248) (3,
Iterata 12:
(2, 1) (7, 86) (4, 625) (8, 321) (1, 66) (9, 494) (5, 248) (3, 550) (6,
Iterata 13:
(4, 625) (8, 321) (1, 66) (9, 494) (5, 248) (3, 550) (6, 643) (7, 86)
494)
248)
550)
643)

java jar prova.jar

Si vuole simulare il funzionamento di un sistema operativo in time sharing che
riserva, a turno, una fetta di tempo di CPU ad ognuno dei processi
che vengono accodati. La struttura dati pi appropriata per gestire
i processi accodati la lista circolare, le cui specifiche sintattiche
sono riportate di seguito:
1.
2.
3.
4.
5.
6.
7.
operations:

ruota la lista circolare in avanti di un elemento

alle operazioni 2-7. Quindi si definisca una classe ListaCircCollegata<T>
che implementi le interfacce CircList<T> e Iterable<T> e rappresenti una
lista circolare mediante una rappresentazione collegata con puntatore allelemento
successivo. La classe ListaCircCollegata<T> dispone di un main che testa
i metodi implementati, inserendo in una lista circolare le stringhe:
alfa
beta
gamma
delta
epsilon
zeta
eta
theta,

delta
epsilon
zeta
eta
theta
alfa
beta.
Definire una classe Processo in cui per ogni processo si conserva lidentificatore
(id) del processo (un numero naturale) e la durata del processo (espresso in numero
di millisecondi). Si suppone di conoscere a priori la durata del processo.
Definire uno schedulatore di processi (classe Scheduler) che ha i seguenti metodi:
1) un costruttore che crea una lista circolare vuota di processi.
2) Un metodo void addProcess() che aggiunge un nuovo processo alla lista
circolare di processi, assegnando ad esso un id progressivo e una durata in
millisecondi compresa fra 50 e 800.
3) Un metodo main che itera 9 volte come segue:
a. genera un nuovo processo, avente durata definita in modo casuale, e lo
aggiunge alla lista dei processi mediante il metodo addProcess();
b. stampa la lista modificata, riportando il numero complessivo dei processi e

i processi stessi;
c. esegue, per un TIME_SLICE = 100, il primo processo nella lista
circolare di processi, decrementando la durata del processo di tempo
pari al TIME_SLICE, e rimuovendo il processo dalla lista qualora la durata
diventi negativa (giacch lesecuzione del processo stata completata);
d. ruoti in avanti la lista circolare, in modo da passare ad eseguire il processo
successivo.
Al termine delliterazione, lo scheduler non riceve pi altri processi in input e
riprende a iterare, finch non ci sono pi processi nella lista circolare e senza
aggiungerne di nuovi.
Esempio di risultato (sequenza di coppie (identificatore di processo, durata)):
Iterata 1:
(1, 176)
Iterata 2:
(2, 318) (1,76)
Iterata 3:
(3, 744) (1,76) (2, 218)
Iterata 4:
(4, 67) (1,76) (2, 218) (3,644)
Iterata 5:
(5, 777) (1,76) (2, 218) (3,644)
Iterata 6:
(6, 345) (1,76) (2, 218) (3,644) (5,677)
Iterata 7:
(7, 210) (1,76) (2, 218) (3,644) (5,677) (6, 245)
Iterata 8:
(8, 654) (1,76) (2, 218) (3,644) (5,677) (6, 245) (7, 110)
Iterata 9:
(9, 98) (1,76) (2, 218) (3,644) (5,677) (6, 245) (7, 110) (8,554)
Iterata 10:
Iterata 11:
(3,644) (5,677) (6, 245) (7, 110) (8,554) (2, 118)
Iterata 12:
(5,677) (6, 245) (7, 110) (8,554) (2, 118) (3,544)

java jar prova.jar

Si vuole un programma per la valutazione di una espressione in notazione polacca. Si
ricorda, che nella notazione polacca o postfissa, gli operatori sono riportati dopo gli
oggetti su cui operano. Ad esempio, la seguente espressione in notazione postfissa:
35 17 40 9 - * + 7 corrisponde alla seguente espressione in notazione infissa:
35+17*(40-9)-7
Per la valutazione dellespressione si pu utilizzare una pila. In particolare,
lalgoritmo per valutare una espressione in notazione polacca il seguente:
scandisci lespressione da sinistra a destra finch non finisce.
Se la stringa letta corrisponde a un operando, inserisci loperando nella pila
Altrimenti (la stringa letta un operatore) rimuovi dalla pila due operandi,
applica loperatore letto e
memorizza il risultato nella pila.
1) Scrivere una classe PilaDoubling<T> che implementi linterfaccia
public interface Pila<T> {
public void push(T e);
public T top();
public void pop();
}
e che utilizzi la tecnica del raddoppiamento dimezzamento per gestire la pila
mediante un array.
2) Definire una interfaccia ItemEspr{} priva di metodi, e due classi, denominate
Operatore e Operando, che la implementano, in modo tale che la prima
faccia il wrapping di un operatore aritmetico (un carattere) che pu comparire in
una espressione in notazione polacca, mentre la seconda faccia il wrapping di un
operando (un valore intero).
3) Definire una classe:
public class EspressionePolacca {
private LinkedList<ItemEspr> espr;
//metodi ...
}
dotata di un costruttore:
EspressionePolacca(String espressione)
che presa in input una stringa che rappresenta una espressione in notazione
polacca, come:
123 245 + 127 2 * 1 /
avvalori espr inserendo, in sequenza, istanze di Operatore e Operando che

contengono gli operatori aritmetici e gli operandi occorrenti in espressione.
4) Dotare la classe EspressionePolacca anche di un metodo:
int valuta()
che scandendo lespressione memorizzata in espr, la valuti utilizzando una pila
come suggerito dallalgoritmo di cui sopra, e restituisca il risultato. Si ricorra a
meccanismi di RTTI per stabilire se un elemento di espr una istanza di
Operatore o Operando.
Nel caso in cui le espressioni non siano ben formate (es., 125 + ), il metodo deve
sollevare leccezione EccezioneEspressioneNonValida in modo da non
terminare in modo anomalo il programma e garantire robustezza.
5) Dotare la classe EspressionePolacca anche di un main, per poter valutare
il risultato delle seguenti espressioni:
1
125 +
125 12 +
123 245 + 127 4 * 2 /

java jar prova.jar


Nel gioco Maze si deve cercare un percorso che consenta di uscire da un labirinto
(maze, in inglese). Il labirinto una matrice di celle, dove ogni cella pu essere libera
o occupata. I punti di uscita possono essere diversi e sono costituiti da celle non
occupate lungo il bordo della matrice. Nel seguente esempio si mostra un piccolo
labirinto con tre punti di uscita (in celeste):
0 1 2 3 4 5
0
1
2
3
4
Si vuole un programma che trovi una via duscita a partire da una qualunque
posizione di partenza nel labirinto, supponendo che gli spostamenti leciti sono sopra,
a destra, sotto e a sinistra della posizione corrente. Si osservi che:
se la posizione di partenza una cella occupata, allora si pu immediatamente
concludere che non c soluzione;
se la posizione di partenza una cella libera lungo il bordo della matrice, allora
si pu subito concludere che c una soluzione (si gi a un punto di uscita);
in tutti gli altri casi occorrer esplorare il labirinto alla ricerca di un punto
duscita. La ricerca potrebbe concludersi con un insuccesso.
Per lesplorazione si utilizzer una struttura dati lineare con gestione LIFO (pila),
dove verr memorizzato il percorso che si sta progressivamente esplorando. Ogni
qualvolta si raggiunge un vicolo cieco, si provveder a estrarre dalla pila lultima
posizione inserita per sostituirla con una alternativa. Ad esempio, con riferimento al
labirinto mostrato sopra, se il percorso costruito dopo due passi :
Passo
0 (iniziale)
1
2
Posizione
(1,2)
(1,3)
(1,4)
occorrer rimuovere dalla pila lultima posizione esplorata, perch ha portato a un

vicolo cieco, e aggiungere una posizione alternativa, come (0,3) oppure (2,3).
Il labirinto rappresentato da una matrice di interi, dove 1 rappresenta una cella
occupata, mentre 0 rappresenta una cella libera. Ad esempio:
private int [][] maze = {
{1,
{1,
{1,
{1,
{1,
1,
0,
0,
0,
1,
1,
0,
1,
1,
1,
0,
0,
0,
0,
0,
1,
0,
1,
0,
1,
0},
1},
1},
1},
1}};
rappresenta il labirinto riportato sopra.

Per evitare di riesplorare celle gi esplorate nel percorso, cio i cicli, si
contrassegneranno con valore 2 le celle gi esplorate. Pertanto le posizioni valide che
si aggiungeranno alla pila dovranno soddisfare i seguenti vincoli:
i)
sono nei confini del labirinto;
ii)
contengono uno 0 (cio non sono occupate e, se libere, non sono gi state
esplorate).
1) Scrivere una classe PilaCollegata<T> che implementi la seguente
interfaccia
public interface Pila<T> extends Iterable<T>{
public T top(); //
public void pop();
}
e realizzi la pila ricorrendo a una rappresentazione collegata.
2) Implementare la classe Posizione per incapsulare le coordinate di una
posizione nel labirinto.
3) Implementare la classe Maze che memorizzi il labirinto (matrice maze) e lo
esplori alla ricerca di una via duscita a partire da una posizione iniziale scelta
casualmente. La classe Maze utilizzer una pila e disporr dei seguenti metodi:
boolean attraversa(Posizione start), che attraversa il
labirinto alla ricerca di una via duscita a partire dalla posizione di partenza.
Il metodo restituisce true se si riesce a trovare un percorso, false
altrimenti.
boolean valido(Posizione p), che stabilisce se una specifica
posizione valida.
public static void main(), che genera casualmente una
posizione iniziale, invoca attraversa sulla posizione generata e
comunica se stato in grado di trovare un percorso o meno. Nel caso in cui
il percorso sia stato trovato si richiede di stampare il percorso.
java jar prova.jar


riportano informazioni sullo stato (unrunnable, runnable, stopped), sul percorso
(path) delleseguibile e sulla priorit. Questa espressa mediante un valore
intero non negativo compreso fra 0 e 100, dove 0 la priorit massima mentre
100 la priorit minima. Ogni coda di processi ordinata in base:
Quindi, una coda di processi una coda con priorit (Priority Queue, abbr. PQ).
operations:
1. newPQ() pq
4. first(pq) item
5. delFirst(pq) pq
8. size(pq) integer

alle operazioni 2-8. Quindi si definisca una classe astratta PQL<Item> che
implementa PQ<Item> sfruttando una lista (interfaccia List<T> di Java) per
poter memorizzare gli elementi. Segue un frammento di definizione:
public abstract class PQL<Item> implements PQ<Item> {
protected List<Item> coda; //punta al primo elemento
//altro ...
}
Si definisca una classe CodaLL<Item> non astratta che inizializza coda con
un oggetto della classe LinkedList<Item>). Corredare questa classe non
astratta di un metodo main utile a testare il corretto funzionamento dei diversi
operatori implementati.
Definire una classe Process che definisce tre costanti pubbliche

UNRUNNABLE, RUNNABLE, STOPPED di tipo int e dispone dei soli
metodi:
- public Process(String path, int priority)
- public void setState(int State)
- public int getState()
- public int getPriority()
associato un identificatore univoco di tipo int e che lo stato sia inizializzato a
UNRUNNABLE. Il metodo getID() restituisce lidentificatore associato
automaticamente, mentre i metodi di tipo get restituiscono le relative propriet
di una istanza di processo. Il metodo setState() serve a variare lo stato di
un processo, in modo da garantire transizioni lecite, come indicato dal seguente
UNRUNNABLE
RUNNABLE
STOP
Definire una classe Test che mantiene tre code di processi, tutte istanze di
CodaLL<Process>: la priorit degli Item di ognuna delle tre code definita
in base alla priorit associata alle istanze di Process. Dotare la classe di un
metodo main che genera 15 istanze di processo, le stampa e le memorizza nella
coda degli UNRUNNABLE scegliendo la priorit di ognuno in modo casuale.
Quindi inizia a svuotare la coda degli UNRUNNABLE cambiando lo stato di
processo e mettendo i processi estratti nella coda dei RUNNABLE. Infine svuota
la coda questa coda cambiando casualmente di stato e di priorit i processi
runnable e riempiendo le code UNRUNNABLE o STOP. Stampare i processi man
mano che si inseriscono in queste tre code.
java jar prova.jar


Si vuole progettare una struttura dati per rappresentare e gestire un istogramma.
Le specifiche sintattiche del dato astratto istogramma sono le seguenti:
sorts: istogramma (abbr. ist), serie, valore, naturale, intpos, boolean
operations:
creaIstogramma() ist
crea un nuovo istogramma
aggiungiSerie(ist, serie) ist
aggiunge una serie allistogramma
aggiungiValore(ist, serie, valore) ist aggiunge un valore alla serie dellistogramma
lunghSerie(ist, serie) naturale
restituisce il numero di elementi in una serie
valore(ist, serie, intpos) reale
restituisce il valore i-esimo della serie, dove i
lintero positivo passato
massimo(ist, serie) reale
restituisce il massimo valore di una serie
crescente(ist, serie) boolean
stabilisce se una serie monotona crescente
Pertanto si definisca una classe Serie che implementa la seguente interfaccia:

public interface CompList<T> extends Iterable<T>{
public void add(T dato); //accoda dato alla lista
public T getElement(int i); //ritorna elem. i-esimo
public int numberElements(); //ritorna num elementi
public T getMaximum(Comparator c); // ritorna max
public boolean growing(Comparator c); /* stabilisce
se gli elem. della lista sono in ordine crescente */
}
Si osservi che per poter ottenere lelemento massimo o per poter stabilire se gli
elementi sono in ordine crescente, necessario disporre di un metodo di
confronto. Allo scopo i metodi getMaximum e growing necessitano in input
un oggetto di una classe che implementa linterfaccia Comparator . Questa ha
due metodi:
public int compare(Object o1, Object o2)
public boolean equals(Object obj)
Il metodo compare restituisce un valore intero negativo, nullo o positivo a
secondo del risultato del confronto (minore, uguale, maggiore).
La classe Serie ha anche un attributo di istanza pubblico:
public String name;
che permette di memorizzare il nome della serie.
La classe Istogramma ha un attributo:
protected Dictionary istogr;
dove Dictionary una interfaccia

}
relativa al dato astratto dizionario. Si ricorda che S il tipo dellelemento da
memorizzare, mentre la chiave una classe che implementa linterfaccia
Comparable. Nellesempio specifico gli elementi saranno le serie, mentre le
chiavi saranno i nomi delle serie.
Ci premesso:
1) implementare le classi Serie e Istogramma, una classe iteratore per la
serie e per il dizionario, una classe ArrayOrdinato per linterfaccia
Dictionary ed eventuali classi per la gestione di eccezioni.
2) Definire una classe Animale dotata di due attributi pubblici:
String padrone;
String nome;
3) Derivare da Animale cinque classi per rappresentare altrettanti tipi di
animali: Cane, Gatto, Leone, Scorpione e Tucano.
Le istanze di animale potranno essere ordinate in base a un confronto su
doppia chiave padrone,nome. Quindi il cane di nome Fido appartenente
a Caio, precede nellordine il cane di nome Fido appartenente a Tizio.
4) Scrivere una classe Test con metodo main che genera 15 istanze di diversi
tipi di animali scelti fra le cinque classi summenzionate e le memorizza in un
istogramma in modo tale che ogni serie corrisponda a un tipo di animale e i
valori siano le istanze. Il nome della serie il nome della classe (esempio
Cane). Stampare listogramma, riportando il nome di ogni serie su una
linea separata, con accanto il numero di elementi nella serie, il massimo
elemento, e se la serie crescente o meno. Ad esempio:
Cane
2
Fido
true
Gatto
4
Felix
false
Tucano
3
Poppy
false
Leone
1
Richard true
Scorpione
5
Biter
false
java jar prova.jar


Si intende studiare il tempo di attesa agli sportelli delle Poste Italiane. In
generale, pi sportelli sono aperti, meno tempo necessario. Il direttore vuole
evitare lunghe code agli sportelli, ma allo stesso tempo vuole ridurre il numero
di sportelli aperti, perch richiedono limpiego di personale. Occorre quindi
simulare leffetto dellaggiunta di sportelli sui tempi di attesa. La simulazione si
baser sulle seguenti assunzioni:
c una sola coda di attesa e la politica di servizio FIFO (first-in, first-out);
a partire dallistante 0 (quello di apertura dellufficio postale) i clienti
arrivano in sequenza, a intervalli di tempo variabile fra i 10 e i 20 secondi
(la distribuzione nellintervallo [10-20] uniforme);
se c almeno uno sportello libero, il cliente viene servito subito, altrimenti si
mette in coda e attende il suo turno;
lelaborazione della pratica del cliente richiede un tempo variabile compreso
fra 1 e 2 minuti (60120 secondi) da quando si reca al primo sportello libero.
Si definisca quindi una classe Cliente con i seguenti membri privati:
- int tempoArrivo
- int tempoServizio
- int tempoPartenza
che conservano, rispettivamente, il tempo in cui il cliente arriva allufficio
postale, il tempo richiesto per processare la pratica (fra 60 e 120 secondi) e il
tempo in cui lascia lo sportello. I tempi sono riportati direttamente in secondi. Il
tempo di attesa del cliente la differenza fra tempo in cui lascer lo sportello
che lo avr servito e il tempo di arrivo allufficio postale.
La simulazione creer una coda di 200 clienti che arriveranno in successione.
Quindi si proceder a servire la coda, calcolando per ogni cliente listante in cui
lascer lo sportello che lo avr servito. Ai fini della simulazione, si assocer a
ogni sportello un tempoSpLibero che rappresenta listante in cui lo sportello
si libera dopo aver servito un cliente. Ad esempio, se il tempo di arrivo del
cliente selezionato 141, il tempo di servizio 91 e ci sono due sportelli, con,
rispettivamente, tempoSpLibero=236 e tempoSpLibero=317, il cliente
sar stato servito solo al tempo 327 (tempoPartenza=236+91), cio 91
secondi dopo che si sar liberato il primo sportello. Mentre se la situazione dei
due sportelli , rispettivamente, tempoSpLibero = 236 e tempoSpLibero
=120, il cliente lascer lo sportello al tempo 232 (tempoPartenza=141+91).
Si vuole calcolare il tempo medio di attesa dei 200 clienti al variare del numero
di sportelli, da 1 a 10. Pertanto si chiede quanto segue:
1) Definire una coda che implementi, mediante rappresentazione collegata, la

seguente interfaccia:
public interface Coda<T> extends Iterable<T>{
public void enqueue(T e);
}
Il metodo iterator() permette di scandire la coda senza svuotarla.
La coda parzialmente definita di seguito.
public class CodaCollegata<T> implements Coda<T>{
private Record<T> inizio = null; //punta al 1 elem.
private Record<T> fine = null; //punta allultimo elem.
//metodi ...
}
2) Implementare la classe Cliente, garantendo che abbia un membro
static int tempo = 0;
e un costruttore a zero argomenti che determina il valore di tempoArrivo
in base a tempo e a un valore casuale compreso fra 10 e 20 (intervallo
temporale fra due clienti successivi). Il costruttore determina anche
tempoServizio. La classe implementa solo i seguenti metodi di istanza:
getTempoArrivo restituisce tempoArrivo
getTempoPartenza(int
tempoSpLibero) calcola e
restituisce tempoPartenza, noto listante in cui il cliente inizia ad
essere servito (assicurarsi che tempoSpLibero tempoArrivo).
3) Implementare la classe simulaCodaCheckIn che definisce delle costanti
MAX_SPORTELLI=10, NUM_CLIENTI=200, e dispone di
un metodo inizializza, che genera la coda di NUM_CLIENTI clienti
con tempo di arrivo in successione a intervalli compresi fra 10 e 20 secondi;
un metodo tempoMedioAttesa(int numSportelli), che calcola il
tempo medio di attesa quando il numero di sportelli un valore specifico
compreso fra 1 e MAX_SPORTELLI;
un metodo main() che calcola e stampa il tempo medio di attesa simulando
code a n sportelli, con n variabile fra 1 e MAX_SPORTELLI.
java jar prova.jar

Si vuole realizzare una applicazione per la memorizzazione e il successivo
ritrovamento dei layout di documenti a singola pagina. Un layout si compone di
blocchi, cio aree rettangolari che delimitano porzioni non sovrapposte di contenuto
testuale e grafico del documento (vedi figura). Ogni blocco y
di un layout identificato univocamente da un indice intero
id e ha tre propriet fondamentali:
tl, lestremo in alto a sinistra, di tipo Point2D che
rappresenta i punti di un piano cartesiano che ha origine
nellangolo in basso a sinistra della pagina;
br, lestremo in basso a destra, sempre di tipo
Point2D;
tc, il tipo di contenuto, di tipo enumerativo typeC che
assume solo valori TEXT o GRAPHICS.
x
Si chiede quindi di definire il tipo enumerativo typeC, la classe Point2D che
consente di creare punti di un piano bidimensionale e la classe Block che oltre agli
attributi id, tl, br e tc ha un costruttore e un metodo toString.
Un layout, oltre a essere un insieme di blocchi, si caratterizza per due relazioni
spaziali fra blocchi, in particolare la relazione al di sopra di (above) e la relazione
a sinistra di (left), che vanno definite in modo esplicito quando si costruisce un
layout. Le specifiche sintattiche del dato astratto layout sono le seguenti:
sorts: layout, block, integer, list, boolean
operations:
newLayout() layout
addBlock(layout, block) layout
isNew(layout) boolean
addAbove(layout, block, block) layout
addLeft(layout, block, block) layout
above(layout, block, block) boolean
left(layout, block, block) boolean
numBlocks(layout) integer
neighbour(layout, block) list
crea un layout vuoto, cio privo di blocchi

aggiunge un blocco al layout
verifica se un layout vuoto
aggiunge una relazione above fra due blocchi
aggiunge una relazione left fra due blocchi
verifica se un blocco al di sopra dellaltro
verifica se un blocco a sinistra dellaltro
restituisce il numero di blocchi del layout
dato un blocco, restituisce lelenco dei blocchi ad esso
spazialmente vicini, perch sopra/sotto, a sinistra/destra
Si chiede pertanto di definire una classe Layout con i seguenti attributi protetti:
ListaIndicizzata<Block> blocchi;
per memorizzare i blocchi, indicizzandoli in base al loro id;
LinkedList<Relation> above;
per memorizzare le coppie di blocchi in relazione above;
LinkedList<Relation> left;
per memorizzare le coppie di blocchi in relazione left;
I metodi pubblici di Layout sono quelli riportati nella specifica sintattica. Si precisa
che addAbove verifica che il primo blocco sia effettivamente al sopra il secondo,
cio che lordinata dellangolo in basso a destra del primo blocco sia maggiore
dellordinata dellangolo in alto a sinistra del secondo blocco. Analoghi controlli di
consistenza sono anche effettuati da addLeft. La lista restituita da neighbour
una istanza di una qualche classe che implementa linterfaccia java.util.List.
Linterfaccia ListaIndicizzata<T> la seguente:
public interface ListaIndicizzata<T> {
public T getElement(int i);
Iterator<T> iterator();
}
dove il metodo iterator() restituisce un oggetto di una classe che implementa
java.util.Iterable<T> e permette di scandire la lista nellordine di indice.
La classe Relation definita come segue:
class Relation {
int b1;
int b2;
}
dove b1 e b2 sono gli identificatori di una coppia di blocchi in relazione.
Linterfaccia
ListaIndicizzata<T>
implementata
dalla
classe
ListaArray<T> mediante un array di oggetti. Questa classe dispone di un main
che testa i servizi implementati, inserendo delle stringhe in posizioni generate
casualmente e poi stampandole.
Scrivere una classe Test con metodo main che costruisce un semplice layout
composto da almeno sei blocchi, con almeno due relazioni above e due relazioni left.
Stampare, per ogni blocco del layout, le liste dei blocchi adiacenti.
Assicurarsi che prova.jar sia eseguibile lanciando il comando:
java jar prova.jar

Si vuole sviluppare unapplicazione per il calcolo e la stampa di istogrammi.
Lapplicazione devessere generale e in grado di operare su una serie di oggetti di
tipo qualunque. Pertanto si chiede di:
1) Scrivere una classe SerieDL che implementi la seguente interfaccia:
public interface Serie {
public Posizione first();
public void add(Object e);
public Posizione next(Posizione p);
public Posizione pred(Posizione p);
public boolean end(Posizione p);
public Object read(Posizione p);
}
dove Posizione anchessa uninterfaccia, priva di metodi, che serve a rendere
indipendente la posizione dallimplementazione:
public interface Posizione {}
Le classi che implementano linterfaccia Serie consentono di creare delle serie,
aggiungendo dei valori in coda (metodo add), e di scandirle sia in avanti che in
indietro a partire da una certa posizione. La classe SerieDL rappresenta gli
elementi della serie mediante un doppio riferimento allelemento successivo e a
quello precedente, in modo da garantire lefficienza nello scorrimento della serie
indipendentemente dal verso.
La classe SerieDL parzialmente definita di seguito.

public class SerieDL implements Serie {
private Elemento listHead = new Elemento(null);
// metodi
}
dove la classe Elemento implementa linterfaccia Posizione e contiene tre
attributi di istanza:
Object dato;
Elemento successivo;
Elemento precedente;
2) Creare diverse classi per rappresentare diversi animali (Cane, Gatto, Leone,
Scorpione e Tucano). Le classi sono dotate di costruttore standard e non
hanno attributi.
3) Definire una classe Istogramma che dispone di un attributo privato
HashMap<Class,Integer> istogramma;
e dei seguenti metodi pubblici:
Un costruttore che prende in input un parametro serie di tipo Serie e
calcola un istogramma rappresentante la frequenza dei diversi tipi di oggetti
contenuti in serie (ad esempio, Cane: 2, Gatto: 2, Tucano: 1).
Un metodo print che consente di stampare su linee separate, un certo
numero di asterischi proporzionato alla frequenza, seguito dal nome della
classe a cui fa riferimento la frequenza.
** Cane
** Gatto
* Tucano
4) Scrivere una classe Test con metodo main che riempie una serie di 30 istanze di
diversi tipi di animali scelti fra le cinque classi summenzionate, in modo tale che
la distribuzione delle istanze sia stabilita in modo casuale, e quindi crea un
istogramma su quella serie e lo stampa.
java jar prova.jar

Si intende sviluppare un modello a oggetti delle sequenze biologiche (e.g., DNA e
proteine) da usare in applicazioni software di bioinformatica. Il DNA un polimero
costituito da unit ripetute di nucleotidi. Questi possono avere delle basi diverse, che
sono l'adenina (abbreviata con la lettera A), la citosina (C), la guanina (G) e la timina
(T). Una comune rappresentazione lineare del DNA pertanto una stringa del tipo:
TTGCCGGGAACTGGCATAGCGTCGCCATTTATTTGCTGGCTGGATG
Anche la proteina un polimero costituito da unit ripetute di aminoacidi, che
possono essere di 20 tipi diversi:
Alanina (A) Cisteina (C) Acido aspartico (D) Acido glutammico (E)
Fenilalanina (F) Glicina (G) Istidina (H) Isoleucina (I) Lisina (K) Leucina (L)
Metionina (M) Asparagina (N) Prolina (P) Glutammina (Q) Arginina (R)
Serina (S) Treonina (T) Valina (V) Triptofano (W) Tirosina (Y)
Anche in questo caso si associano delle lettere dellalfabeto agli aminoacidi, sicch
una proteina pu essere rappresentata mediante una stringa del tipo:
CQVDAHCSAGHSCIFT
1) Definire una classe astratta Monomero che dispone di due metodi:
a. String getName(), che restituisce il nome completo del monomero
(ad esempio, citosina o valina);
b. char getSymbol(), che restituisce la lettera dellalfabeto che
identifica il monomero.
2) Definire una classe concreta Nucleotide derivata da Monomero che permette
la creazione solo dei quattro nucleotidi che compongono il DNA, sollevando una
eccezione IllegalNucleotide altrimenti.
3) Definire una classe concreta Aminoacido derivata da Monomero che permette
la creazione solo dei 20 aminoacidi che compongono una proteina, sollevando una
eccezione IllegalAminoacido altrimenti.
4) Definire una classe Nucleotidi che espone un membro public static
HashMap<Character, Nucleotide> inizializzato ai quattro tipi di
nucleotidi. La classe non ha costruttori pubblici.
5) Definire una classe concreta Aminoacidi che espone un membro public
static HashMap<Character, Aminoacido> inizializzato ai venti tipi
di aminoacidi.1 La classe non ha costruttori pubblici.
6) Definire una classe astratta Polimero che parzialmente definita di seguito.
1
Per brevit riportare nellHashMap solo qualcuno dei 20 amminoacidi.
public abstract class Polimero {

protected ListaSemplice sequenza = null;
public String toString() { };
}
La classe dispone di una lista ove memorizzare una sequenza di monomeri e di un
metodo toString che converte il polimero in una stringa.
7) ListaSemplice una interfaccia cos definita:
public interface ListaSemplice {
public void add(Object o); // aggiunge o in coda
public void reset(); // si posiziona sul primo elem.
public Object next(); // restituisce elem. puntato
public boolean hasNext(); // verifica che ci siano
// altri elementi
}
8) Scrivere una classe AList che implementa linterfaccia ListaSemplice.
9) Derivare da Polimero due classi concrete, DNA e Proteina, che consentono
rispettivamente la creazione di sequenze di DNA e proteine utilizzando solo
riferimenti a nucleotidi inizializzati nella classe Nucleotidi o aminoacidi
inizializzati nella classe degli Aminoacidi (vedi esempio in figura).
Nucleotidi
Ognuna delle due classi ha un costruttore pubblico che prende in input una stringa
e crea una istanza di quel polimero.
10) Scrivere una classe Test con metodo main che crea e stampa una istanza di
DNA e una di proteina.
java jar prova.jar

Si vuole progettare una struttura dati per gestire la ricezione di messaggi
comunicati con protocollo TCP/IP. Il messaggio composto di diversi datagrammi
(detti anche pacchetti) che possono giungere in un ordine qualunque (non
necessariamente nello stesso ordine logico di frammentazione del messaggio). Un
datagramma contiene le seguenti informazioni: indirizzo IP sorgente, indirizzo IP
destinazione, identificativo, dati (in forma di stringa) e un flag che indica se il
datagramma lultimo del messaggio. Lidentificativo un numero progressivo (0,
1, 2, 3, ), che identifica lordine in cui i dati convogliati nei diversi datagrammi
devono essere ricomposti. Si definisca quindi una classe Datagramma con i
seguenti membri privati:
- InetAddress sorgente
- InetAddress destinazione
- String dati
- boolean ultimo
La struttura dati utilizzata per memorizzare i datagrammi di un messaggio la lista
indicizzata, che consente di inserire gli elementi nelle posizioni stabilite da un
indice, che assume valori 0, 1, 2, 3, . La lista indicizzata ha una interfaccia cos
definita:
public interface ListaIndicizzata <T> {
public T getElement(int i); //
}
secondo metodo aggiunge un elemento non nullo in posizione i-esima, il terzo
metodo restituisce lelemento di posizione i-esima se questa occupata e solleva
una eccezione undefinedElement altrimenti, e il quarto metodo restituisce il
numero di posizioni effettivamente occupate.
Definire una classe ListaIndicizzataRD che implementa linterfaccia di cui
sopra, ricorrendo alla tecnica del raddoppiamento/dimezzamento (halving
doubling) per gestire al run-time la variabilit dellindice.
Quindi definire una classe Messaggio che destinata a contenere i datagrammi
di un singolo messaggio. Essa parzialmente definita come segue:

public class Messaggio {
private ListaIndicizzata<Datagramma> messaggio =
new ListaIndicizzataRD<Datagramma>();
private int ultimo = -1; // indice dg chiusura msg
//metodi ...
}
I metodi di cui dotata la classe Messaggio sono i seguenti:
addDatagramma(Datagramma) void aggiunge un datagramma al messaggio
posizionandolo nella posizione corretta
completo() boolean
verifica se un messaggio completo,
cio sono stati aggiunti tutti i
datagrammi che lo compongono
esisteDatagramma(int) boolean
verifica se un datagramma stato
incluso o meno nella posizione
specificata dallargomento
datagramma(int) Datagramma
restituisce il datagramma nella posizione
specificata dallargomento
toString() String
tutti i pacchetti del messaggio,
scandendo la lista con indice che varia
da 0 fino allultimo valore valido.
Implementare la classe testaMessaggio dotata di un metodo public
static void main(), che genera in ordine casuale i 10 datagrammi di un
messaggio, li memorizza e quindi stampa il messaggio per intero.
java jar prova.jar

Si intende studiare il tempo di attesa per la registrazione di imbarco (check-in) agli
sportelli della compagnia aerea ALITARE dellaeroporto di Roma. In generale, pi
sportelli ci sono per la registrazione, meno tempo necessario. Il manager responsabile
dello scalo vuole evitare lunghe code ai clienti della compagnia, ma allo stesso tempo
vuole ridurre il numero di sportelli, perch ognuno incide notevolmente sul budget a
disposizione. Occorre quindi simulare leffetto dellaggiunta di sportelli sui tempi di
attesa. La simulazione si baser sulle seguenti assunzioni:
1) c una sola coda di attesa e la politica di servizio FIFO (first-in, first-out);
2) i clienti arrivano con un tempo variabile fra i 10 e i 20 secondi (la distribuzione
nellintervallo uniforme);
3) se c uno sportello libero, il cliente viene subito servito;
4) lelaborazione del cliente richiede in media 2 minuti (120 secondi) da quando esso
viene chiamato al primo sportello libero.
Si definisca quindi una classe Cliente con i seguenti membri privati:
- int tempoArrivo
- int tempoPartenza
che conservano, rispettivamente, il tempo in cui il cliente entra in coda e il tempo in cui
lascia lo sportello. Per comodit i tempi sono riportati direttamente in secondi. Il tempo
di attesa del cliente la differenza fra tempo di partenza e tempo di arrivo. La
simulazione inizia al tempo 0.
La simulazione creer una coda di 100 clienti che arriveranno in successione con un
tempo variabile fra i 10 e i 20 secondi. Quindi si proceder a servire la coda, calcolando
per ogni cliente listante in cui lascer uno sportello dopo essere stato servito. Per
stabilire ci, si assocer a ogni sportello un tempoSportello che rappresenta
listante in cui lo sportello si libera. Ad esempio, se il tempo di arrivo del cliente
selezionato 141 e ci sono due sportelli, con, rispettivamente, tempoSportello =
236 e tempoSportello=317, quel cliente sar stato servito solo al tempo 356
(236+120), cio per quel cliente tempoPartenza=317. Mentre se la situazione dei
due sportelli , rispettivamente, tempoSportello = 236 e tempoSportello
=120, quel cliente verr servito al tempo 240 (120+120), cio tempoPartenza=240.
Si vuole calcolare il tempo medio di attesa dei 100 clienti al variare del numero di
sportelli, da 1 a 10. Pertanto si chiede quanto segue:
1) Definire una coda che implementi, mediante rappresentazione collegata, la seguente
interfaccia:
public interface Coda <T> {

public void enqueue(T e);
public T first(); //
public void dequeue();
}
Essa parzialmente definita di seguito.
public class CodaCollegata<T> implements Coda<T> {
private Record<T> inizio = null; //punta al 1 elemento
private Record<T> fine = null; //punta allultimo elem.
//metodi ...
}
Completare limplementazione di CodaCollegata<T>, di Record<T> e delle
eventuali classi previste per le condizioni eccezionali. Linterfaccia e le tre classi
devono far parte di un unico package coda.
2) Implementare la classe Cliente, garantendo che essa implementi i seguenti
metodi di istanza:
getOraArrivo restituisce lora di arrivo del cliente
setOraPartenza imposta lora di partenza del cliente
getOraPartenza restituisce lora di partenza del cliente
tempoAttesa restituisce il tempo di attesa
3) Implementare la classe simulaCodaCheck-in che definisce delle costanti
PROCESSA=120, MAX_SPORTELLI=10, NUM_CLIENTI=100, e dispone di
un metodo inizializza, che genera la coda di 100 clienti con tempo di arrivo
fra luno e laltro che come un numero pseudocasuale fra 10 e 20;
un metodo tempoMedioAttesa, che, utilizzando una variabile int[]
tempoSportello, calcola il tempo medio di attesa quando il numero di sportelli
(numSportelli) un valore specifico compreso fra 1 e MAX_SPORTELLI;
un metodo public static void main(), che calcola e stampa il tempo
medio di attesa simulando code a n sportelli, con n variabile fra 1 e
MAX_SPORTELLI. Il metodo main stampa anche il numero minimo di sportelli
necessario a garantire un tempo di attesa di massimo 600 secondi.
java jar prova.jar

Si vuole un programma che consenta di trovare un percorso in un labirinto. Il
labirinto rappresentato da una matrice quadrata di interi, dove 0 rappresenta una
cella occupata da una parete, mentre 1 rappresenta una cella di un percorso. Un
esempio di labirinto mostrato in basso, dove la cella in alto a sinistra (verde) indica
il punto di partenza del percorso, mentre quella in basso a destra (rosso) indica il
punto di arrivo. Queste due posizioni sono sempre libere.
Il labirinto potr essere rappresentato dalla seguente struttura dati:

private int [][] grid = { {1, 1, 0, 1, 1},
{1, 0, 1, 1, 1},
{1, 1, 1, 0, 1},
{1, 0, 0, 1, 1},
{0, 1, 1, 1, 1} };
Per attraversare il labirinto si contrassegner il percorso cambiando gli 1 in 3 e
mettendo in una pila solo le mosse valide. Una mossa valida se la cella in cui ci si
sposta:
i)
nei confini del labirinto;
ii)
contiene un 1 (cio non una parete e non gi stata esplorata).
1) Scrivere una classe PilaCollegata<T>
interfaccia
public interface Pila<T> {
public T top(); //
public void pop();
}
che implementi la seguente
e che utilizza una rappresentazione collegata. Essa parzialmente definita di

seguito.
public class PilaCollegata<T> implements Pila<T> {

private Record<T> top = null; //punta allelemento top
//metodi ...
}
La classe Record<T> ha due variabili di istanza:
T elem memorizza linformazione
Record<T> next ha il riferimento allelemento successivo
Si riportano di seguito due metodi di PilaCollegata<T>:
public boolean isEmpty() {
return top == null;
}
public void pop(){
if isEmpty() throw new
EccezioneStrutturaVuota("Pila vuota");
top = top.next;
}
Completare limplementazione di PilaCollegata<T>, di Record<T> e di
EccezioneStrutturaVuota. Linterfaccia e le tre classi devono far parte di
un unico package pila.
2) Implementare la classe Posizione per incapsulare le coordinate di una
posizione nel labirinto.
3) Implementare la classe Labirinto che conserva la matrice del labirinto, e
utilizzando una Pila<Posizione> permette di esplorare il labirinto alla
ricerca di un percorso che porti dalla posizione iniziale a quella finale. La classe
Labirinto ha i seguenti metodi:
a. boolean attraversa(), che attraversa il labirinto dalla posizione di
partenza fino a quella finale, memorizzando nella pila le mosse valide. Il
metodo restituisce true se si riesce a trovare un percorso, false
altrimenti.
b. boolean valido(int riga, int colonna), che stabilisce se
una specifica locazione valida.
c. public static void main(), che invoca attraversa e
comunica se stato in grado di trovare un percorso o meno.
java jar prova.jar

Si vuole un programma per la memorizzazione dei caratteri costituenti una stringa e la
verifica che la stringa sia un palindromo, cio che si possa leggere indifferentemente da
sinistra a destra o viceversa. La lunghezza della stringa non nota a priori, inoltre la
naturale sequenzialit dei caratteri della stringa orienta la scelta della struttura dati
verso una lista. Pertanto si chiede di:
1) Scrivere una classe WODoubleLinkedList
interfaccia
che implementi la seguente
public interface AOLista {

public Posizione firstList();
public void insert(Object e, Posizione p);
public Posizione succ(Posizione p);
public Posizione pred(Posizione p);
public boolean endList(Posizione p);
public Object readList(Posizione p);
}
che permette di definire delle liste add-only, cio nelle quali possibile solo
aggiungere gli elementi, ma che possono essere lette quante volte si vuole, scorrendo
la posizione in avanti o in indietro.
La classe WODoubleLinkedList rappresenta la lista mediante doppi puntatori:

public class WODoubleLinkedList implements AOLista {
private Elemento listHead = new Elemento(null);
// metodi
}
La classe Elemento implementa linterfaccia Posizione e contiene tre attributi

di classe:
Object dato;
Elemento successivo;
Elemento precedente;
dove il primo serve a memorizzare il dato passato al metodo insert, il secondo
un riferimento allelemento successivo nella sequenza, mentre il terzo un
riferimento allelemento precedente. Linterfaccia Posizione cos definita:
public interface Posizione {}
2) Implementare la classe TestPalindromo. La classe, che non ha costruttori
pubblici, dotata di due metodi inizializza1() e inizializza2() che
memorizzano i caratteri di una parola invocando il metodo insert di
WODoubleLinkedList. La differenza fra i due metodi che il primo inizializza
la lista con i caratteri di un palindromo, mentre il secondo no.
3) Dotare la classe TestPalindromo anche di due metodi stampaSD e
stampaDS che stampano i caratteri memorizzati nella lista, leggendoli in
successione, rispettivamente, dal primo allultimo o dallultimo al primo, cio da
sinistra verso destra o da destra verso sinistra.
4) Dotare la classe TestPalindromo di un metodo palindromo() che
restituisce un valore booleano che vero se e solo se la sequenza dei caratteri
memorizzata corrisponde a un palindromo.
5) Dotare la classe TestPalindromo di un main che invoca i metodi
inizializza1, inizializza2, stampaSD, stampaDS, e palindromo in
modo da testare la corretta implementazione dei vari metodi.
java jar prova.jar

Si vuole un programma per la memorizzazione e il calcolo di statistiche relative a
partite di calcio. La memorizzazione deve avvenire in modo ordinato rispetto alla data
in cui si svolta la partita, anche quando le partite sono inserite in modo
cronologicamente non ordinato. Pertanto si chiede di:
1) Scrivere una classe WOListLinked che implementi la seguente interfaccia
public interface ListaOrdinata {
public void insert(Comparable e);
public int numElementi();
Iterator iterator();
}
che permette di definire delle liste write-only, cio nelle quali possibile scrivere
una sola volta, di elementi memorizzati in modo ordinato. La classe
WOListLinked rappresenta la lista mediante puntatori:
head
a1
a2
an-1
an

public class WOListLinked implements Lista {
private Puntatore inizioLista = null;
// altri attributi ...
// metodi ...
}
Il metodo numElementi() restituisce il numero di elementi effettivamente
memorizzati nella lista, mentre il metodo iterator() restituisce un oggetto di
una classe che implementa java.lang.Iterable e permette di scandire la lista
ordinata.

2) Implementare la classe Partita dotata delle variabili di istanza:
Date data
String sqOspitante;
String sqOspitata;
int retiOspitante;
int retiOspitata;
3) Implementare la classe GestionePartite per la gestione delle partite. La classe
dotata di un metodo inizializza che inizializza, riempiendola, la lista delle
partite, invocando il metodo insert di WOListLinked. La classe dotata di un
metodo stampa che stampa lelenco delle partite memorizzate ordinato per data.
4) Dotare la classe GestionePartite anche del metodo:
int partiteVinteOspitante(String sqOspitante, Date d)
che prende in input il nome di una squadra ospitante e restituisce il numero di
partite vinte entro la data specificata.
5) Dotare la classe GestionePartite di un main che invochi i metodi
inizializza
e
stampa,
effettui
diverse
invocazioni
di
partiteVinteOspitante e stampi il risultato.
java jar prova.jar

Si vuole un programma per la memorizzazione e il ritrovamento di informazioni
relative a clienti e fornitori di una ditta. In entrambi i casi abbiamo informazioni su
ragione sociale (String) e sede (String). Dei fornitori si sa dire anche se sono
fornitori principali o secondari, mentre per i clienti si conosce lanno (int) in cui
hanno effettuato il primo ordinativo. In entrambi i casi la chiave di memorizzazione/
ritrovamento data dalla ragione sociale.
1) Scrivere una classe ArrayDoubling che implementi la seguente interfaccia
public interface Tabella {
public void insert(Object e, Comparable k);
public Object search(Comparable k);
}
e che utilizzi la tecnica del raddoppiamento-dimezzamento per garantire un tempo
ammortizzato costante delle operazioni di inserimento. Essa parzialmente
definita di seguito.
public class ArrayDoubling implements Tabella {
// array di coppie (elem,chiave)
private Entry[] S= new Entry[1];
private int n = 0; //numero di coppie inserite
//metodi ...
}
La classe Entry ha due variabili di istanza, chiave che memorizza la chiave di
ricerca e elem che memorizza linformazione associata.
Si riporta di seguito il metodo search:
public Object search(Comparable k) {
if n==0 throw new EccezioneStrutturaVuota("vuota");
for (int i = 0; i<n; i++)
if (k.equals(S[i].chiave)) return S[i].elem;
return null;
}
Completare limplementazione di ArrayDoubling, di Entry e delle eccezioni.

Stabilire quali classi/interfacce inserire nel package tabella.
2) Implementare la classe astratta InfoDitta dotata di una variabile di istanza:
String sede.
Implementare due classi derivate, InfoFornitore e InfoCliente, che
contengono le informazioni specifiche di fornitore (tipologia) e di cliente (anno).
3) Implementare la classe GestioneDitte per la gestione dei clienti e dei fornitori.
La classe dotata di un metodo inizializza che inizializza, riempiendola, la
tabella unica di clienti e fornitori, invocando il metodo insert e passando di volta
in volta istanze di InfoFornitore o di InfoCliente.
4) Dotare la classe GestioneDitte anche del metodo:
tipoDitta ricerca(String ragionesociale)
che prende in input una ragione sociale e restituisce un valore enumerativo di tipo
tipoDitta che assume valori {UNDEFINED, CLIENTE, FORNITORE}. Il
valore restituito sar CLIENTE se la ragione sociale si riferisce a un cliente, e sar
FORNITORE se la ragione sociale si riferisce a un fornitore. Se la ragione sociale
non dovesse essere n di un fornitore n di un cliente, restituisce UNDEFINED.
5) Dotare la classe GestioneDitte di un main che invochi il metodo
inizializza, effettui diverse invocazioni di ricerca, almeno una per ogni
possibile valore di risposta, stampi il risultato della ricerca (il valore enumerativo) e
cancelli lelemento se il risultato non UNDEFINED.
java jar prova.jar

Si vuole un programma per la valutazione di una espressione in notazione polacca. Si
ricorda, che nella notazione polacca o postfissa, gli operatori sono riportati dopo gli
oggetti su cui operano. Ad esempio, la seguente espressione in notazione postfissa:
35 17 40 9 - * + 7 corrisponde alla seguente espressione in notazione infissa:
35+17*(40-9)-7
Per la valutazione dellespressione si pu utilizzare una pila. In particolare,
lalgoritmo per valutare una espressione in notazione polacca il seguente:
scandisci lespressione da sinistra a destra finch non finisce.
Se la stringa letta corrisponde a un operando, inserisci loperando nella pila
Altrimenti (la stringa letta un operatore) rimuovi dalla pila due operandi,
applica loperatore letto e
memorizza il risultato nella pila.
1) Scrivere una classe PilaCollegata che implementi la seguente interfaccia
public interface Pila {
public void push(Object e);
public Object top(); //
public void pop();
}
e che utilizza una rappresentazione collegata. Essa parzialmente definita di
seguito.
public class PilaCollegata implements Pila {
private Record top = null; //punta allelemento top
//metodi ...
}
La classe Record ha due variabili di istanza:
Object elem memorizza linformazione
Record next ha il riferimento allelemento successivo
Si riportano di seguito due metodi di PilaCollegata:

public boolean isEmpty() {
return top == null;
}
public void pop(){
if isEmpty() throw new
EccezioneStrutturaVuota("Pila vuota");
top = top.next;
}
Completare limplementazione di PilaCollegata, di Record e di
EccezioneStrutturaVuota. Linterfaccia e le tre classi devono far parte di
un unico package pila.
2) Implementare la classe Polacca dotata di un metodo
int valuta(String espressione)

che prende in input una espressione ben formata in notazione polacca, riguardante
dei numeri interi e i quattro operatori aritmetici, come la seguente:
123 245 + 127 2 * 1 /
e la valuti, come indicato nellalgoritmo dato, ricorrendo ai servizi offerti da
PilaCollegata.
3) Nel caso in cui le eccezioni non siano ben formate, il metodo valuta deve
sollevare leccezione EccezioneEspressioneNonValida in modo da non
terminare in modo anomalo il programma.
4) Implementare linterfaccia Pila in una classe PilaLinkedList che utilizza i
servizi della classe java.util.LinkedList per la realizzazione della

struttura dati.
5) Implementare una classe PolaccaTest dotata di un main che invochi il
metodo valuta su diverse stringhe e stampi, se le stringhe sono espressioni ben

formate, il risultato della valutazione restituito da valuta, o altrimenti segnali
un errore del tipo la stringa non ben formata.
java jar prova.jar

Tracce Lab Asd

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tracce Lab Asd

Uploaded by

Copyright:

Available Formats

Algoritmi e Strutture Dati / Programmazione II

Corso di Laurea in Informatica e Tecnologie per la Produzione del Software

una sequenza ordinata in senso decrescente di una o pi occorrenze di valori reali

nell'attributo progetto il riferimento a un progetto e nell'attributo

WOListLinked rappresenta la lista mediante puntatori:

Il metodo numElementi() restituisce il numero di elementi effettivamente

Algoritmi e Strutture Dati

a. Il numero degli aventi diritti al voto;

crea una nuova matrice di dimensione NM

Pertanto si chiede quanto segue:

Literatore restituir tutti i valori (significativi o di default) presenti nella matrice,

Al termine della prova lasciare sulla cartella Documenti un file:

Algoritmi e Strutture Dati

ricorrendo ad una rappresentazione indicizzata. Si suggerisce di utilizzare il

Camil Demetrescu, Umberto Ferraro Petrillo, Irene Finocchi, Giuseppe F. Italiano

Algoritmi e Strutture Dati

crea una nuova lista circolare

Pertanto si definisca una interfaccia generica CircList<T> che estende

ovest nord-ovest nord nord-est.

Definire una classe Bussola caratterizzata da un ago che pu essere posizionato su

Programmazione II / Algoritmi e Strutture Dati

Prova di laboratorio: ore 15:00 17:30

Il confronto di due messaggi restituisce un valore negativo/zero/positivo, se e

Algoritmi e Strutture Dati

quindi pubblica i tre volumi e ne fa una stampa.

Algoritmi e Strutture Dati

Le parole del multi-insieme sono formate esclusivamente dalle 26 lettere

crea un nuovo multi-insieme

Un multi-insieme realizzabile tramite un dizionario, dove la chiave la parola

2) Implementare Dictionary<S> mediante un array.

3) Implementare una classe BagOfWords che ha due attributi:

Programmazione II (Algoritmi e Strutture Dati)

Prova di laboratorio: ore 15:00 17:30

Pertanto si definisca una interfaccia PQ<Item> con metodi che corrispondono

Implementare una classe Process con i metodi:

quindi inserendolo nella coda opportuna ed eventualmente cambiandogli la

Programmazione II (Algoritmi e Strutture Dati)

Prova di laboratorio: ore 15:00 17:30

Pertanto si definisca una interfaccia PQ<Item> con metodi che corrispondono

Gestire larray con la tecnica del raddoppiamento/dimezzamento.

inserendolo nella coda opportuna ed eventualmente cambiandogli la priorit (la

Simpo PDF Password Remover Unregistered Version - http://www.simpopdf.com

Algoritmi e Strutture Dati

Prova di laboratorio: ore 15:00 17:30

Pertanto si definisca una interfaccia PQ<Item> con metodi che corrispondono

Simpo PDF Password Remover Unregistered Version - http://www.simpopdf.com

Definire un tipo enumerativo State con valori UNRUNNABLE, RUNNABLE,

Simpo PDF Password Remover Unregistered Version - http://www.simpopdf.com

Algoritmi e Strutture Dati

descritto come segue:

Le specifiche sintattiche del carrello sono le seguenti:

crea un nuovo carrello

Un carrello realizzabile tramite un dizionario, dove la chiave larticolo mentre il

String nome relativa al nome del prodotto (es. Frollini Dixie)

Simpo PDF Password Remover Unregistered Version - http://www.simpopdf.com

public interface Dictionary<V>

Simpo PDF Password Remover Unregistered Version - http://www.simpopdf.com

Algoritmi e Strutture Dati

Simpo PDF Password Remover Unregistered Version - http://www.simpopdf.com

Il costruttore di ItemRecommender dotato di un parametro int N che

Simpo PDF Password Remover Unregistered Version - http://www.simpopdf.com

Algoritmi e Strutture Dati

Simpo PDF Password Remover Unregistered Version - http://www.simpopdf.com

ricorrendo ad una rappresentazione collegata. Si suggerisce di utilizzare il metodo