Esercizio 1.
============
Si implementi in Java un metodo RICORSIVO che, ricevuto un array di interi, 
restituisca il valore massimo in esso contenuto. 

SOLUZIONE
---------
public static int maxInArrayRicorsivoLineare ( int a[], int pos, int maxCorrente ) {
            if (pos >= a.length) 
                  return maxCorrente;
            if (a[pos] > maxCorrente)
                  maxCorrente = a[pos];
            return maxInArrayRicorsivoLineare ( a, pos+1, maxCorrente );
      }


ESERCZIO 2.
===========
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. 

SOLUZIONE
---------
import java.util.*;

public class Insieme {

    private boolean[] presente;

    public Insieme() {
	presente = new boolean[20];
	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();
    }
    
    public static Insieme Leggi(Scanner input){
    	Insieme s = new Insieme();
    	System.out.println("Inserisci l'insieme specificando i suoi elementi racchiusi tra {} e separati da ,");
    	String ins = input.next();
    	String[] numeri = ins.substring(1, ins.length()-1).split(",");
    	for(int i=0; i<numeri.length; i++)
    		s.aggiungi(Integer.parseInt(numeri[i]));
    	return s;
    }  
}

import java.util.*;

public class TestInsieme {

    public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
	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));
	Insieme C = Insieme.Leggi(input);
	System.out.println(C);
	
    }  
}


ESERCZIO 3.
===========
Si implementi in Java un metodo RICORSIVO avente il seguente prototipo:

    public static boolean verifica (int v[], int i) 

Il metodo deve restituire true se e solo se l’array “v” è costituito 
da una sequenza alternata di numeri positivi e negativi. In altre parole, 
ogni numero positivo deve sempre essere seguito da un numero negativo, 
ed ogni numero negativo deve sempre essere seguito da un numero positivo. 
Il metodo deve restituire false altrimenti.

SOLUZIONE
---------
public static boolean verifica (int v[], int i) {
	if ( i < v.length-1)
		if (v[i] < 0 && v[i+1] < 0 || v[i] > 0 && v[i+1] > 0)
			return false;
		else
			return verifica(v,i+1);
	else
		return true;
}