Progetto 2017/18

Questa pagina descrive il progetto per il corso di Informatica della Laurea in Matematica per le sessioni dell'anno accademico 2017/2018.

Il progetto è costituito da due mini-esercizi.

Problema 1: il display a cristalli liquidi

Si consideri un display a cristalli liquidi composto da 16 segmenti, della forma seguente.

display a cristalli liquidi

Ogni segmento può essere nello stato "acceso" oppure "spento". Tutto il display può quindi formare piccole espressioni aritmetiche come ad esempio 3+3,4-3,0-8.

Si chiede di scrivere un programma Java che "legga" l'espressione aritmetica rappresentata dal display, e "scriva" sul display stesso il risultato di tale espressione. Più precisamente:

Formato dei dati

Si chiede di scrivere una funzione Java avente (esattamente) nome e tipo come segue: 

public static String esercizio1(String display) { ... }

Lo stato di tutti e 16 i segmenti è rappresentato come una String Java di lunghezza 16. Il carattere in posizione i nella stringa indica lo stato del cristallo numero i: con '#' si indica un cristallo acceso, con '_' uno spento. (Chiarimento: qui si segue la numerazione che compare sopra in figura.) Questo formato vale sia per il parametro di input alla funzione, sia per il suo output.

Si può supporre che la stringa input sia sempre una stringa lunga 16, contenente solo i caratteri acceso/spento descritti sopra. In tal caso, la funzione deve sempre fornire un risultato nello stesso formato.

In caso di input malformato (stringa non di 16 caratteri, o con caratteri diversi da acceso/spento), non si richiede nessun comportamento particolare. Il programma può dare un risultato qualunque, o anche generare un errore a tempo di esecuzione.

Esempi

Ecco alcuni esempi di input-output attesi. 

8+8 = 16
"################" -> "__#__#___##_####"
4+6 = 10
"_###_#_####_####" -> "__#__#___###_###"
4-6 = -2
"_###_#_#_##_####" -> "_______#_#_###_#"
4-C = EE
"_###_#_#_##__#_#" -> "##_##_#__##_##_#"

Problema 2: sostituzione delle armi in un videogioco

Un personaggio di un videogioco ha con sé un insieme di armi, che si porta dietro e usa nelle sue avventure. A un certo punto nel gioco, il personaggio si imbatte in un negozio di armi, dove può sostituire le armi che ha nel modo seguente.

Il personaggio deve scegliere fino a due armi (quindi 0, 1, o 2) tra quelle possedute, e abbandonarle, consegnandole al negoziante. Successivamente, per ogni arma consegnata in questo modo, il personaggio riceve in cambio un'arma dal negoziante. Le armi così ricevute sono distinte tra loro. Queste sono anche diverse dalle armi che il personaggio possiede in quel momento (ma non necessariamente diverse dalle armi che il personaggio aveva all'inizio).

Per esempio, il personaggio all'inizio ha spada,arco,balestra,fionda,ascia. Decide di abbandonare arco,fionda. Dopo, ha a disposizione spada,balestra,ascia. Il negoziante quindi gli consegna altre due armi tra quelle che ora non ha: alabarda,arco. Alla fine il personaggio ha quindi a disposizione spada,balestra,ascia,alabarda,arco. In questo caso, una delle armi (arco) è stata nuovamente restituita al personaggio.

Si chiede di scrivere una funzione Java che legga da file l'elenco delle armi prima della sostituzione, e l'elenco delle armi dopo la sostituzione. La funzione deve controllare che la sostituzione sia avvenuta correttamente, in base alle regole descritte sopra, e non in altro modo. La funzione Java deve restituire come risultato un booleano: questo deve essere true se e solo se la sostituzione è stata svolta correttamente.

Formato dei dati

Si chiede di scrivere una funzione Java avente (esattamente) nome e tipo come segue: 

public static boolean esercizio2(String nomeFile) { ... }

Alla funzione viene passato un nome di file nomeFile che è garantito esistere, e contenere due righe di testo nella forma seguente. 

armaA1 armaA2 ... armaAN
armaB1 armaB2 ... armaBM

La prima riga elenca le armi prima della sostituzione, la seconda dopo la sostituzione. In ogni riga si trovano i nomi delle armi, separati da un singolo spazio. Il nome di ogni arma è composto da una parola sola, e quindi non contiene spazi al suo interno.

Non c'è un ordine particolare in cui le armi vengono elencate. È possibile che le armi elencate nella prima riga compaiano nella seconda riga in una posizione diversa, o in un ordine diverso rispetto alle altre armi. In una riga la stessa arma compare al massimo una volta (non ci sono ripetizioni).

Il numero di armi N e M è un naturale (quindi maggiore o uguale a zero). Se zero, la riga è vuota.

