Caricamento materiale FFerrando (#78)

Materie/PROG1/EserciziUtili/Ricorsione/FD.java

@@ -0,0 +1,69 @@
+import java.util.Arrays;
+
+/** Scrivere un metodo fD con le seguenti caratteristiche:
+  - fD ha un parametro formale a di tipo array di interi;
+  - fD restituisce un array che contiene tutti e soli gli interi dispari inizialmente in a, rispettando l'ordine originale degli elementi;
+  - fD è wrapper di un paio di metodi ricorsivi con le seguenti caratteristiche:
+      + uno contro-variante che conta quanti elementi in a dovranno essere restituiti nell'array risultato;
+      + uno co-variante che risolve effettivamente il problema.
+  Per ipotesi, l'array a passato al metodo fD come parametro attuale non puo' essere null. 
+  NOTA. Il metodo con firma boolean Arrays.equals(int[],int[]) restituisce true se i due parametri
+  attuali sono array identici elemento per elemento, e false altrimenti.*/
+
+public class FD {
+
+    // Contro-variante
+    public static int contaDispari(int[] a, int i) {
+        if (i == a.length)
+          return 0;
+        else if (a[i]%2 == 1) 
+                return 1 + contaDispari(a, i+1);
+             else
+                return 0 + contaDispari(a, i+1);
+    }
+
+    // Co-variante
+    public static int fD(int[] a, int i, int[] r) {
+        if (i == 0)
+          return 0;
+        else {
+          int indiceR = fD(a, i-1, r);
+          if (a[i-1]%2 == 1) {
+             r[indiceR] = a[i-1];
+             return indiceR+1;
+          } else 
+             return indiceR;
+        }
+    }
+
+    // Wrapper
+    public static int[] fD(int[] a) {
+      int[] r = new int[contaDispari(a, 0)];
+      fD(a, a.length, r); 
+      return r;
+    }
+
+  /* Metodi di supporto */
+  // Restituisce true se gli array di interi a e b sono uguali
+  public static boolean uguali(int[] a, int[] b) {
+  return Arrays.equals(a, b);
+  }
+
+  // Stampa un array di interi 
+  public static void pA(int[] a) {
+    System.out.println(Arrays.toString(a));
+  }
+
+    public static void main(String[] args) {
+System.out.println(uguali(new int[] {}     , fD(new int[] {}       )));
+System.out.println(uguali(new int[] {}     , fD(new int[] {0}      )));
+System.out.println(uguali(new int[] {1}    , fD(new int[] {1}      )));
+System.out.println(uguali(new int[] {1}    , fD(new int[] {0,1}    )));
+System.out.println(uguali(new int[] {1}    , fD(new int[] {1,0}    )));
+System.out.println(uguali(new int[] {}     , fD(new int[] {0,0,0}  )));
+System.out.println(uguali(new int[] {1}    , fD(new int[] {0,1,0}  )));
+System.out.println(uguali(new int[] {1,1,1}, fD(new int[] {1,1,1}  )));
+System.out.println(uguali(new int[] {1,1}  , fD(new int[] {0,1,0,1})));
+System.out.println(uguali(new int[] {1,1}  , fD(new int[] {1,0,1,0})));
+    }
+}

Materie/PROG1/EserciziUtili/Ricorsione/FDDic.java

@@ -0,0 +1,75 @@
+import java.util.Arrays;
+
+/** Scrivere un metodo fD con le seguenti caratteristiche:
+  - fD ha un parametro formale a di tipo array di interi;
+  - fD restituisce un array che contiene tutti e soli gli interi dispari inizialmente in a, rispettando l'ordine originale degli elementi;
+  - fD è wrapper di un paio di metodi ricorsivi tali che:
+      + il primo è dicotomico e conta quanti elementi in a dovranno essere restituiti nell'array risultato;
+      + il secondo è contro-variante e risolve effettivamente il problema.
+  Per ipotesi, l'array a passato al metodo fD come parametro attuale non puo' essere null. 
+  NOTA. Il metodo con firma boolean Arrays.equals(int[],int[]) restituisce true se i due parametri
+  attuali sono array identici elemento per elemento, e false altrimenti. */
+
+public class FDDic {
+
+    // Dicotomico
+    public static int contaDispari(int[] a, int l, int r) {
+      if (r-l == 0) 
+        return 0;
+      else
+        if (r-l == 1)
+          if (a[l]%2 == 1) 
+                return 1;
+             else
+                return 0;
+        else {
+          int m = (l+r)/2;
+          return contaDispari(a, l, m) + contaDispari(a, m, r);
+        }
+    }
+
+    // Contro-variante
+    public static int fD(int[] a, int i, int[] r) {
+        if (i == a.length)
+          return 0;
+        else {
+          int indiceR = fD(a, i+1, r);
+          if (a[i]%2 == 1) {
+             r[indiceR] = a[i];
+             return indiceR+1;
+          } else 
+             return indiceR;
+        }
+    }
+
+    // Wrapper
+    public static int[] fD(int[] a) {
+      int[] r = new int[contaDispari(a, 0, a.length)];
+      fD(a, 0, r); 
+      return r;
+    }
+
+  /* Metodi di supporto */
+  // Restituisce true se gli array di interi a e b sono uguali
+  public static boolean uguali(int[] a, int[] b) {
+  return Arrays.equals(a, b);
+  }
+
+  // Stampa un array di interi 
+  public static void pA(int[] a) {
+    System.out.println(Arrays.toString(a));
+  }
+
+  public static void main(String[] args) {
+System.out.println(uguali(new int[] {}     , fD(new int[] {}       )));
+System.out.println(uguali(new int[] {}     , fD(new int[] {0}      )));
+System.out.println(uguali(new int[] {1}    , fD(new int[] {1}      )));
+System.out.println(uguali(new int[] {1}    , fD(new int[] {0,1}    )));
+System.out.println(uguali(new int[] {1}    , fD(new int[] {1,0}    )));
+System.out.println(uguali(new int[] {}     , fD(new int[] {0,0,0}  )));
+System.out.println(uguali(new int[] {1}    , fD(new int[] {0,1,0}  )));
+System.out.println(uguali(new int[] {1,1,1}, fD(new int[] {1,1,1}  )));
+System.out.println(uguali(new int[] {1,1}  , fD(new int[] {0,1,0,1})));
+System.out.println(uguali(new int[] {1,1}  , fD(new int[] {1,0,1,0})));
+    }
+}

Materie/PROG1/EserciziUtili/Ricorsione/FMag.java

@@ -0,0 +1,68 @@
+import java.util.Arrays;
+
+/** Scrivere un metodo fMag con le seguenti caratteristiche:
+  - fMag ha un primo parametro formale a di tipo array di interi ed un secondo parametro formale l di tipo intero;
+  - fMag restituisce un array che contiene tutti e soli gli interi inizialmente in a e strettamente maggiori del valore in l, rispettando l'ordine originale degli elementi;
+  - fMag *non* puo' contare il numero di elementi in a che soddisfano la proprieta' indicata per dimensionare opportunamente l'array da produrre come risultato;
+  - fMag è wrapper di un solo metodo ricorsivo co-variante che risolve effettivamente il problema.
+  Per ipotesi, l'array a passato al metodo fD come parametro attuale non puo' essere null. 
+  NOTA. Il metodo con firma boolean Arrays.equals(int[],int[]) restituisce true se i due parametri
+  attuali sono array identici elemento per elemento, e false altrimenti.   */
+
+public class FMag {
+
+    // Co-variante
+    private static int[] fMag(int[] a, int l, int i) {
+        if (i == 0) {
+            return new int[0];
+        } else { 
+            int[] tmp = fMag(a, l, i-1);
+            if (a[i-1] > l) { 
+                int[] r = new int[tmp.length + 1]; 
+                copiaDi(tmp, r, 0);
+                r[r.length-1] = a[i-1];
+                return r;
+            } else 
+                return tmp;
+        }
+    }
+
+    // Wrapper
+    public static int[] fMag(int[] a, int l) {
+        return fMag(a, l, a.length);
+    }
+
+    /* Metodo contro-variante che copia tmp in r, assumendo 
+    che tmp.length<=r.length. */
+    private static void copiaDi(int[] tmp, int[] r, int i) {
+        if (i == tmp.length) {
+        } else { 
+            r[i] = tmp[i];
+            copiaDi(tmp, r, i+1);
+        }
+    }
+
+  /* Metodi di supporto */
+  // Restituisce true se gli array di interi a e b sono uguali
+  public static boolean uguali(int[] a, int[] b) {
+    return Arrays.equals(a, b);
+  }
+
+  // Stampa un array di interi 
+  public static void pA(int[] a) {
+    System.out.println(Arrays.toString(a));
+  }
+
+    public static void main(String[] args) {
+System.out.println(uguali(new int[] {}     , fMag(new int[] {}       , 0)));
+System.out.println(uguali(new int[] {}     , fMag(new int[] {0}      , 0)));
+System.out.println(uguali(new int[] {1}    , fMag(new int[] {1}      , 0)));
+System.out.println(uguali(new int[] {1}    , fMag(new int[] {0,1}    , 0)));
+System.out.println(uguali(new int[] {1}    , fMag(new int[] {1,0}    , 0)));
+System.out.println(uguali(new int[] {}     , fMag(new int[] {0,0,0}  , 0)));
+System.out.println(uguali(new int[] {1}    , fMag(new int[] {0,1,0}  , 0)));
+System.out.println(uguali(new int[] {1,1,1}, fMag(new int[] {1,1,1}  , 0)));
+System.out.println(uguali(new int[] {1,2}  , fMag(new int[] {0,1,0,2}, 0)));
+System.out.println(uguali(new int[] {1,1}  , fMag(new int[] {1,0,1,0}, 0)));
+    }
+}

Materie/PROG1/EserciziUtili/Ricorsione/FMagDic.java

@@ -0,0 +1,73 @@
+import java.util.Arrays;
+
+/** Scrivere un metodo fMag con le seguenti caratteristiche:
+  - fMag ha un primo parametro formale a di tipo array di interi ed un secondo parametro formale m di tipo intero;
+  - fMag restituisce un array che contiene tutti e soli gli interi inizialmente in a e strettamente maggiori del valore in m, rispettando l'ordine originale degli elementi;
+  - fMag *non* puo' contare il numero di elementi in a che soddisfano la proprieta' indicata per dimensionare opportunamente l'array da produrre come risultato. La conseguenza è che occorrerà scrivere anche un metodo append (ricorsivo o iterativo) che, dati due array x, ed y di interi, ne costruisce un terzo z la cui prima parte contiene tutti e soli i valori in x e la seconda tutti e soli i valori di y;
+  - fMag è wrapper di un solo metodo ricorsivo dicotomico che risolve effettivamente il problema.
+  Per ipotesi, l'array a passato al metodo fD come parametro attuale non puo' essere null.
+  NOTA. Il metodo con firma boolean Arrays.equals(int[],int[]) restituisce true se i due parametri
+  attuali sono array identici elemento per elemento, e false altrimenti.   */
+
+public class FMagDic {
+
+    // Dicotomica
+    private static int[] fMag(int[] a, int m, int l, int r) {
+        if (r-l == 0) // intervallo vuoto, con 0 elementi
+          return new int[0];
+        else
+          if (r-l == 1) // intervallo con un elemento
+            if (a[l] > m) { // l'elemento soddisfa la condizione
+               int[] e = new int[1];
+               e[0] = a[l];
+               return e;
+            } else // l'elemento non soddisfa la condizione
+               return new int[0];
+          else { // intervallo con più di un elemento tra cui individuare quelli di interesse
+            int mezzo = (r+l)/2;
+            int[] sx = fMag(a, m, l, mezzo);
+            int[] dx = fMag(a, m, mezzo, r);
+            return append(sx, dx);
+          }
+    }
+
+    // Wrapper
+    public static int[] fMag(int[] a, int m) {
+        return fMag(a, m, 0, a.length);
+    }
+
+    // Appende array y ad array x
+    public static int[] append(int[] x, int[] y) {
+        int[] z = new int[x.length+y.length];
+        int i;
+        for(i = 0; i < x.length; i++)
+            z[i] = x[i];
+        for(i = 0; i < y.length; i++)
+            z[x.length+i] = y[i];
+        return z;
+    }
+
+  /* Metodi di supporto */
+  // Restituisce true se gli array di interi a e b sono uguali
+  public static boolean uguali(int[] a, int[] b) {
+    return Arrays.equals(a, b);
+  }
+
+  // Stampa un array di interi
+  public static void pA(int[] a) {
+    System.out.println(Arrays.toString(a));
+  }
+
+    public static void main(String[] args) {
+System.out.println(uguali(new int[] {}     , fMag(new int[] {}       , 0)));
+System.out.println(uguali(new int[] {}     , fMag(new int[] {0}      , 0)));
+System.out.println(uguali(new int[] {1}    , fMag(new int[] {1}      , 0)));
+System.out.println(uguali(new int[] {1}    , fMag(new int[] {0,1}    , 0)));
+System.out.println(uguali(new int[] {1}    , fMag(new int[] {1,0}    , 0)));
+System.out.println(uguali(new int[] {}     , fMag(new int[] {0,0,0}  , 0)));
+System.out.println(uguali(new int[] {1}    , fMag(new int[] {0,1,0}  , 0)));
+System.out.println(uguali(new int[] {1,1,1}, fMag(new int[] {1,1,1}  , 0)));
+System.out.println(uguali(new int[] {1,2}  , fMag(new int[] {0,1,0,2}, 0)));
+System.out.println(uguali(new int[] {1,1}  , fMag(new int[] {1,0,1,0}, 0)));
+    }
+}

Materie/PROG1/EserciziUtili/Ricorsione/FMin.java

@@ -0,0 +1,69 @@
+import java.util.Arrays;
+
+/** Scrivere un metodo fMin con le seguenti caratteristiche:
+  - fMin ha un primo parametro formale a di tipo array di interi ed un secondo parametro formale m di tipo intero;
+  - fMin restituisce un array che contiene tutti e soli gli interi inizialmente in a e strettamente minori del valore in m, rispettando l'ordine originale degli elementi;
+  - fMin è wrapper di un paio di metodi ricorsivi con le seguenti caratteristiche:
+      + uno co-variante che conta quanti elementi in a dovranno essere restituiti nell'array risultato;
+      + uno contro-variante che risolve effettivamente il problema.
+  Per ipotesi, l'array a passato al metodo fMin come parametro attuale non puo' essere null. 
+  NOTA. Il metodo con firma boolean Arrays.equals(int[],int[]) restituisce true se i due parametri
+  attuali sono array identici elemento per elemento, e false altrimenti.   */
+
+public class FMin {
+
+    // Co-variante
+    public static int contaMinori(int[] a, int m, int i) {
+        if (i == 0)
+          return 0;
+        else if (a[i-1] < m) 
+                return 1 + contaMinori(a, m, i-1);
+             else
+                return 0 + contaMinori(a, m, i-1);
+    }
+
+    // Contro-variante
+    public static int fMin(int[] a, int m, int i, int[] r) {
+        if (i == a.length)
+          return r.length-1;
+        else {
+          int indiceR = fMin(a, m, i+1, r);
+          if (a[i] < m) {
+             r[indiceR] = a[i];
+             return indiceR-1;
+          } else 
+             return indiceR;
+        }
+    }
+
+    // Wrapper
+    public static int[] fMin(int[] a, int m) {
+      int[] r = new int[contaMinori(a, m, a.length)];
+      fMin(a, m, 0, r); 
+      return r;
+    }
+
+  /* Metodi di supporto */
+  // Restituisce true se gli array di interi a e b sono uguali
+  public static boolean uguali(int[] a, int[] b) {
+    return Arrays.equals(a, b);
+  }
+
+  // Stampa un array di interi 
+  public static void pA(int[] a) {
+    System.out.println(Arrays.toString(a));
+  }
+
+    public static void main(String[] args) {
+System.out.println(uguali(new int[] {}     , fMin(new int[] {}       , 1)));
+System.out.println(uguali(new int[] {0}    , fMin(new int[] {0}      , 1)));
+System.out.println(uguali(new int[] {}     , fMin(new int[] {1}      , 1)));
+System.out.println(uguali(new int[] {0}    , fMin(new int[] {0,1}    , 1)));
+System.out.println(uguali(new int[] {0}    , fMin(new int[] {1,0}    , 1)));
+System.out.println(uguali(new int[] {0,0,0}, fMin(new int[] {0,0,0}  , 1)));
+System.out.println(uguali(new int[] {0,0}  , fMin(new int[] {0,1,0}  , 1)));
+System.out.println(uguali(new int[] {}     , fMin(new int[] {1,1,1}  , 1)));
+System.out.println(uguali(new int[] {0,0}  , fMin(new int[] {0,1,0,2}, 1)));
+System.out.println(uguali(new int[] {0,0}  , fMin(new int[] {1,0,1,0}, 1)));
+    }
+}