Testo esercizi:

Esercizio 1) 
Considerando le classi viste a lezione, si aggiunga un metodo 
alla implementazione delle pile ad oggetti che, 
data una pila P di interi ordinata in senso crescente, 
ed una matrice bidimensionale di interi, 
le cui righe sono tutte ordinate in senso crescente,
ed un numero intero N, restituisce un valore booleano 
true se e solo se *esattamente* N valori di P compaiono 
in almeno due righe di M.

Per esempio se P contiene i valori -4, 6, 8, 10
e M = {{6, 7, 8, 9, 10},{3,4,5,6,7},{-5, -4, 7, 8, 10}} ed N = 3,
verra' restituito il valore true.
Se N = 2 verra' restituito il valore false.

Esercizio 2) 
Considerando le classi viste a lezione, si aggiunga un metodo
alla implementazione delle liste di interi, che data una lista 
di interi L (tutti diversi tra loro), ed un vettore V di interi
(tutti diversi tra loro), restituisce un valore booleano true 
se e solo se ogni valore x in L compare in V, ed inoltre il valore 
successivo ad x in V e' minore di x. Nel caso che x sia l'ultimo 
valore in V si assume che la proprieta' sia vera per x.

Se ad esempio L contiene 9, -12
e V contiene i valori -7, 3, -12, -14, 5, 9
restituisce true.
Se invece V contiene -7, 3, -12, -14, 5, 9, 10
restituisce false.

Esercizio 3)  (solo per chi deve recuperare il primo compitino)

Scrivere una funzione che accetta in ingresso 
una matrice quadrata di numeri interi M ed un numero intero positivo 
N che restituisce true se e solo se il numero di valori 
nella matrice triangolare inferiore che sono minori
di tutti quelli nella matrice triangolare superiore
sia almeno pari ad N. Si assuma che la dimensione della
matrice quadrata sia almeno 2x2.

Ad esempio 
se M = {{1, 2, 0, 7}, {-1, 4, 5, 5}, {8, 2, 3, 9}, {4, 9,-1, 3}}, 
ed N = 2, restituisce true, se N = 3 restituisce false.


POSSIBILI SOLUZIONI:

public class EserciziCompito26Maggio2021
{
    static public boolean NvaloriDiPin2righeDiM(PilaOO P, int[][]M, int N)
    /** data una pila P di interi ordinata in senso crescente, ed una matrice M di interi,
       le cui righe sono tutte ordinate in senso crescente, ed un numero intero N, 
       restituisce un valore booleano true sse *esattamente* N valori di P compaiono
       in almeno due righe di M. */
    { 
      int contaRighe = 0; int contaP = 0; 
      int [] V = new int [P.dimensione()]; // si dimensiona V per copiarci i valori in P
      while (!P.pilavuota()){ // si copiano tutti i valori di P in V
          V[contaP++]=P.top();
          P.pop();
        }
      for (int i=0; i<M.length; i++){ // si controlla una riga alla volta con verificaRiga
          if (verificaRiga(M[i],V,contaP,N)) contaRighe++;
          if (contaRighe == 2) return true; // trovate due righe che soddisfano la proprieta'
        }
      return(false);   
    }
    static public boolean verificaRiga(int[] Riga, int [] V, int colonneV, int N){
        // verifica se i valori identici tra i vettori Riga e V sono esattamente B
        int indR = 0;
        int indV = 0;
        while (indR< Riga.length & indV <colonneV)
            if (Riga[indR] == V[indV]) { 
                N--; // se trovati due valori identici si decrementa N
                indR++;
                indV++;}
            else if (Riga[indR] < V[indV]) indR++;
            else indV++;
        return(N==0); // se N e' zero ci sono esattamente N valori identici
    }
    
    static public boolean tuttiValoriDiLinM(Lista L, int[] V){
        /** data una lista di interi L (tutti diversi tra loro), ed un vettore V di interi
        (tutti diversi tra loro), restituisce un valore booleano true sse:
        ogni valore x in L compare in V, ed inoltre il valore successivo ad x in V 
        e' minore di x. */
        while( !L.listavuota()){ // controlla tutti gli elementi in L
            int i;
            for (i = 0; i<V.length; i++) // ricerca in V ogni elemento L.leggi() nella lista L
                if (V[i]==L.leggi() & (i==V.length-1 || V[i+1]<V[i])) break;
            if (i == V.length) return false;
            L.elimina();
        }
        return true;   
    }     
    
    static public boolean confrontaMatriciTriangolari(int[][] M, int N){
        /** restituisce true sse il numero di valori
         * nella matrice triangolare inferiore che sono minori
         * di tutti quelli nella matrice triangolare superiore
         * sia almeno pari ad N */
        int minimoTriangoloSuperiore = M[0][1];
        for (int i=0; i<M.length-1; i++)
           for (int j=i+1; j<M[0].length; j++)
           if (M[i][j]<minimoTriangoloSuperiore) minimoTriangoloSuperiore = M[i][j];
        int contaMinori = 0;
        for (int i=1; i<M.length; i++)
           for (int j=0; j<i; j++){
           if (M[i][j]<minimoTriangoloSuperiore) contaMinori++;
           if (contaMinori==N) return(true);
           }
        return false;
    }

    static public void main(){ 
        PilaOO p = new PilaOO(20);
        p.push(10);
        p.push(8);
        p.push(6);
        p.push(-4);
        int[][] M = {{6, 7, 8, 9, 10},{3,4,5,6,7},{-5, -4, 7, 8, 10}};
        System.out.println("NvaloriDiPin2righeDiM = "+NvaloriDiPin2righeDiM(p,M,3));
        Lista l = new Lista();
        l.inserisci(-12);
        l.inserisci(9);
        int[] V = {-7, 3, -12, -14, 5, 9};
        System.out.println("tuttiValoriDiLinM  = "+tuttiValoriDiLinM(l,V));
        int[][] M1 = {{1, 2, 0, 7}, {-1, 4, 5, 5}, {8, 2, 3, 9}, {4, 9,-1, 3}};
        System.out.println("confrontaMatriciTriangolari  = "+confrontaMatriciTriangolari(M1,2));
    }
}