diff --git a/Materie/CMRO/FacSimili/2019-raccolta-testi-esami-con-tracce-soluzioni.pdf b/Materie/CMRO/FacSimili/2019-raccolta-testi-esami-con-tracce-soluzioni.pdf new file mode 100644 index 0000000..560ed78 Binary files /dev/null and b/Materie/CMRO/FacSimili/2019-raccolta-testi-esami-con-tracce-soluzioni.pdf differ diff --git a/Materie/PROG1/Appunti/slides_2022-11-10.pdf b/Materie/PROG1/Appunti/slides_2022-11-10.pdf new file mode 100644 index 0000000..38b8728 Binary files /dev/null and b/Materie/PROG1/Appunti/slides_2022-11-10.pdf differ diff --git a/Materie/PROG1/Appunti/slides_2022-11-24.pdf b/Materie/PROG1/Appunti/slides_2022-11-24.pdf new file mode 100644 index 0000000..00ff963 Binary files /dev/null and b/Materie/PROG1/Appunti/slides_2022-11-24.pdf differ diff --git a/Materie/PROG1/Appunti/slides_2022-12-01.pdf b/Materie/PROG1/Appunti/slides_2022-12-01.pdf new file mode 100644 index 0000000..0db75df Binary files /dev/null and b/Materie/PROG1/Appunti/slides_2022-12-01.pdf differ diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/FD.java b/Materie/PROG1/EserciziUtili/Ricorsione/FD.java new file mode 100644 index 0000000..3a52518 --- /dev/null +++ b/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}))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/FDDic.java b/Materie/PROG1/EserciziUtili/Ricorsione/FDDic.java new file mode 100644 index 0000000..2428c81 --- /dev/null +++ b/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}))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/FMag.java b/Materie/PROG1/EserciziUtili/Ricorsione/FMag.java new file mode 100644 index 0000000..c9038a0 --- /dev/null +++ b/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))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/FMagDic.java b/Materie/PROG1/EserciziUtili/Ricorsione/FMagDic.java new file mode 100644 index 0000000..14df466 --- /dev/null +++ b/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))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/FMin.java b/Materie/PROG1/EserciziUtili/Ricorsione/FMin.java new file mode 100644 index 0000000..d3b88a2 --- /dev/null +++ b/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))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/FMinDic.java b/Materie/PROG1/EserciziUtili/Ricorsione/FMinDic.java new file mode 100644 index 0000000..4df4d46 --- /dev/null +++ b/Materie/PROG1/EserciziUtili/Ricorsione/FMinDic.java @@ -0,0 +1,75 @@ +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 con le seguenti caratteristiche: + + il primo è ricorsivo dicotomico conta quanti elementi in a dovranno essere restituiti nell'array risultato; + + il secondo è ricorsivo co-variante e 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 FMinDic { + + // Dicotomico + public static int contaMinori(int[] a, int m, int l, int r) { + if (r-l == 0) + return 0; + else + if (r-l == 1) + if (a[l] < m) + return 1; + else + return 0; + else { + int mezzo = (r+l)/2; + return contaMinori(a, m, l, mezzo) + contaMinori(a, m, mezzo, r); + } + } + + // Co-variante + public static int fMin(int[] a, int m, int i, int[] r) { + if (i == 0) + return 0; + else { + int indiceR = fMin(a, m, i-1, r); + if (a[i-1] < m) { + r[indiceR] = a[i-1]; + return indiceR+1; + } else + return indiceR; + } + } + + // Wrapper + public static int[] fMin(int[] a, int m) { + int[] r = new int[contaMinori(a, m, 0, a.length)]; + fMin(a, m, 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[] {} , 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))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/FPosDValD.java b/Materie/PROG1/EserciziUtili/Ricorsione/FPosDValD.java new file mode 100644 index 0000000..1b3a5f7 --- /dev/null +++ b/Materie/PROG1/EserciziUtili/Ricorsione/FPosDValD.java @@ -0,0 +1,58 @@ +import java.util.Arrays; + +/** Scrivere un metodo fPosDValD con le seguenti caratteristiche: + - fPosDValD ha un parametro formale a di tipo array di interi; + - fPosDValD restituisce un array che contiene il doppio di tutti e soli gli interi di posizione dispari inizialmente in a, rispettando l'ordine originale degli elementi; + - fPosDValD è wrapper un metodo metodo ricorsivo contro-variante che risolve effettivamente il problema. + Per ipotesi, l'array a passato al metodo fPosDValD 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 FPosDValD { + + // Contro-variante + public static int fPosDValD(int[] a, int i, int[] r) { + if (i == a.length) + return r.length-1; + else { + int indiceR = fPosDValD(a, i+1, r); + if (i%2 == 1) { + r[indiceR] = 2*a[i]; + return indiceR-1; + } else + return indiceR; + } + } + + // Wrapper + public static int[] fPosDValD(int[] a) { + int[] r = new int[a.length/2]; + fPosDValD(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[] {} , fPosDValD(new int[] {} ))); +System.out.println(uguali(new int[] {} , fPosDValD(new int[] {0} ))); +System.out.println(uguali(new int[] {} , fPosDValD(new int[] {1} ))); +System.out.println(uguali(new int[] {2} , fPosDValD(new int[] {0,1} ))); +System.out.println(uguali(new int[] {0} , fPosDValD(new int[] {1,0} ))); +System.out.println(uguali(new int[] {0} , fPosDValD(new int[] {0,0,0} ))); +System.out.println(uguali(new int[] {2} , fPosDValD(new int[] {0,1,0} ))); +System.out.println(uguali(new int[] {2} , fPosDValD(new int[] {1,1,1} ))); +System.out.println(uguali(new int[] {2,4}, fPosDValD(new int[] {0,1,0,2}))); +System.out.println(uguali(new int[] {0,0}, fPosDValD(new int[] {1,0,1,0}))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/FPosDValDDic.java b/Materie/PROG1/EserciziUtili/Ricorsione/FPosDValDDic.java new file mode 100644 index 0000000..e13ec3c --- /dev/null +++ b/Materie/PROG1/EserciziUtili/Ricorsione/FPosDValDDic.java @@ -0,0 +1,60 @@ +import java.util.Arrays; + +/** Scrivere un metodo fPosDValD con le seguenti caratteristiche: + - fPosDValD ha un parametro formale a di tipo array di interi; + - fPosDValD restituisce un array che contiene il doppio di tutti e soli gli interi di posizione dispari inizialmente in a, rispettando l'ordine originale degli elementi; + - fPosDValD è wrapper un metodo metodo ricorsivo dicotomico che risolve effettivamente il problema. + Per ipotesi, l'array a passato al metodo fPosDValD come parametro attuale deve avere almeno un elemento. + 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 FPosDValDDic { + + // Dicotomico + public static void fPosDValD(int[] a, int l, int r, int[] ris) { + if(r-l == 0) { + } else { + if (r-l == 1) { + if (l%2 == 1) { + ris[l/2] = 2*a[l]; + } + } else { + int m = (r+l)/2; + fPosDValD(a, l, m, ris); + fPosDValD(a, m, r, ris); + } + } + } + +// Wrapper + public static int[] fPosDValD(int[] a) { + int[] ris = new int[a.length/2]; + fPosDValD(a, 0, a.length, ris); + return ris; + } + + + /* 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[] {} , fPosDValD(new int[] {} ))); +System.out.println(uguali(new int[] {} , fPosDValD(new int[] {0} ))); +System.out.println(uguali(new int[] {} , fPosDValD(new int[] {1} ))); +System.out.println(uguali(new int[] {2} , fPosDValD(new int[] {0,1} ))); +System.out.println(uguali(new int[] {0} , fPosDValD(new int[] {1,0} ))); +System.out.println(uguali(new int[] {0} , fPosDValD(new int[] {0,0,0} ))); +System.out.println(uguali(new int[] {2} , fPosDValD(new int[] {0,1,0} ))); +System.out.println(uguali(new int[] {2} , fPosDValD(new int[] {1,1,1} ))); +System.out.println(uguali(new int[] {2,4}, fPosDValD(new int[] {0,1,0,2}))); +System.out.println(uguali(new int[] {0,0}, fPosDValD(new int[] {1,0,1,0}))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/NDD.java b/Materie/PROG1/EserciziUtili/Ricorsione/NDD.java new file mode 100644 index 0000000..c28eb4c --- /dev/null +++ b/Materie/PROG1/EserciziUtili/Ricorsione/NDD.java @@ -0,0 +1,83 @@ +import java.util.Arrays; + +/** Scrivere un metodo nDD con le seguenti caratteristiche: + - nDD ha un parametro formale a di tipo array di interi ed un intero n; + - nDD restituisce un nuovo array, rispetto ad a, che contiene tutti e soli i multipli di n + che si trovano in a, rispettando l'ordine originale degli elementi; + - nDD è wrapper di un metodo con le seguenti caratteristiche: + + è ricorsivo dicotomico; + + risolve effettivamente il problema usando il metodo append, fornito a corredo del testo. + Per ipotesi, il parametro attuale a, passato al metodo nDD, può essere null o può contenere 0 elementi. + 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. + Il metodo con firma boolean Arrays.toString(int[]) restituisce una stringa con gli elementi + del parametro formale. */ + +public class NDD { + // Dicotomico + static int[] nDD(int[] a, int n, int l, int r) { + if (l < r) { // almeno un elemento in [l,r) + if (1 == r-l) { // un elemento in [l,r) + if (a[l]%n == 0) { // elemento multiplo di n + int[] ris = new int[1]; + ris[0] = a[l]; + return ris; + } else { + return new int[] {}; + } + } else { // più di un elemento in [l,r) + int m = (r+l)/2; + int[] sx = nDD(a, n, l, m); + int[] dx = nDD(a, n, m, r); + return append(sx, dx); + } + } else { // no elementi in [l,r) + return new int[] {}; + } + } + + // Wrapper + static int[] nDD(int[] a, int n) { + int[] ris = null; + if (a != null) { + ris = nDD(a, n, 0, a.length); + } + return ris; + } + + + /* Metodi di supporto */ + // 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; + } + + // 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(null , nDD(null , 0))); +System.out.println(uguali(new int[] {} , nDD(new int[] {} , 0))); +System.out.println(uguali(new int[] {} , nDD(new int[] {1} , 2))); +System.out.println(uguali(new int[] {2} , nDD(new int[] {2} , 2))); +System.out.println(uguali(new int[] {2} , nDD(new int[] {1,2} , 2))); +System.out.println(uguali(new int[] {2} , nDD(new int[] {2,1} , 2))); +System.out.println(uguali(new int[] {2,4}, nDD(new int[] {2,1,4} , 2))); +System.out.println(uguali(new int[] {} , nDD(new int[] {1,1,1} , 2))); +System.out.println(uguali(new int[] {2,4}, nDD(new int[] {1,2,1,4}, 2))); +System.out.println(uguali(new int[] {2,4}, nDD(new int[] {2,1,4,1}, 2))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/SZD.java b/Materie/PROG1/EserciziUtili/Ricorsione/SZD.java new file mode 100644 index 0000000..c69930d --- /dev/null +++ b/Materie/PROG1/EserciziUtili/Ricorsione/SZD.java @@ -0,0 +1,65 @@ +import java.util.Arrays; + +/** Scrivere un metodo sZD con le seguenti caratteristiche: + - sZD ha un parametro formale a di tipo array di interi; + - sZD è wrapper di un metodo ricorsivo dicotomico che, tramite il meccanismo di aliasing, + modifica a sostituendo 0 ad ogni valore pari inizialmente in a; + - sZD restituisce una copia di a, per mezzo dell'assegnamento int[] b = Array.copyOf(a, a.length). + + Per ipotesi, il parametro attuale a, passato al metodo sZD, può essere null o può contenere 0 elementi. + 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. Il metodo con firma boolean + Arrays.toString(int[]) restituisce una stringa con gli elementi + del parametro formale. */ + +public class SZD { + // Dicotomico + static void sZD(int[] a, int l, int r) { + if (l < r) { // almeno un elemento in [l,r) + if (1 == r-l) { // un elemento in [l,r) + if (a[l]%2 == 0) { // elemento multiplo di n + a[l] = 0; + } + } else { // più di un elemento in [l,r) + int m = (r+l)/2; + sZD(a, l, m); + sZD(a, m, r); + } + } + } + + // Wrapper + static int[] sZD(int[] a) { + int[] ris = null; + if (a != null) { + sZD(a, 0, a.length); + ris = new int[a.length]; + ris = Arrays.copyOf(a, a.length); + } + return ris; + } + + /* 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(null , sZD(null ))); +System.out.println(uguali(new int[] {} , sZD(new int[] {} ))); +System.out.println(uguali(new int[] {1} , sZD(new int[] {1} ))); +System.out.println(uguali(new int[] {0} , sZD(new int[] {2} ))); +System.out.println(uguali(new int[] {1,0} , sZD(new int[] {1,2} ))); +System.out.println(uguali(new int[] {0,1} , sZD(new int[] {2,1} ))); +System.out.println(uguali(new int[] {0,1,0} , sZD(new int[] {2,1,4} ))); +System.out.println(uguali(new int[] {1,1,1} , sZD(new int[] {1,1,1} ))); +System.out.println(uguali(new int[] {1,0,1,0}, sZD(new int[] {1,2,1,4}))); +System.out.println(uguali(new int[] {0,1,0,1}, sZD(new int[] {2,1,4,1}))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/SZSD.java b/Materie/PROG1/EserciziUtili/Ricorsione/SZSD.java new file mode 100644 index 0000000..abe9527 --- /dev/null +++ b/Materie/PROG1/EserciziUtili/Ricorsione/SZSD.java @@ -0,0 +1,69 @@ +import java.util.Arrays; + +/** Scrivere un metodo sZSD con le seguenti caratteristiche: + - sZSD ha un parametro formale a di tipo array di interi; + - sZSD è wrapper di un metodo ricorsivo dicotomico che, tramite il meccanismo di aliasing, + modifica a come segue: + + ogni valore che si trova nella posizione immediatamente successiva ad una cella con valore pari + è sostituito con 0, ammesso che tale cella successiva esista; + - sZSD restituisce una copia di a, per mezzo dell'assegnamento int[] b = Array.copyOf(a, a.length). + + Per ipotesi, il parametro attuale a, passato al metodo sZSD, può essere null o può contenere 0 elementi. + 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. Il metodo con firma boolean + Arrays.toString(int[]) restituisce una stringa con gli elementi + del parametro formale. */ + +public class SZSD { + // Dicotomico + static void sZSD(int[] a, int l, int r) { + if (l < r) { // almeno un elemento in [l,r) + if (1 == r-l) { // un elemento in [l,r) + if (a[l]%2 == 0) { // elemento multiplo di n + if (l+1 < a.length) { // elemento successivo esiste + a[l+1] = 0; + } + } + } else { // più di un elemento in [l,r) + int m = (r+l)/2; + sZSD(a, l, m); + sZSD(a, m, r); + } + } + } + + // Wrapper + static int[] sZSD(int[] a) { + int[] ris = null; + if (a != null) { + sZSD(a, 0, a.length); + ris = new int[a.length]; + ris = Arrays.copyOf(a, a.length); + } + return ris; + } + + /* 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(null , sZSD(null ))); +System.out.println(uguali(new int[] {} , sZSD(new int[] {} ))); +System.out.println(uguali(new int[] {1} , sZSD(new int[] {1} ))); +System.out.println(uguali(new int[] {2} , sZSD(new int[] {2} ))); +System.out.println(uguali(new int[] {1,2} , sZSD(new int[] {1,2} ))); +System.out.println(uguali(new int[] {2,0} , sZSD(new int[] {2,1} ))); +System.out.println(uguali(new int[] {2,0,0} , sZSD(new int[] {2,1,4} ))); +System.out.println(uguali(new int[] {1,1,1} , sZSD(new int[] {1,1,1} ))); +System.out.println(uguali(new int[] {1,2,0,0}, sZSD(new int[] {1,2,1,4}))); +System.out.println(uguali(new int[] {2,0,0,0}, sZSD(new int[] {2,1,4,1}))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/T.java b/Materie/PROG1/EserciziUtili/Ricorsione/T.java new file mode 100644 index 0000000..623d865 --- /dev/null +++ b/Materie/PROG1/EserciziUtili/Ricorsione/T.java @@ -0,0 +1,55 @@ +import java.util.Arrays; + +/** Scrivere un metodo t con le seguenti caratteristiche: + - t ha un primo parametro formale a di tipo array di interi ed un secondo parametro formale m di tipo intero; + - t restituisce un array di booleani in cui ogni elemento e' true se l'elemento che gli corrisponde in a e' strettamente inferiore al valore in l e false altrimenti; + - t è wrapper di un solo metodo ricorsivo co-variante che risolve effettivamente il problema. + Per ipotesi, l'array a passato al metodo T 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 T { + + // Co-variante + private static void t(int[] a, int m, int i, boolean[] r) { + if (i == 0) { + } else { + t(a, m, i-1, r); + r[i-1] = (a[i-1] < m); + } + } + + // Wrapper + public static boolean[] t(int[] a, int m) { + boolean[] r = new boolean[a.length]; + t(a, m, a.length, r); + return r; + } + + /* Metodi di supporto */ + // Restituisce true se gli array di booleani a e b sono uguali + public static boolean uguali(boolean[] a, boolean[] b) { + return Arrays.equals(a, b); + } + + // Stampe di array + public static void pABool(boolean[] a) { + System.out.println(Arrays.toString(a)); + } + public static void pAInt(int[] a) { + System.out.println(Arrays.toString(a)); + } + + public static void main(String[] args) { +System.out.println(uguali(new boolean[] {} , t(new int[] {} , 1))); +System.out.println(uguali(new boolean[] {true } , t(new int[] {0} , 1))); +System.out.println(uguali(new boolean[] {false} , t(new int[] {1} , 1))); +System.out.println(uguali(new boolean[] {true ,false} , t(new int[] {0,1} , 1))); +System.out.println(uguali(new boolean[] {false,true } , t(new int[] {1,0} , 1))); +System.out.println(uguali(new boolean[] {true ,true } , t(new int[] {0,0} , 1))); +System.out.println(uguali(new boolean[] {false,false} , t(new int[] {1,1} , 1))); +System.out.println(uguali(new boolean[] {false,false,false} , t(new int[] {1,1,1} , 1))); +System.out.println(uguali(new boolean[] {true ,false,true ,false}, t(new int[] {0,1,0,2}, 1))); +System.out.println(uguali(new boolean[] {false,true ,false,true }, t(new int[] {1,0,1,0}, 1))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/EserciziUtili/Ricorsione/TDic.java b/Materie/PROG1/EserciziUtili/Ricorsione/TDic.java new file mode 100644 index 0000000..3093864 --- /dev/null +++ b/Materie/PROG1/EserciziUtili/Ricorsione/TDic.java @@ -0,0 +1,59 @@ +import java.util.Arrays; + +/** Scrivere un metodo t con le seguenti caratteristiche: + - t ha un primo parametro formale a di tipo array di interi ed un secondo parametro formale m di tipo intero; + - t restituisce un array di booleani in cui ogni elemento e' true se l'elemento che gli corrisponde in a e' strettamente inferiore al valore in l e false altrimenti; + - t è wrapper di un solo metodo ricorsivo dicotomico che risolve effettivamente il problema. + Per ipotesi, l'array a passato al metodo T 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 TDic { + + // Co-variante + private static void t(int[] a, int m, int l, int r, boolean[] ris) { + if (r-l == 0) { + } else + if (r-l == 1) + ris[l] = (a[l] < m); + else { + int mezzo = (r+l)/2; + t(a, m, l, mezzo, ris); + t(a, m, mezzo, r, ris); + } + } + + // Wrapper + public static boolean[] t(int[] a, int m) { + boolean[] ris = new boolean[a.length]; + t(a, m, 0, a.length, ris); + return ris; + } + + /* Metodi di supporto */ + // Restituisce true se gli array di booleani a e b sono uguali + public static boolean uguali(boolean[] a, boolean[] b) { + return Arrays.equals(a, b); + } + + // Stampe di array + public static void pABool(boolean[] a) { + System.out.println(Arrays.toString(a)); + } + public static void pAInt(int[] a) { + System.out.println(Arrays.toString(a)); + } + + public static void main(String[] args) { +System.out.println(uguali(new boolean[] {} , t(new int[] {} , 1))); +System.out.println(uguali(new boolean[] {true } , t(new int[] {0} , 1))); +System.out.println(uguali(new boolean[] {false} , t(new int[] {1} , 1))); +System.out.println(uguali(new boolean[] {true ,false} , t(new int[] {0,1} , 1))); +System.out.println(uguali(new boolean[] {false,true } , t(new int[] {1,0} , 1))); +System.out.println(uguali(new boolean[] {true ,true } , t(new int[] {0,0} , 1))); +System.out.println(uguali(new boolean[] {false,false} , t(new int[] {1,1} , 1))); +System.out.println(uguali(new boolean[] {false,false,false} , t(new int[] {1,1,1} , 1))); +System.out.println(uguali(new boolean[] {true ,false,true ,false}, t(new int[] {0,1,0,2}, 1))); +System.out.println(uguali(new boolean[] {false,true ,false,true }, t(new int[] {1,0,1,0}, 1))); + } +} \ No newline at end of file diff --git a/Materie/PROG1/FacSimili/aa1617EsamiProg1.zip b/Materie/PROG1/FacSimili/aa1617EsamiProg1.zip new file mode 100644 index 0000000..1c6b83c Binary files /dev/null and b/Materie/PROG1/FacSimili/aa1617EsamiProg1.zip differ diff --git a/Materie/PROG1/FacSimili/aa1718EsamiProg1.zip b/Materie/PROG1/FacSimili/aa1718EsamiProg1.zip new file mode 100644 index 0000000..7b32718 Binary files /dev/null and b/Materie/PROG1/FacSimili/aa1718EsamiProg1.zip differ diff --git a/Materie/PROG1/FacSimili/aa1819EsamiProg1.zip b/Materie/PROG1/FacSimili/aa1819EsamiProg1.zip new file mode 100644 index 0000000..bcf0bb2 Binary files /dev/null and b/Materie/PROG1/FacSimili/aa1819EsamiProg1.zip differ