1 /* 
   2 Esercizio 1
   3 -----------
   4 Creare in Java una classe "Insieme" che rappresenti un insieme matematico di
   5 numeri interi compresi tra 0 e 20. Definire per la classe i seguenti metodi, 
   6 oltre a costruttore, metodi equals() e toString(). 
   7 
   8 
   9  - aggiungi 
  10  
  11 che dato un intero lo aggiunga all'insieme; 
  12 
  13  - elimina
  14  
  15 che dato un intero lo elimini dall'insieme; 
  16 
  17  - cardinalità
  18  
  19 che restituisca la cardinalità dell'insieme;
  20  
  21  - vuoto
  22 
  23 che restituisca true se l'insieme è vuoto, false altrimenti;
  24  
  25  - tuttoUniverso
  26  
  27 che restituisca true se l'insieme contiene tutti gli elementi del dominio
  28 considerato (tutti gli interi da 0 a 20 nel nostro caso), false altrimenti;
  29  
  30  - complementare
  31  
  32 che restituisca un nuovo insieme contenente tutti e soli gli elementi del dominio
  33 non presenti nell'insieme;
  34  
  35  - unione
  36  
  37 che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro unione;
  38  
  39  - intersezione
  40  
  41 che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro intersezione;
  42  
  43  - differenza
  44  
  45 che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro differenza;
  46  
  47  - differenzaSimmetrica
  48  
  49 che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro differenza simmetrica;
  50  
  51  - sottoinsiemeDi
  52  
  53 che, dato un secondo insieme, restituisca true se l'insieme è un suo sottoinsieme, false altrimenti; 
  54  
  55  - sovrainsiemeDi
  56  
  57 che, dato un secondo insieme, restituisca true se l'insieme è un suo sovrainsieme, false altrimenti; 
  58  
  59  - Leggi
  60  
  61 che legga da input un insieme. Si può scegliere di realizzare tale metodo in due modi alternativi.
  62 
  63   - Prima possibilità (più semplice):
  64     si richiede in input una sequenza di numeri interi (appartenenti al dominio considerato) terminata
  65     da -1. I numeri introdotti costituiranno gli elementi dell'insieme.
  66 
  67   - Seconda possibilità:
  68     si richiede di introdurre l'insieme come stringa opportunamente formattata, cioè numeri separati
  69     da virgole e racchiusi tra parentesi graffe. Sarà il metodo a preoccuparsi di scandire la stringa
  70     in input in modo da ricavare gli elementi da memorizzare nell'insieme.
  71 
  72 
  73 Scrivere poi un programma (con un main()) che legga da input un insieme e ne calcoli la cardinalità
  74 ed il complementare.
  75 Letto poi un secondo insieme, applicare ai due insiemi le varie operazioni definite per la classe
  76 e stamparne il risultato. 
  77 */ 
  78 
  79 
  80 /////////////////////////////////
  81 // INIZIO FILE Insieme.java 
  82 /////////////////////////////////
  83 public class Insieme {
  84 
  85     private boolean[] presente;
  86 
  87     public Insieme() {
  88 	presente = new boolean[20];
  89 	
  90 	// questo non serve, ma non so se gliel'abbiamo detto
  91 	for(int i = 0; i < presente.length; i++)
  92 	    presente[i] = false;
  93     }
  94     
  95     public String toString() {
  96 	String s = "{";
  97 	boolean primo = true;
  98 	for(int i = 0; i < presente.length; i++)
  99 	    if(presente[i]) {
 100 		if(primo) {
 101 		    primo = false;
 102 		    s += i;
 103 		}
 104 		else
 105 		    s += "," + i;
 106 	    }
 107 	return s + "}";
 108     }
 109     
 110     public void aggiungi(int x) {
 111 	presente[x] = true;
 112     }
 113     
 114     public void elimina(int x) {
 115 	presente[x] = false;
 116     }
 117     
 118     public int cardinalita() {
 119 	int count = 0;
 120 	for(int i = 0; i < presente.length; i++)
 121 	    if(presente[i])
 122 		count++;
 123 	return count;
 124     }
 125     
 126     public boolean vuoto() {
 127 	return cardinalita() == 0;
 128     }
 129     
 130     public boolean universo() {
 131 	return cardinalita() == presente.length;
 132     }
 133     
 134     public Insieme inverso() {
 135 	Insieme ris = new Insieme();
 136 	for(int i = 0; i < ris.presente.length; i++)
 137 	    ris.presente[i] = !(this.presente[i]);
 138 	return ris;
 139     }
 140     
 141     public Insieme unione(Insieme A) {
 142 	Insieme ris = new Insieme();
 143 	for(int i = 0; i < ris.presente.length; i++)
 144 	    ris.presente[i] = this.presente[i] || A.presente[i];
 145 	return ris;
 146     }
 147     
 148     public Insieme intersezione(Insieme A) {
 149 	Insieme ris = new Insieme();
 150 	for(int i = 0; i < ris.presente.length; i++)
 151 	    ris.presente[i] = this.presente[i] && A.presente[i];
 152 	return ris;
 153     }
 154     
 155     public Insieme differenza(Insieme A) {
 156 	Insieme ris = new Insieme();
 157 	for(int i = 0; i < ris.presente.length; i++)
 158 	    ris.presente[i] = this.presente[i] && !(A.presente[i]);
 159 	return ris;
 160     }
 161     
 162     public Insieme differenzaSimmetrica(Insieme A) {
 163 	Insieme AmenoThis = this.differenza(A);
 164 	Insieme thisMenoA = A.differenza(this);
 165 	return thisMenoA.unione(AmenoThis);
 166     }
 167     
 168     public boolean isEquals(Insieme A) {
 169 	for(int i = 0; i < this.presente.length; i++)
 170 	    if(this.presente[i] != A.presente[i])
 171 		return false;
 172 	return true;
 173     }
 174     
 175     public boolean diverso(Insieme A) {
 176 	return !this.isEquals(A);
 177     }
 178     
 179     public boolean sottoinsiemeDi(Insieme A) {
 180 	return this.differenza(A).vuoto();
 181     }
 182     
 183     public boolean sovrainsiemeDi(Insieme A) {
 184 	return A.differenza(this).vuoto();
 185     }
 186     
 187 }
 188 /////////////////////////////////
 189 // FINE   FILE Insieme.java 
 190 /////////////////////////////////
 191 
 192 
 193 
 194 /////////////////////////////////
 195 // INIZIO FILE TestInsieme.java 
 196 /////////////////////////////////
 197 public class TestInsieme {
 198 
 199     public static void main(String[] args) {
 200 	Insieme A = new Insieme();
 201 	A.aggiungi(1);
 202 	A.aggiungi(4);
 203 	System.out.println(A.cardinalita());
 204 	System.out.println(A.inverso().inverso());
 205 	A.elimina(1);
 206 	System.out.println(A);
 207 	
 208 	Insieme B = new Insieme();
 209 	B = B.unione(A);
 210 	System.out.println(B);
 211 	B.aggiungi(10);
 212 	B.aggiungi(3);
 213 	System.out.println(B.differenza(A));
 214 	
 215 	A.aggiungi(10);
 216 	System.out.println(B.intersezione(A));
 217 	
 218 	System.out.println(B.differenzaSimmetrica(A));
 219     }
 220     
 221 }
 222 /////////////////////////////////
 223 // FINE   FILE TestInsieme.java 
 224 /////////////////////////////////
 225 
 226 
 227 
 228 ///////////////////////////////////////////////////////////////////////////////
 229 
 230 
 231 /*
 232 Esercizio 2
 233 -----------
 234 Creare una classe "GrigliaLuminosa" caratterizzata da una matrice quadrata di NxN celle luminose
 235 che possono essere accese o spente.
 236 Definire per la classe i seguenti metodi (oltre al costruttore):
 237 
 238  - accendiTutto/spegniTutto
 239 
 240 due metodi che ripettivamente accendono/spengono tutte le celle luminose;
 241 
 242  - accendiDiagonali/spegniDiagonali
 243  		
 244 due metodi che ripettivamente accendono/spengono le celle luminose situate sulle due diagonali;
 245 
 246  - accendiCornice/spegniCornice
 247  
 248 due metodi che, dato un intero i, ripettivamente accendono/spengono le celle luminose situate sulla
 249 cornice che parte dalla posizione [i,i];
 250 
 251  - visualizza
 252  
 253 che stampa a video un asterisco in corrispondenza di ogni cella luminosa accesa, ed uno spazio bianco
 254 in corrispondenza di ogni cella luminosa spenta.
 255 */
 256 
 257 ////////////////////////////////////////////////////////////////
 258 // ************ NOTA: sono qui proposte 2 soluzioni ALTERNATIVE
 259 // per la classe GrigliaLuminosa **************** 
 260 ////////////////////////////////////////////////////////////////
 261 
 262 
 263 /////////////////////////////////
 264 // INIZIO FILE GrigliaLuminosa.java 
 265 /////////////////////////////////
 266 public class GrigliaLuminosa {
 267 
 268     private int N;
 269     private boolean[][] cella;
 270     
 271     public GrigliaLuminosa(int N) {
 272 	if(N > 0)
 273 	    this.N = N;
 274 	else
 275 	    this.N = 1;
 276 	cella = new boolean[this.N][this.N];
 277 	spegniTutto();
 278     }
 279     
 280     public void accendiTutto() {
 281 	for(int i = 0; i < N; i++)
 282 	    for(int j = 0; j < N; j++)
 283 		cella[i][j] = true;
 284     }
 285     
 286     public void spegniTutto() {
 287 	for(int i = 0; i < N; i++)
 288 	    for(int j = 0; j < N; j++)
 289 		cella[i][j] = false;
 290     }
 291     
 292     public void accendiDiagonali() {
 293 	for(int i = 0; i < N; i++) {
 294 	    cella[i][i] = true;		// diagonale principale
 295 	    cella[i][N-i-1] = true;	// diagonale secondaria
 296 	}
 297     }
 298     
 299     public void spegniDiagonali() {
 300 	for(int i = 0; i < N; i++) {
 301 	    cella[i][i] = false;		// diagonale principale
 302 	    cella[i][N-i-1] = false;	// diagonale secondaria
 303 	}
 304     }
 305     
 306     public void accendiCornice(int c) {
 307 	// vogliamo c <= N/2
 308 	if(c > N/2)
 309 	    c = N-c-1;
 310 	
 311 	for(int i = 0; i < N; i++) {
 312 	    for(int j = 0; j < N; j++) {
 313 		if(((i == c || i == N-c-1) && c <= j && j <= N-c-1 ) ||
 314 			((j == c || j == N-c-1) && (c <= i && i <= N-c-1 )))
 315 		    cella[i][j] = true;
 316 	    }
 317 	}
 318     }
 319     
 320     public void spegniCornice(int c) {
 321 	// vogliamo c <= N/2
 322 	if(c > N/2)
 323 	    c = N-c-1;
 324 	
 325 	for(int i = 0; i < N; i++) {
 326 	    for(int j = 0; j < N; j++) {
 327 		if(((i == c || i == N-c-1) && c <= j && j <= N-c-1 ) ||
 328 			((j == c || j == N-c-1) && (c <= i && i <= N-c-1 )))
 329 		    cella[i][j] = false;
 330 	    }
 331 	}
 332     }
 333     
 334     public void visualizza() {
 335  	for(int i = 0; i < N; i++) {
 336 	    for(int j = 0; j < N; j++) {
 337 		if(cella[i][j])
 338 		    System.out.print("*");
 339 		else
 340 		    System.out.print(" ");
 341 	    }
 342 	    System.out.println();
 343 	}
 344     }   
 345 }
 346 /////////////////////////////////
 347 // FINE   FILE GrigliaLuminosa.java 
 348 /////////////////////////////////
 349 
 350 
 351 
 352 /////////////////////////////////
 353 // INIZIO FILE GrigliaLuminosa2.java 
 354 /////////////////////////////////
 355 public class GrigliaLuminosa2 {
 356 
 357     private int N;
 358     private boolean[][] cella;
 359     
 360     public GrigliaLuminosa2(int N) {
 361 	if(N > 0)
 362 	    this.N = N;
 363 	else
 364 	    this.N = 1;
 365 	cella = new boolean[this.N][this.N];
 366 	spegniTutto();
 367     }
 368     
 369     private void setTutto(boolean value) {
 370 	for(int i = 0; i < N; i++)
 371 	    for(int j = 0; j < N; j++)
 372 		cella[i][j] = value;
 373     }
 374     
 375     public void accendiTutto() {
 376 	setTutto(true);
 377     }
 378     
 379     public void spegniTutto() {
 380 	setTutto(false);
 381     }
 382     
 383     private void setDiagonali(boolean value) {
 384 	for(int i = 0; i < N; i++) {
 385 	    cella[i][i] = value;	// diagonale principale
 386 	    cella[i][N-i-1] = value;	// diagonale secondaria
 387 	}
 388     }
 389     
 390     public void accendiDiagonali() {
 391 	setDiagonali(true);
 392     }
 393     
 394     public void spegniDiagonali() {
 395 	setDiagonali(false);
 396     }
 397 
 398     private void setCornice(int c, boolean value) {
 399 	// vogliamo c <= N/2
 400 	if(c > N/2)
 401 	    c = N-c-1;
 402 	
 403 	for(int i = 0; i < N; i++) {
 404 	    for(int j = 0; j < N; j++) {
 405 		if(((i == c || i == N-c-1) && c <= j && j <= N-c-1 ) ||
 406 			((j == c || j == N-c-1) && (c <= i && i <= N-c-1 )))
 407 		    cella[i][j] = value;
 408 	    }
 409 	}
 410     }
 411     
 412     public void accendiCornice(int c) {
 413 	setCornice(c, true);
 414     }
 415     
 416     public void spegniCornice(int c) {
 417 	setCornice(c, false);
 418     }
 419     
 420     public void visualizza() {
 421 	for(int i = 0; i < N; i++) {
 422 	    for(int j = 0; j < N; j++) {
 423 		if(cella[i][j])
 424 		    System.out.print("*");
 425 		else
 426 		    System.out.print(" ");
 427 	    }
 428 	    System.out.println();
 429 	}
 430     }
 431     
 432 }
 433 /////////////////////////////////
 434 // FINE   FILE GrigliaLuminosa2.java 
 435 /////////////////////////////////
 436 
 437 
 438 
 439 /////////////////////////////////
 440 // INIZIO FILE TestGrigliaLuminosa.java 
 441 /////////////////////////////////
 442 public class TestGrigliaLuminosa {
 443 
 444     public static void main(String[] args) {
 445 	GrigliaLuminosa g = new GrigliaLuminosa(5);
 446 	
 447 	System.out.println("Tutto spento");
 448 	g.visualizza();
 449 	
 450 	System.out.println("Tutto acceso");
 451 	g.accendiTutto();
 452 	g.visualizza();
 453 	
 454 	System.out.println("Tutto spento");
 455 	g.spegniTutto();
 456 	g.visualizza();
 457 	
 458 	System.out.println("Diagonali accese");
 459 	g.accendiDiagonali();
 460 	g.visualizza();
 461 	
 462 	System.out.println("Tutto acceso tranne diagonali");
 463 	g.accendiTutto();
 464 	g.spegniDiagonali();
 465 	g.visualizza();
 466 	
 467 	System.out.println("Solo cornice 1");
 468 	g.spegniTutto();
 469 	g.accendiCornice(1);
 470 	g.visualizza();
 471     }
 472     
 473 }
 474 /////////////////////////////////
 475 // FINE   FILE TestGrigliaLuminosa.java 
 476 /////////////////////////////////