In caso di errore di IO (per esempio, il nome di file passato come argomento non corrisponde a nessun file) o di input malformato (per esempio, meno di due righe nel file), non si richiede nessun comportamento particolare. Il programma può dare un risultato qualunque, o anche generare un errore a tempo di esecuzione.

Esempi

Ecco alcuni esempi di input-output attesi: 

=== Input:
spada arco
arco spada
=== Output: true
*******************
=== Input:
spada arco
arco
=== Output: false
*******************
=== Input:
spada arco
arco fionda
=== Output: true
*******************
=== Input:
spada arco
arco fionda lancia
=== Output: false
*******************
=== Input:
spada arco
katana mazza
=== Output: true
*******************
=== Input:
cerbottana claymore dardo cannone
laser fucile cannone sciabola
=== Output: false
*******************
=== Input:
cerbottana claymore dardo cannone
claymore fucile cannone sciabola
=== Output: true
*******************
=== Input:
kusarigama naginata
kusarigama kunai
=== Output: true
*******************
=== Input:


=== Output: true
*******************
*******************
=== Input:

spada
=== Output: false

Consigli

Si fa notare che in Java, se s1,s2 sono due variabili di tipo String, il loro confronto tramite s1 == s2 controlla se le due stringhe hanno lo stesso riferimento (sono memorizzate nello stesso posto in memoria), invece dello stesso contenuto (contengono gli stessi caratteri). Per verificare l'uguaglianza del contenuto di due stringhe, bisogna usare invece s1.equals(s2).

Svolgimento

Si chiede di scrivere una singola classe Java Progetto, che contenga entrambe le funzioni esercizio1,esercizio2 con il tipo descritto sopra. Vi viene fornito un scheletro di classe Java.

La classe scheletro va posizionata in un progetto eclipse come segue. Create un progetto eclipse chiamato COGNOME_MATRICOLA (usate i vostri dati), e create la classe Progetto al suo interno nella cartella src. Dovreste ottenere un file come segue:

È obbligatorio utilizzare lo scheletro associato al progetto come è, senza modificare i tipi delle funzioni all'interno, e senza modificare il suo package. È obbligatorio rispettare la posizione del file come descritto sopra.

È invece consentito (e consigliabile) definire delle procedure/funzioni addizionali all'interno della classe Progetto. È consentito aggiungere import per usare librerie di Java.

È consentito modificare il metodo main della classe nello scheletro. Si noti, tuttavia, che tale metodo potrà essere cancellato e sovrascritto, o comunque non eseguito, da chi corregge. Di conseguenza, se si decidono di usare variabili globali, queste devono essere inizializzate dentro le funzioni esercizio1, esercizio2 e non dentro il main, in quanto quest'ultimo non verrà eseguito.

Durante la correzione, verranno ripetutamente chiamate le funzioni esercizio1, esercizio2 della classe scheletro, eseguendo (anche) test automatizzati.

Requisiti e criteri di valutazione

Il progetto verrà valutato secondo i seguenti criteri, che formano un insieme di requisiti sul codice consegnato. Ogni requisito primario è condizione necessaria per il superamento della prova: anche se uno di questi non viene rispettato, la prova non è superata. I requisiti secondari devono essere generalmente rispettati. Nel caso ci siano solo minori violazioni di tali requisiti, la prova è comunque superata. Violazioni gravi possono comunque causare il non superamento della prova.

Requisiti tecnici (primario). La soluzione consegnata deve seguire lo scheletro di progetto fornito sopra, modificato nel modo descritto sopra.

Devono inoltre essere rispettati questi requisiti:

  1. Non modificate il nome della classe Progetto, i nomi o i tipi delle funzioni esercizio1, esercizio2. Non aggiungete o modificate il package della classe.
  2. Posizionate la classe Progetto come descritto sopra nel vostro progetto eclipse.
  3. Nel secondo esercizio, il file di input devono essere letto aprendo il file il cui nome viene passato come parametro. Non deve essere usato un altro come nome di file di input.
  4. Le funzioni esercizio1, esercizio2 non devono interagire con l'utente in nessun modo (ad es., chiedere dati all'utente). I nostri test devono potere chiamare ripetutamente quelle funzioni in modo automatico, senza il nostro intervento. Il main invece può interagire con l'utente, se desiderato (ma comunque come detto sopra il codice del main può essere ignorato da noi durante i test.)
  5. Non usate lettere accentate nei vostri file Java, neppure all'interno delle stringhe o dei commenti. (In passato hanno creato problemi di compilazione, visto che i sorgenti arrivavano in encoding diversi.)

Il non rispettare questi requisiti tecnici può causare il fallimento dei nostri test automatizzati, ed in tal caso la prova non sarà superata.

