/* 
Esercizio 1
-----------
Creare in Java una classe "Insieme" che rappresenti un insieme matematico di
numeri interi compresi tra 0 e 20. Definire per la classe i seguenti metodi, 
oltre a costruttore, metodi equals() e toString(). 


 - aggiungi 
 
che dato un intero lo aggiunga all'insieme; 

 - elimina
 
che dato un intero lo elimini dall'insieme; 

 - cardinalità
 
che restituisca la cardinalità dell'insieme;
 
 - vuoto

che restituisca true se l'insieme è vuoto, false altrimenti;
 
 - tuttoUniverso
 
che restituisca true se l'insieme contiene tutti gli elementi del dominio
considerato (tutti gli interi da 0 a 20 nel nostro caso), false altrimenti;
 
 - complementare
 
che restituisca un nuovo insieme contenente tutti e soli gli elementi del dominio
non presenti nell'insieme;
 
 - unione
 
che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro unione;
 
 - intersezione
 
che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro intersezione;
 
 - differenza
 
che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro differenza;
 
 - differenzaSimmetrica
 
che, dato un secondo insieme, restituisca un nuovo insieme ottenuto dalla loro differenza simmetrica;
 
 - sottoinsiemeDi
 
che, dato un secondo insieme, restituisca true se l'insieme è un suo sottoinsieme, false altrimenti; 
 
 - sovrainsiemeDi
 
che, dato un secondo insieme, restituisca true se l'insieme è un suo sovrainsieme, false altrimenti; 
 
 - Leggi
 
che legga da input un insieme. Si può scegliere di realizzare tale metodo in due modi alternativi.

  - Prima possibilità (più semplice):
    si richiede in input una sequenza di numeri interi (appartenenti al dominio considerato) terminata
    da -1. I numeri introdotti costituiranno gli elementi dell'insieme.

  - Seconda possibilità:
    si richiede di introdurre l'insieme come stringa opportunamente formattata, cioè numeri separati
    da virgole e racchiusi tra parentesi graffe. Sarà il metodo a preoccuparsi di scandire la stringa
    in input in modo da ricavare gli elementi da memorizzare nell'insieme.


Scrivere poi un programma (con un main()) che legga da input un insieme e ne calcoli la cardinalità
ed il complementare.
Letto poi un secondo insieme, applicare ai due insiemi le varie operazioni definite per la classe
e stamparne il risultato. 
*/ 


/////////////////////////////////
// INIZIO FILE Insieme.java 
/////////////////////////////////
public class Insieme {

    private boolean[] presente;

    public Insieme() {
	presente = new boolean[20];
	
	// questo non serve, ma non so se gliel'abbiamo detto
	for(int i = 0; i < presente.length; i++)
	    presente[i] = false;
    }
    
    public String toString() {
	String s = "{";
	boolean primo = true;
	for(int i = 0; i < presente.length; i++)
	    if(presente[i]) {
		if(primo) {
		    primo = false;
		    s += i;
		}
		else
		    s += "," + i;
	    }
	return s + "}";
    }
    
    public void aggiungi(int x) {
	presente[x] = true;
    }
    
    public void elimina(int x) {
	presente[x] = false;
    }
    
    public int cardinalita() {
	int count = 0;
	for(int i = 0; i < presente.length; i++)
	    if(presente[i])
		count++;
	return count;
    }
    
    public boolean vuoto() {
	return cardinalita() == 0;
    }
    
    public boolean universo() {
	return cardinalita() == presente.length;
    }
    
    public Insieme inverso() {
	Insieme ris = new Insieme();
	for(int i = 0; i < ris.presente.length; i++)
	    ris.presente[i] = !(this.presente[i]);
	return ris;
    }
    
    public Insieme unione(Insieme A) {
	Insieme ris = new Insieme();
	for(int i = 0; i < ris.presente.length; i++)
	    ris.presente[i] = this.presente[i] || A.presente[i];
	return ris;
    }
    
    public Insieme intersezione(Insieme A) {
	Insieme ris = new Insieme();
	for(int i = 0; i < ris.presente.length; i++)
	    ris.presente[i] = this.presente[i] && A.presente[i];
	return ris;
    }
    
