//==================================================================================
// Voglio stabilire se in una lista di numeri interi compaiano tutti e soli
// i numeri compresi fra i due estremi B[asso] ed A[lto].
//==================================================================================
// 
// Esercizio 1: Modificare il programma in modo che verifichi che ogni numero
// dell'intervallo scelto compaia una e una sola volta.
//
//==================================================================================
// 
// Esercizio 2a: Modificare il precedente metodo di verifica in modo che, nel caso i
// dati immessi superino con successo la verifica, essi vengano restituiti come un
// array.
//
//----------------------------------------------------------------------------------
//
// Esercizio 2b: Risolvere lo stesso esercizio del punto 2a, ma senza la ricorsione.
// (Un accenno dell'implementazione richiesta a voi, si trova nel metodo
// 'werifica' tratteggiato sotto)
//
//==================================================================================
//
// Esercizio 3a: Siano dati due oggetti di tipo String. Stabilire se i caratteri
// che figurano nella prima figurino tutti anche nella seconda.
//
//----------------------------------------------------------------------------------
//
// Esercizio 3b: Risolvere lo stesso esercizio del punto 2a facendo uso di una
// bitmap.
//
//----------------------------------------------------------------------------------
//
// Esercizio 3c: Stabilire se una stringa sia anagramma di un'altra, utilizzando
// l'idea della bitmap ma in forma piu` generale. 
//
//==================================================================================


public class EsBitmap {

    public static void main( String[] aa ){

         int a, b;
         
         Leggi.emettiMessaggio( "Dammi il numero basso" );
         b = Leggi.leggiInt( ); 
         Leggi.emettiMessaggio( "Dammi il numero alto" );
         a = Leggi.leggiInt( ); 
         Leggi.emettiMessaggio( "Dammi una lista dei numeri compresi fra " + b +
                                " e " + a);
         
         System.out.println( ( verificaCiSianoTuttiESoli( b, a ) ) ? " bene"
                                                                   : " male" ) ;                                                            
    }

    public static boolean werificaCiSianoTuttiESoli( int b, int a ){
    
    // la bitmap che segue serve a registrare una serie di chiamate per appello

        boolean[] bitmap = new boolean[ a - b + 1 ]; // per ora tutto falso
        
        int[] lista = acquisisci( );
        
        for( int i = 0; i < lista.length; i++ )
        
              if ( lista[ i ] < b || lista[ i ] > a ) return false;
              
              else bitmap[ i ] = true;
               
        for ( int i = 0; i < bitmap.length; i++ )
        
                    if (! bitmap[ i ]) return false; // fallisce per ammanco
                    
//  EQUIVALENTE:    if ( bitmap[ i ] == false ) return false;
        
        return true;
    }        
              
    public static int[] acquisisci(){
    
        int[] lista = new int [3];

        lista[0] = 1; lista[1] = 2; lista[2] = 3;
        
        return lista; 
    }
    
    public static boolean verificaCiSianoTuttiESoli( int b, int a ){
    
        boolean[] bitmap = new boolean[ a - b + 1 ]; 
        
        if ( ! ver( b, a , bitmap ) )  // ci dira` se abbiamo trovato
                                     // solo valori compresi fra b e a

                    return false; // fallisce per eccesso
                    
        for ( int i = 0; i < bitmap.length; i++ )
        
                    if (! bitmap[ i ]) return false; // fallisce per ammanco
                    
//                    if ( bitmap[ i ] == false ) return false;
        
        return true;
    }
    
    
    private  static boolean ver( int b, int a, boolean[] bit ){
    // Workhorse ricorsivo

// Acquisisce un el. della sequenza da controllare
// Gli elementi sono terminati? Tanto meglio, non occorre fare nulla.

         Integer el; // elemento della lista sotto esame
         
         el = Leggi.leggiInt( );
         
         if ( el == null ) return true; // nulla di troppo in una lista vuota
         // questo e` il caso base
         
         boolean risu = ver( b, a, bit ); // delega ricorsiva
         
         System.out.print( el+" " ); 

         if ( ! risu ||  // risultato della verifica dei dati che,
                         // nella lista, seguono l'el acquisito qui
                         // sopra
         
             el < b || el > a ) // test del dato acquisito qui sopra
                                return false;
         
         bit[ el - b ] = true; // annotiamo sulla bitmap che abbiamo
                               //               acquisito il dato el 
         
         return true;
    }
}