Esercizio 1
===========
Un gruppo di appassionati di giochi di ruolo dispone di un numero considerevole 
di dadi (che possiamo considerare illimitato). I dadi sono di vario tipo: da 4 
facce, da 5 facce, da 6 facce e, in generale, da k facce, dove k è un qualsiasi 
intero nell'intervallo [4, 20]. I dadi sono tutti regolari, ovvero ogni faccia 
di un dado da k facce esce con frequenza 1/k. Il gruppo inventa un gioco. 
Dato un insieme di n dadi (n>0) da k facce, lanciarli ripetutamente finché la 
somma dei valori di ciascuna faccia visibile sul tavolo non è pari o superiore 
a n*k/2. Si noti che tutti i dadi devono essere lanciati assieme, ogni volta, 
quindi non è possibile mantenerne alcuni sul tavolo. Vince il giocatore che 
raggiunge la sopracitata condizione nel minor numero di lanci. 

ESEMPIO: per n=4 e k=5, se i dadi assumono le facce 2, 1, 2, 3 il giocatore deve 
riprovare (infatti 2+1+2+3=8, che è strettamente minore di n*5/2 = 4*5/2=10). Se 
invece le facce assunte dai dadi sono 2, 4, 3, 4, il giocatore può ovviamente 
fermarsi.


Modellare la classe InsiemeDadi per consentire al gruppo di cimentarsi nel 
gioco, avendo cura di implementare almeno i seguenti metodi.

- private InsiemeDadi(int n, int k): un costruttore privato con due parametri 
  (dal significato intuitivo);

- public static InsiemeDadi leggi(Scanner input): un metodo statico che legge da 
  standard input i parametri n e k e costruisce un'istanza di InsiemeDadi;

- public int gioca(): un metodo che esegue il lancio dei dadi finché la 
  condizione target non è raggiunta; il metodo deve restituire il numero di lanci 
  eseguiti.

Modellare e implementare ogni altra classe o metodo che si ritiene utile ai fini 
dell'esercizio. SUGGERIMENTO: si pensi, ad esempio, ad una classe Dado...



Esercizio 2
===========
Si modelli il metodo "gioca()" dell'esercizio precedente ad un gioco con nuove
regole, descritte di seguito. Dato un insieme di n dadi (n>0) da k facce, 
lanciarli ripetutamente finché almeno metà delle possibili facce sono visibili 
sul tavolo. Si noti che tutti i dadi devono essere lanciati assieme, ogni volta, 
quindi non è possibile mantenerne alcuni sul tavolo. Vince il giocatore che 
raggiunge la sopracitata condizione nel minor numero di lanci. 

ESEMPIO: per n=4 e k=7, se i dadi assumono le facce 2, 2, 4, 4 il giocatore deve 
riprovare. Se invece le facce assunte dai dadi sono 2, 4, 3, 5 il giocatore può 
fermarsi.



Esercizio 3
===========
Si progetti e si implementi in Java un metodo “booleano” che restituisca “true” 
se è verificato quanto descritto di seguito, e restituisca “false” altrimenti. 
Il metodo riceve come parametro una matrice di numeri interi di dimensione n*m; 
si attende in essa una “striscia” di demarcazione che la separa in due parti. 
Questa “striscia” risulta costituita da elementi “vicini” pari a “0”; essa 
consente di individuare una regione sinistra ed una regione destra, nella 
matrice stessa. Si noti che per elementi “vicini” si intendono due elementi 
presenti in due righe consecutive e su colonne che differiscono al più di uno 
(quindi sulla stessa colonna oppure su due colonne adiacenti). Si definiscono le 
due grandezze SOMMA e PRODOTTO come segue: SOMMA è pari alla somma di tutti gli 
elementi presenti nella regione sinistra della matrice, mentre PRODOTTO è pari 
al prodotto di tutti gli elementi presenti nella regione destra. Il metodo 
richiesto dall’esercizio deve restituire “true” se e solo se SOMMA = PRODOTTO. 
NOTA: sia la regione sinistra che quella destra contengono ALMENO un elemento 
per ciascuna riga (questo vuol dire che gli zeri non possono mai trovarsi sulla 
prima colonna, né sull’ultima). ESEMPIO: nella matrice riportata qui sotto, la 
somma degli elementi nella regione sinistra è pari a 72, così come il prodotto 
degli elementi nella regione destra. Il metodo dovrebbe pertanto restituire 
“true”.

 - - - - - - 
|9|7|1|8|0|1|
 - - - - - - 
|3|9|5|0|3|1|
 - - - - - - 
|6|6|0|2|1|2|
 - - - - - - 
|7|9|2|0|3|2|
 - - - - - -