    public Insieme differenza(Insieme A) {
	Insieme ris = new Insieme();
	for(int i = 0; i < ris.presente.length; i++)
	    ris.presente[i] = this.presente[i] && !(A.presente[i]);
	return ris;
    }
    
    public Insieme differenzaSimmetrica(Insieme A) {
	Insieme AmenoThis = this.differenza(A);
	Insieme thisMenoA = A.differenza(this);
	return thisMenoA.unione(AmenoThis);
    }
    
    public boolean isEquals(Insieme A) {
	for(int i = 0; i < this.presente.length; i++)
	    if(this.presente[i] != A.presente[i])
		return false;
	return true;
    }
    
    public boolean diverso(Insieme A) {
	return !this.isEquals(A);
    }
    
    public boolean sottoinsiemeDi(Insieme A) {
	return this.differenza(A).vuoto();
    }
    
    public boolean sovrainsiemeDi(Insieme A) {
	return A.differenza(this).vuoto();
    }
    
}
/////////////////////////////////
// FINE   FILE Insieme.java 
/////////////////////////////////



/////////////////////////////////
// INIZIO FILE TestInsieme.java 
/////////////////////////////////
public class TestInsieme {

    public static void main(String[] args) {
	Insieme A = new Insieme();
	A.aggiungi(1);
	A.aggiungi(4);
	System.out.println(A.cardinalita());
	System.out.println(A.inverso().inverso());
	A.elimina(1);
	System.out.println(A);
	
	Insieme B = new Insieme();
	B = B.unione(A);
	System.out.println(B);
	B.aggiungi(10);
	B.aggiungi(3);
	System.out.println(B.differenza(A));
	
	A.aggiungi(10);
	System.out.println(B.intersezione(A));
	
	System.out.println(B.differenzaSimmetrica(A));
    }
    
}
/////////////////////////////////
// FINE   FILE TestInsieme.java 
/////////////////////////////////



///////////////////////////////////////////////////////////////////////////////


/*
Esercizio 2
-----------
Creare una classe "GrigliaLuminosa" caratterizzata da una matrice quadrata di NxN celle luminose
che possono essere accese o spente.
Definire per la classe i seguenti metodi (oltre al costruttore):

 - accendiTutto/spegniTutto

due metodi che ripettivamente accendono/spengono tutte le celle luminose;

 - accendiDiagonali/spegniDiagonali
 		
due metodi che ripettivamente accendono/spengono le celle luminose situate sulle due diagonali;

 - accendiCornice/spegniCornice
 
due metodi che, dato un intero i, ripettivamente accendono/spengono le celle luminose situate sulla
cornice che parte dalla posizione [i,i];

 - visualizza
 
che stampa a video un asterisco in corrispondenza di ogni cella luminosa accesa, ed uno spazio bianco
in corrispondenza di ogni cella luminosa spenta.
*/

////////////////////////////////////////////////////////////////
// ************ NOTA: sono qui proposte 2 soluzioni ALTERNATIVE
// per la classe GrigliaLuminosa **************** 
////////////////////////////////////////////////////////////////


/////////////////////////////////
// INIZIO FILE GrigliaLuminosa.java 
/////////////////////////////////
public class GrigliaLuminosa {

    private int N;
    private boolean[][] cella;
    
    public GrigliaLuminosa(int N) {
	if(N > 0)
	    this.N = N;
	else
	    this.N = 1;
	cella = new boolean[this.N][this.N];
	spegniTutto();
    }
    
    public void accendiTutto() {
	for(int i = 0; i < N; i++)
	    for(int j = 0; j < N; j++)
		cella[i][j] = true;
    }
    
    public void spegniTutto() {
	for(int i = 0; i < N; i++)
	    for(int j = 0; j < N; j++)
		cella[i][j] = false;
    }
    
    public void accendiDiagonali() {
	for(int i = 0; i < N; i++) {
	    cella[i][i] = true;		// diagonale principale
	    cella[i][N-i-1] = true;	// diagonale secondaria
	}
    }
    
    public void spegniDiagonali() {
	for(int i = 0; i < N; i++) {
	    cella[i][i] = false;		// diagonale principale
	    cella[i][N-i-1] = false;	// diagonale secondaria
	}
    }
    
