1 Esercizio 1
   2 ===========
   3 Un gruppo di appassionati di giochi di ruolo dispone di un numero considerevole 
   4 di dadi (che possiamo considerare illimitato). I dadi sono di vario tipo: da 4 
   5 facce, da 5 facce, da 6 facce e, in generale, da k facce, dove k è un qualsiasi 
   6 intero nell'intervallo [4, 20]. I dadi sono tutti regolari, ovvero ogni faccia 
   7 di un dado da k facce esce con frequenza 1/k. Il gruppo inventa un gioco. 
   8 Dato un insieme di n dadi (n>0) da k facce, lanciarli ripetutamente finché la 
   9 somma dei valori di ciascuna faccia visibile sul tavolo non è pari o superiore 
  10 a n*k/2. Si noti che tutti i dadi devono essere lanciati assieme, ogni volta, 
  11 quindi non è possibile mantenerne alcuni sul tavolo. Vince il giocatore che 
  12 raggiunge la sopracitata condizione nel minor numero di lanci. 
  13 
  14 ESEMPIO: per n=4 e k=5, se i dadi assumono le facce 2, 1, 2, 3 il giocatore deve 
  15 riprovare (infatti 2+1+2+3=8, che è strettamente minore di n*5/2 = 4*5/2=10). Se 
  16 invece le facce assunte dai dadi sono 2, 4, 3, 4, il giocatore può ovviamente 
  17 fermarsi.
  18 
  19 
  20 Modellare la classe InsiemeDadi per consentire al gruppo di cimentarsi nel 
  21 gioco, avendo cura di implementare almeno i seguenti metodi.
  22 
  23 - private InsiemeDadi(int n, int k): un costruttore privato con due parametri 
  24   (dal significato intuitivo);
  25 
  26 - public static InsiemeDadi leggi(Scanner input): un metodo statico che legge da 
  27   standard input i parametri n e k e costruisce un'istanza di InsiemeDadi;
  28 
  29 - public int gioca(): un metodo che esegue il lancio dei dadi finché la 
  30   condizione target non è raggiunta; il metodo deve restituire il numero di lanci 
  31   eseguiti.
  32 
  33 Modellare e implementare ogni altra classe o metodo che si ritiene utile ai fini 
  34 dell'esercizio. SUGGERIMENTO: si pensi, ad esempio, ad una classe Dado...
  35 
  36 
  37 
  38 Esercizio 2
  39 ===========
  40 Si modelli il metodo "gioca()" dell'esercizio precedente ad un gioco con nuove
  41 regole, descritte di seguito. Dato un insieme di n dadi (n>0) da k facce, 
  42 lanciarli ripetutamente finché almeno metà delle possibili facce sono visibili 
  43 sul tavolo. Si noti che tutti i dadi devono essere lanciati assieme, ogni volta, 
  44 quindi non è possibile mantenerne alcuni sul tavolo. Vince il giocatore che 
  45 raggiunge la sopracitata condizione nel minor numero di lanci. 
  46 
  47 ESEMPIO: per n=4 e k=7, se i dadi assumono le facce 2, 2, 4, 4 il giocatore deve 
  48 riprovare. Se invece le facce assunte dai dadi sono 2, 4, 3, 5 il giocatore può 
  49 fermarsi.
  50 
  51 
  52 
  53 Esercizio 3
  54 ===========
  55 Si progetti e si implementi in Java un metodo “booleano” che restituisca “true” 
  56 se è verificato quanto descritto di seguito, e restituisca “false” altrimenti. 
  57 Il metodo riceve come parametro una matrice di numeri interi di dimensione n*m; 
  58 si attende in essa una “striscia” di demarcazione che la separa in due parti. 
  59 Questa “striscia” risulta costituita da elementi “vicini” pari a “0”; essa 
  60 consente di individuare una regione sinistra ed una regione destra, nella 
  61 matrice stessa. Si noti che per elementi “vicini” si intendono due elementi 
  62 presenti in due righe consecutive e su colonne che differiscono al più di uno 
  63 (quindi sulla stessa colonna oppure su due colonne adiacenti). Si definiscono le 
  64 due grandezze SOMMA e PRODOTTO come segue: SOMMA è pari alla somma di tutti gli 
  65 elementi presenti nella regione sinistra della matrice, mentre PRODOTTO è pari 
  66 al prodotto di tutti gli elementi presenti nella regione destra. Il metodo 
  67 richiesto dall’esercizio deve restituire “true” se e solo se SOMMA = PRODOTTO. 
  68 NOTA: sia la regione sinistra che quella destra contengono ALMENO un elemento 
  69 per ciascuna riga (questo vuol dire che gli zeri non possono mai trovarsi sulla 
  70 prima colonna, né sull’ultima). ESEMPIO: nella matrice riportata qui sotto, la 
  71 somma degli elementi nella regione sinistra è pari a 72, così come il prodotto 
  72 degli elementi nella regione destra. Il metodo dovrebbe pertanto restituire 
  73 “true”.
  74 
  75  - - - - - - 
  76 |9|7|1|8|0|1|
  77  - - - - - - 
  78 |3|9|5|0|3|1|
  79  - - - - - - 
  80 |6|6|0|2|1|2|
  81  - - - - - - 
  82 |7|9|2|0|3|2|
  83  - - - - - -