1 Esercizio 1.
   2 ============
   3 Si implementi in Java un metodo RICORSIVO che, ricevuto un array di interi, 
   4 restituisca il valore massimo in esso contenuto. 
   5 
   6 SOLUZIONE
   7 ---------
   8 public static int maxInArrayRicorsivoLineare ( int a[], int pos, int maxCorrente ) {
   9             if (pos >= a.length) 
  10                   return maxCorrente;
  11             if (a[pos] > maxCorrente)
  12                   maxCorrente = a[pos];
  13             return maxInArrayRicorsivoLineare ( a, pos+1, maxCorrente );
  14       }
  15 
  16 
  17 ESERCZIO 2.
  18 ===========
  19 Creare in Java una classe "Insieme" che rappresenti un insieme matematico di
  20 numeri interi compresi tra 0 e 20. Definire per la classe i seguenti metodi, 
  21 oltre a costruttore, metodi equals() e toString(). 
  22 
  23 
  24  - aggiungi 
  25  
  26 che dato un intero lo aggiunga all'insieme; 
  27 
  28  - elimina
  29  
  30 che dato un intero lo elimini dall'insieme; 
  31 
  32  - cardinalità
  33  
  34 che restituisca la cardinalità dell'insieme;
  35  
  36  - vuoto
  37 
  38 che restituisca true se l'insieme è vuoto, false altrimenti;
  39  
  40  - tuttoUniverso
  41  
  42 che restituisca true se l'insieme contiene tutti gli elementi del dominio
  43 considerato (tutti gli interi da 0 a 20 nel nostro caso), false altrimenti;
  44  
  45  - complementare
  46  
  47 che restituisca un nuovo insieme contenente tutti e soli gli elementi del dominio
  48 non presenti nell'insieme;
  49  
  50  - unione
  51  
  52 che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro unione;
  53  
  54  - intersezione
  55  
  56 che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro intersezione;
  57  
  58  - differenza
  59  
  60 che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro differenza;
  61  
  62  - differenzaSimmetrica
  63  
  64 che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro differenza simmetrica;
  65  
  66  - sottoinsiemeDi
  67  
  68 che, dato un secondo insieme, restituisca true se l'insieme è un suo sottoinsieme, false altrimenti; 
  69  
  70  - sovrainsiemeDi
  71  
  72 che, dato un secondo insieme, restituisca true se l'insieme è un suo sovrainsieme, false altrimenti; 
  73  
  74  - Leggi
  75  
  76 che legga da input un insieme. Si può scegliere di realizzare tale metodo in due modi alternativi.
  77 
  78   - Prima possibilità (più semplice):
  79     si richiede in input una sequenza di numeri interi (appartenenti al dominio considerato) terminata
  80     da -1. I numeri introdotti costituiranno gli elementi dell'insieme.
  81 
  82   - Seconda possibilità:
  83     si richiede di introdurre l'insieme come stringa opportunamente formattata, cioè numeri separati
  84     da virgole e racchiusi tra parentesi graffe. Sarà il metodo a preoccuparsi di scandire la stringa
  85     in input in modo da ricavare gli elementi da memorizzare nell'insieme.
  86 
  87 
  88 Scrivere poi un programma (con un main()) che legga da input un insieme e ne calcoli la cardinalità
  89 ed il complementare.
  90 Letto poi un secondo insieme, applicare ai due insiemi le varie operazioni definite per la classe
  91 e stamparne il risultato. 
  92 
  93 SOLUZIONE
  94 ---------
  95 import java.util.*;
  96 
  97 public class Insieme {
  98 
  99     private boolean[] presente;
 100 
 101     public Insieme() {
 102 	presente = new boolean[20];
 103 	for(int i = 0; i < presente.length; i++)
 104 	    presente[i] = false;
 105     }
 106     
 107     public String toString() {
 108 	String s = "{";
 109 	boolean primo = true;
 110 	for(int i = 0; i < presente.length; i++)
 111 	    if(presente[i]) {
 112 		if(primo) {
 113 		    primo = false;
 114 		    s += i;
 115 		}
 116 		else
 117 		    s += "," + i;
 118 	    }
 119 	return s + "}";
 120     }
 121     
 122     public void aggiungi(int x) {
 123 	presente[x] = true;
 124     }
 125     
 126     public void elimina(int x) {
 127 	presente[x] = false;
 128     }
 129     
 130     public int cardinalita() {
 131 	int count = 0;
 132 	for(int i = 0; i < presente.length; i++)
 133 	    if(presente[i])
 134 		count++;
 135 	return count;
 136     }
 137     
 138     public boolean vuoto() {
 139 	return cardinalita() == 0;
 140     }
 141     
 142     public boolean universo() {
 143 	return cardinalita() == presente.length;
 144     }
 145     
 146     public Insieme inverso() {
 147 	Insieme ris = new Insieme();
 148 	for(int i = 0; i < ris.presente.length; i++)
 149 	    ris.presente[i] = !(this.presente[i]);
 150 	return ris;
 151     }
 152     
 153     public Insieme unione(Insieme A) {
 154 	Insieme ris = new Insieme();
 155 	for(int i = 0; i < ris.presente.length; i++)
 156 	    ris.presente[i] = this.presente[i] || A.presente[i];
 157 	return ris;
 158     }
 159     
 160     public Insieme intersezione(Insieme A) {
 161 	Insieme ris = new Insieme();
 162 	for(int i = 0; i < ris.presente.length; i++)
 163 	    ris.presente[i] = this.presente[i] && A.presente[i];
 164 	return ris;
 165     }
 166     
 167     public Insieme differenza(Insieme A) {
 168 	Insieme ris = new Insieme();
 169 	for(int i = 0; i < ris.presente.length; i++)
 170 	    ris.presente[i] = this.presente[i] && !(A.presente[i]);
 171 	return ris;
 172     }
 173     
 174     public Insieme differenzaSimmetrica(Insieme A) {
 175 	Insieme AmenoThis = this.differenza(A);
 176 	Insieme thisMenoA = A.differenza(this);
 177 	return thisMenoA.unione(AmenoThis);
 178     }
 179     
 180     public boolean isEquals(Insieme A) {
 181 	for(int i = 0; i < this.presente.length; i++)
 182 	    if(this.presente[i] != A.presente[i])
 183 		return false;
 184 	return true;
 185     }
 186     
 187     public boolean diverso(Insieme A) {
 188 	return !this.isEquals(A);
 189     }
 190     
 191     public boolean sottoinsiemeDi(Insieme A) {
 192 	return this.differenza(A).vuoto();
 193     }
 194     
 195     public boolean sovrainsiemeDi(Insieme A) {
 196 	return A.differenza(this).vuoto();
 197     }
 198     
 199     public static Insieme Leggi(Scanner input){
 200     	Insieme s = new Insieme();
 201     	System.out.println("Inserisci l'insieme specificando i suoi elementi racchiusi tra {} e separati da ,");
 202     	String ins = input.next();
 203     	String[] numeri = ins.substring(1, ins.length()-1).split(",");
 204     	for(int i=0; i<numeri.length; i++)
 205     		s.aggiungi(Integer.parseInt(numeri[i]));
 206     	return s;
 207     }  
 208 }
 209 
 210 import java.util.*;
 211 
 212 public class TestInsieme {
 213 
 214     public static void main(String[] args) {
 215     Scanner input = new Scanner(System.in);
 216 	Insieme A = new Insieme();
 217 	A.aggiungi(1);
 218 	A.aggiungi(4);
 219 	System.out.println(A.cardinalita());
 220 	System.out.println(A.inverso().inverso());
 221 	A.elimina(1);
 222 	System.out.println(A);
 223 	
 224 	Insieme B = new Insieme();
 225 	B = B.unione(A);
 226 	System.out.println(B);
 227 	B.aggiungi(10);
 228 	B.aggiungi(3);
 229 	System.out.println(B.differenza(A));
 230 	
 231 	A.aggiungi(10);
 232 	System.out.println(B.intersezione(A));
 233 	
 234 	System.out.println(B.differenzaSimmetrica(A));
 235 	Insieme C = Insieme.Leggi(input);
 236 	System.out.println(C);
 237 	
 238     }  
 239 }
 240 
 241 
 242 ESERCZIO 3.
 243 ===========
 244 Si implementi in Java un metodo RICORSIVO avente il seguente prototipo:
 245 
 246     public static boolean verifica (int v[], int i) 
 247 
 248 Il metodo deve restituire true se e solo se l’array “v” è costituito 
 249 da una sequenza alternata di numeri positivi e negativi. In altre parole, 
 250 ogni numero positivo deve sempre essere seguito da un numero negativo, 
 251 ed ogni numero negativo deve sempre essere seguito da un numero positivo. 
 252 Il metodo deve restituire false altrimenti.
 253 
 254 SOLUZIONE
 255 ---------
 256 public static boolean verifica (int v[], int i) {
 257 	if ( i < v.length-1)
 258 		if (v[i] < 0 && v[i+1] < 0 || v[i] > 0 && v[i+1] > 0)
 259 			return false;
 260 		else
 261 			return verifica(v,i+1);
 262 	else
 263 		return true;
 264 }