Correttezza (primario). Non ci devono essere errori a tempo di compilazione: il programma deve compilare. Non ci devono essere errori a tempo di esecuzione: il programma non deve generare eccezioni (per esempio, DivisionByZero oppure ArrayIndexOutOfBounds) quando eseguito su un input valido. Il programma deve dare l'output desiderato su qualunque input compatibile con la specifica.
Nota bene: Nel caso il programma sia scorretto, non è compito di chi corregge fare il debugging, ovvero identificare la causa dell'errore e suggerire una modifica per rimuoverla. Anche quando tale causa fosse nota a chi corregge, non verrà comunicata allo studente, in quanto sarebbe come suggerire una parte non banale della soluzione della prova. Infatti, capita frequentemente che correggere l'errore dopo averlo individuato diventi banale ("devo usare x, e non x+1"), e che la prova di conseguenza consista prevalentemente nella ricerca dell'errore.
Corollario: se provando il programma su un insieme di input campione si riscontrano già errori di correttezza, chi corregge non è tenuto ad esaminare il codice del programma.

Leggibilità (secondario). Il codice deve essere scritto in modo tale da permettere ad un altro programmatore di comprenderne la logica. Non è sufficiente che il codice "funzioni", o che sia chiaro a chi lo ha scritto. Per aiutare la lettura del codice da parte di altri, si consiglia di usare dei nomi di variabile e di funzione appropriati, strutturare il codice adeguatamente (dove ha senso, meglio dividere una funzione lunga in più funzioni ausiliarie), e di inserire dei commenti.

Non commentate come state calcolando qualcosa, commentate piuttosto cosa state calcolando. Per esempio, il seguente commento è altamente inutile: 

	// incremento i
	i++;

Al contrario, il seguente aiuta a comprendere il codice: 

	// passo a coordinate polari
	rho = Math.sqrt(x*x + y*y);
	theta = Math.atan2(y, x);

Consegna del progetto

Per potere partecipare allo scritto di una sessione di esame, il progetto deve essere consegnato entro le date indicate nell'elenco delle sessioni di esame. La consegna si svolge mandando una email avente esattamente le seguenti caratteristiche.

Note Finali

Se avete dubbi sul testo del progetto, ovvero su che cosa vi sta venendo chiesto, chiedete pure delucidazioni per email o a ricevimento. Se invece avete dubbi sulla soluzione dell'esercizio, ovviamente non possiamo suggerirvi nulla.

Il progetto non viene svolto in un ambiente "controllato" come per esempio avviene per un esame scritto, ma vi viene lasciata libertà di svolgerlo dove e quando preferite (compatibilmente con le scadenze). Per esempio, potete usare i laboratori quando liberi, o farlo su un vostro computer personale.

Il progetto è individuale, non di gruppo. Tuttavia, vi è consentito discutere del progetto con altre persone per scambiarsi opinioni a riguardo. Non è consentita, ovviamente, la copia di pezzi di codice inerenti al progetto da uno studente all'altro. Allo stesso modo, farsi fare il progetto da un'altra persona è considerato equivalente a copiare. In caso di dubbi sull'autenticità del progetto, ci riserviamo la possibilità di convocarvi per un colloquio sul codice che avete consegnato, anche dopo l'esame scritto.

Vi è consentito di "copiare" invece pezzi di codice che vi abbiamo fornito noi, o di "tradurre in Java" dei pezzi di codice che potreste trovare su qualche libro o tutorial online. In questo caso, però, dovete obbligatoriamente citare la fonte in un commento nel codice.

Il discutere del progetto su forum di discussione su Internet o simili non è vietato a prescindere, ma è soggetto alle stesse regole della comunicazione tra altri studenti. Inoltre, se iniziate una discussione su un forum riguardo al progetto, dovete obbligatoriamente dichiarare 1) che l'esercizio in questione è un progetto di esame, e 2) che non desiderate che qualcuno vi scriva una soluzione al posto vostro. Se anche chiarendo ciò qualcuno vi risponde includendo del codice, voi non potete includerlo nel progetto.

Risposte a domande degli studenti

Se preferite, potete usare anche caratteristiche di Java non viste a lezione (costrutti, librerie, ...), anche se il progetto si può svolgere benissimo senza. Dovete però comprendere il codice che state usando: se venite chiamati ad un colloquio (vedi sopra) vi può essere chiesto di spiegarlo.

Se, nell'input dell'esercizio 1, l'operazione è completamente spenta (segmenti 7 e 8 spenti), l'operazione è da considerarsi come non valida e quindi il risultato è la configurazione d'errore. Lo stesso vale per una o più cifre completamente spente nell'input.

Informatica - Teaching - Home

Valid CSS Valid XHTML 1.1 Roberto Zunino, 2017