    public void accendiCornice(int c) {
	// vogliamo c <= N/2
	if(c > N/2)
	    c = N-c-1;
	
	for(int i = 0; i < N; i++) {
	    for(int j = 0; j < N; j++) {
		if(((i == c || i == N-c-1) && c <= j && j <= N-c-1 ) ||
			((j == c || j == N-c-1) && (c <= i && i <= N-c-1 )))
		    cella[i][j] = true;
	    }
	}
    }
    
    public void spegniCornice(int c) {
	// vogliamo c <= N/2
	if(c > N/2)
	    c = N-c-1;
	
	for(int i = 0; i < N; i++) {
	    for(int j = 0; j < N; j++) {
		if(((i == c || i == N-c-1) && c <= j && j <= N-c-1 ) ||
			((j == c || j == N-c-1) && (c <= i && i <= N-c-1 )))
		    cella[i][j] = false;
	    }
	}
    }
    
    public void visualizza() {
 	for(int i = 0; i < N; i++) {
	    for(int j = 0; j < N; j++) {
		if(cella[i][j])
		    System.out.print("*");
		else
		    System.out.print(" ");
	    }
	    System.out.println();
	}
    }   
}
/////////////////////////////////
// FINE   FILE GrigliaLuminosa.java 
/////////////////////////////////



/////////////////////////////////
// INIZIO FILE GrigliaLuminosa2.java 
/////////////////////////////////
public class GrigliaLuminosa2 {

    private int N;
    private boolean[][] cella;
    
    public GrigliaLuminosa2(int N) {
	if(N > 0)
	    this.N = N;
	else
	    this.N = 1;
	cella = new boolean[this.N][this.N];
	spegniTutto();
    }
    
    private void setTutto(boolean value) {
	for(int i = 0; i < N; i++)
	    for(int j = 0; j < N; j++)
		cella[i][j] = value;
    }
    
    public void accendiTutto() {
	setTutto(true);
    }
    
    public void spegniTutto() {
	setTutto(false);
    }
    
    private void setDiagonali(boolean value) {
	for(int i = 0; i < N; i++) {
	    cella[i][i] = value;	// diagonale principale
	    cella[i][N-i-1] = value;	// diagonale secondaria
	}
    }
    
    public void accendiDiagonali() {
	setDiagonali(true);
    }
    
    public void spegniDiagonali() {
	setDiagonali(false);
    }

    private void setCornice(int c, boolean value) {
	// vogliamo c <= N/2
	if(c > N/2)
	    c = N-c-1;
	
	for(int i = 0; i < N; i++) {
	    for(int j = 0; j < N; j++) {
		if(((i == c || i == N-c-1) && c <= j && j <= N-c-1 ) ||
			((j == c || j == N-c-1) && (c <= i && i <= N-c-1 )))
		    cella[i][j] = value;
	    }
	}
    }
    
    public void accendiCornice(int c) {
	setCornice(c, true);
    }
    
    public void spegniCornice(int c) {
	setCornice(c, false);
    }
    
    public void visualizza() {
	for(int i = 0; i < N; i++) {
	    for(int j = 0; j < N; j++) {
		if(cella[i][j])
		    System.out.print("*");
		else
		    System.out.print(" ");
	    }
	    System.out.println();
	}
    }
    
}
/////////////////////////////////
// FINE   FILE GrigliaLuminosa2.java 
/////////////////////////////////



/////////////////////////////////
// INIZIO FILE TestGrigliaLuminosa.java 
/////////////////////////////////
public class TestGrigliaLuminosa {

    public static void main(String[] args) {
	GrigliaLuminosa g = new GrigliaLuminosa(5);
	
	System.out.println("Tutto spento");
	g.visualizza();
	
	System.out.println("Tutto acceso");
	g.accendiTutto();
	g.visualizza();
	
	System.out.println("Tutto spento");
	g.spegniTutto();
	g.visualizza();
	
	System.out.println("Diagonali accese");
	g.accendiDiagonali();
	g.visualizza();
	
	System.out.println("Tutto acceso tranne diagonali");
	g.accendiTutto();
	g.spegniDiagonali();
	g.visualizza();
	
	System.out.println("Solo cornice 1");
	g.spegniTutto();
	g.accendiCornice(1);
	g.visualizza();
    }
    
}
/////////////////////////////////
// FINE   FILE TestGrigliaLuminosa.java 
/////////////////////////////////