Tema 59

Scrivere un metodo creaArrayEstraendoTuttiGliElementiPerColonna che riceve in ingresso una matrice di interi M e crea un array estraendo tutti gli elementi della matrice colonna per colonna.

1	2	3	7
4	5	6	8
7	8	9	3
8	6	5	4

allora creaArrayEstraendoTuttiGliElementiPerRiga(M) darà

1

4

7

8

2

5

8

6

3

6

9

5

7

8

3

4

 public class tema59 { public static int[] creaArrayEstraendoTuttiGliElementiPerColonna (int[][] M) { // approntiamo un array di dimensione data dal seguente calcolo, dovendo // inserire tutti gli elementi di M int[] V = new int[M.length * M.length]; // prepariamo un indice per scorrere l’array int indice = 0; // in questo caso poniamo come ciclo più esterno quello delle colonne for(int j = 0; j < M[0].length; j++) { for(int i = 0; i < M.length; i++) { V[indice] = M[i][j]; indice++;} } return V; } public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); }  /* Applicazione di prova */  public static void main (String[] args) { int[][] Q ={ {1, 2, 3, 7}, {4, 5, 6, 8}, {7, 8, 9, 3}, {8, 6, 5, 4} }; visualizzaArray (creaArrayEstraendoTuttiGliElementiPerColonna (Q)); } }     

Tema 58

Scrivere un metodo creaArrayEstraendoTuttiGliElementiPerRiga che riceve in ingresso una matrice di interi M e crea un array estraendo tutti gli elementi della matrice riga per riga.

Ad esempio, sia M la matrice così costituita

1	2	3	7
4	5	6	8
7	8	9	3
8	6	5	4

allora creaArrayEstraendoTuttiGliElementiPerRiga (M) darà

1

2

3

7

4

5

6

8

7

8

9

3

8

6

5

4

 public class tema59 { public static int[] creaArrayEstraendoTuttiGliElementiPerRiga (int[][] M) { // approntiamo un array di dimensione data dal seguente calcolo, dovendo // inserire tutti gli elementi di M int[] V = new int[M.length * M.length]; // prepariamo un indice per scorrere l’array int indice = 0; for(int i = 0; i < M.length; i++) { for(int j = 0; j < M[0].length; j++) { // trasferiamo nell’array gli elementi riga per riga V[indice] = M[i][j]; indice++;} } return V; }  public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); }  /* Applicazione di prova */  public static void main (String[] args) { int[][] Q ={ {1, 2, 3, 7}, {4, 5, 6, 8}, {7, 8, 9, 3}, {8, 6, 5, 4} }; visualizzaArray (creaArrayEstraendoTuttiGliElementiPerRiga (Q)); } }     

Tema 57

Scrivere un metodo creaArrayConPositiviDiagonaleSecondaria che riceve in ingresso una matrice quadrata M e restituisce un vettore contenente gli elementi positivi presenti sulla diagonale secondaria.

Ad esempio, sia M la matrice così costituita

1	2	3
2	-6	4
8	4	5

allora estraiPositiviDaDiagonaleSecondaria (M) darà

3

8

 public class tema57 { public static int[] estraiPositiviDaDiagonaleSecondaria (int[][] M){ // verifichiamo che la matrice sia quadrata if (M.length != M[0].length) return null; // dichiariamo l’array che conterrà gli elementi finali int[] A; // approntiamo un array in cui faremo confluire inizialmente gli elementi che // soddisfano il requisito // assegnamo a questo array la dimensione M.length che potrebbe avere nel caso // in cui tutti gli elementi // soddisfino il requisito int[] V = new int[M.length]; // prepariamo un indice con cui scorrere l’array int indice = 0; for (int i = 0; i < M.length; i++) if (M[i][M.length-1-i] > 0){ V[indice] = M[i][M.length-1-i]; indice++; } // se non vengono trovati elementi non nulli, il risultato sarà null if (indice == 0) return null; else { // altrimenti assegnamo all’array A la giusta dimensione e trasferiamo al suo // interno gli elementi A = new int[indice]; for (int i = 0; i < A.length; i++) A[i] = V[i]; } return A; }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = new int[][]{{1,2,3}, {2,-6,4}, {8,4,5}}; int[] V = estraiPositiviDaDiagonaleSecondaria (M); if (V != null){ for (int i = 0; i < V.length; i++) System.out.println(V[i]+" ");} } }     

Tema 56

Scrivere un metodo creaArrayConElementiDiagonaleSecondaria che riceve in ingresso una matrice quadrata di interi M e preleva gli elementi della diagonale secondaria collocandoli in un array.

Ad esempio, sia M la matrice così costituita

1	2	3	7
4	5	6	8
7	8	9	3
8	6	5	4

allora estraiDiagonaleSecondaria(M) darà

7

6

8

8

 public class tema56 { public static int[] estraiDiagonaleSecondaria (int[][] M) { // approntiamo un array di dimensione pari alla dimensione di M int[] V = new int[M.length]; // in questo caso abbiamo bisogno di un solo ciclo e di un solo indice for(int i = 0; i < M.length; i++) V[i] = M[i][M[0].length-1-i]; return V; }  public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); }  /* Applicazione di prova */ public static void main (String[] args) { int[][] Q ={ {1, 2, 3, 7}, {4, 5, 6, 8}, {7, 8, 9, 3}, {8, 6, 5, 4} }; visualizza (estraiDiagonaleSecondaria (Q)); } }     

Tema 55

Scrivere un metodo creaArrayConElementiNonNulliDiagonalePrincipale che riceve in ingresso una matrice quadrata di interi M e restituisce un vettore contenente gli elementi non nulli che si trovano sulla sua diagonale principale.

Ad esempio, sia M la matrice così costituita

0	2	3
2	3	4
4	5	6

allora estraiNonNulliDaDiagonalePrincipale(M) darà

3

6

 public class tema55 { public static int[] estraiNonNulliDaDiagonalePrincipale (int[][] M){ // dichiariamo un array in cui trasferiremo gli elementi che soddisfano il // requisito int[] A; // controlliamo che la matrice sia quadrata if (M.length != M[0].length) return null; // approntiamo un array in cui faremo confluire inizialmente gli elementi che // soddisfano il requisito // assegnamo a questo array la dimensione M.length che potrebbe avere nel caso // in cui tutti gli elementi // soddisfino il requisito int[] V = new int[M.length]; // prepariamo un indice con cui scorrere l’array int indice = 0; for (int i = 0; i < M.length; i++) if (M[i][i] != 0){ V[indice] = M[i][i]; indice++; } // se non vengono trovati elementi non nulli, il risultato sarà null if (indice == 0) return null; else { // altrimenti assegnamo all’array A la giusta dimensione e trasferiamo al suo // interno gli elementi A = new int[indice]; for (int i = 0; i < A.length; i++) A[i] = V[i]; } return A; }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = new int[][]{{0,2,3},{2,3,4},{4,5,6}}; int[] V = estraiNonNulliDaDiagonalePrincipale (M); if (V != null){ for (int i = 0; i < V.length; i++) System.out.println(V[i]+" "); } }}     

Tema 54

Scrivere un metodo creaArrayConElementiDiagonalePrincipale che riceve in ingresso una matrice quadrata di interi M e preleva gli elementi della diagonale principale collocandoli in un array.

Ad esempio, sia M la matrice così costituita

1	2	3	7
4	5	6	8
7	8	9	3
8	6	5	4

allora estraiDiagonalePrincipale(M) darà

1

5

9

4

 public class tema54 { public static int[] estraiDiagonalePrincipale (int[][] M) { // approntiamo un array di dimensione pari alla dimensione di M int[] V = new int[M.length]; // in questo caso abbiamo bisogno di un solo ciclo e di un solo indice for(int i = 0; i < M.length; i++) // collochiamo nell’array gli elementi della matrice i cui indici coincidono V[i] = M[i][i]; return V; }  public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); } /* Applicazione di prova */  public static void main (String[] args) { int[][] Q ={ {1, 2, 3, 7}, {4, 5, 6, 8}, {7, 8, 9, 3}, {8, 6, 5, 4} }; visualizza (estraiDiagonalePrincipale (Q)); } }     

Tema 53

Scrivere un metodo isTriangolareSuperiore che riceve in ingresso una matrice di interi M e restituisce TRUE se essa risulta trinagolare superiore; FALSE altrimenti. Per il nostro obiettivo, definiamo matrice triangolare superiore una matrice in cui tutti gli elementi al di sotto della diagonale principale sono nulli e gli elementi dalla diagonale in su non sono tutti nulli.

Ad esempio, sia M la matrice così costituita

1	2	0	0
0	4	0	0
0	0	0	8
0	0	0	9

allora isTriangolareSuperiore(M) = TRUE

 public class tema53 { public static boolean isTriangolareSuperiore (int[][] M){ // basterà verificare che gli elementi al di sotto della diagonale principale // siano tutti nulli mentre i restanti // elementi non siano tutti nulli; in caso contrario il risultato sarà FALSE // approntiamo una variabile boolean che ci servirà per fare una doppia verifica boolean esito = true; // avviamo un ciclo per scorrere la parte sottostante la diagonale, cominciando // dalla prima riga e ancorando // la mobilità dell’indice delle colonne in maniera opportuna for(int i = 1; i < M.length; i++){ for(int j = 0; j < i-1; j++) // appena si dovesse individuare un elemento diverso da zero in questa porzione // di matrice if( M[i][j] != 0) // il risultato sarà negativo esito = false; } // nel caso in cui questa prima verifica desse risultato positivo, avviamo un // secondo ciclo per la seccessiva // verifica, cioè ci accertiamo che esista almeno un elemento non nullo tra i // restanti elementi for(int i = 0; i < M.length; i++){ for(int j = i; j < M[0].length; j++) // nel caso in cui venisse individuato un primo elemento diverso da zero e la // verifica precedente avesse // avuto esito positivo if (M[i][j] != 0 && esito) // il metodo restituirà TRUE return  true; } // altrimenti FALSE return false; }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M ={{1,2,0,0}, {0,4,0,0}, {0,0,0,8}, {0,0,0,9}}; System.out.println(isTriangolareSuperiore (M)); // il risultato sarà TRUE System.out.println(); int[][] Q ={{1,2,3,4}, {0,4,5,6}, {5,0,7,8}, {0,0,0,9}}; System.out.println(isTriangolareSuperiore (Q)); // il risultato sarà FALSE System.out.println(); // verifichiamo che non è sufficiente avere nulli tutti gli elementi al di sotto // della diagonale principale // ma occorre che ci sia almeno un elemento non nullo tra i restanti per // ottenere TRUE int[][] N ={{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,0,0,0}}; System.out.println(isTriangolareSuperiore (N)); } }     

Tema 52

Scrivere un metodo isTriangolareInferiore che riceve in ingresso una matrice di interi M e restituisce TRUE se essa risulta triangolare inferiore; FALSE altrimenti. Per il nostro obiettivo, definiamo matrice triangolare inferiore una matrice in cui tutti gli elementi al di sopra della diagonale principale sono nulli e gli elementi dalla diagonale in giù non sono tutti nulli.

Ad esempio, sia M la matrice così costituita

1	0	0	0
2	3	0	0
4	5	0	0
0	0	6	7

allora isTriangolareInferiore(M) = TRUE

 public class tema52 { public static boolean isTriangolareInferiore (int[][ ] M){ // basterà verificare che gli elementi al di sopra della diagonale principale // siano tutti nulli mentre i restanti // elementi non siano tutti nulli; in caso contrario il risultato sarà FALSE // approntiamo una variabile boolean che ci servirà per fare una doppia verifica boolean esito = true; // avviamo un ciclo per scorrere la parte soprastante la diagonale, cominciando // dalla prima riga e ancorando // la mobilità dell’indice delle colonne in maniera opportuna for(int i = 0; i < M.length; i++){ for(int j = i+1; j < M[0].length; j++) // appena si dovesse individuare un elemento diverso da zero in questa porzione // di matrice if (M[i][j] != 0) // il risultato sarà negativo esito = false;} // nel caso in cui questa prima verifica desse risultato positivo, avviamo un // secondo ciclo per la successiva // verifica, cioè ci accertiamo che esista almeno un elemento non nullo tra i // restanti elementi for(int i = 0; i < M.length; i++){ for(int j = 0; j < i+1; j++) // nel caso in cui venisse individuato un primo elemento diverso da zero e la // verifica precedente avesse // avuto esito positivo if (M[i][j] != 0 && esito) // il metodo restituirà TRUE return  true; } // altrimenti FALSE return false; }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M ={{1,0,0,0}, {2,3,0,0}, {4,5,6,0}, {0,0,0,7}}; System.out.println(isTriangolareInferiore (M)); // il risultato sarà TRUE System.out.println(); int[][] Q ={{1,0,0,7}, {2,3,0,0}, {4,5,6,0}, {0,0,6,7}}; System.out.println(isTriangolareInferiore (Q));  // il risultato sarà FALSE System.out.println(); // verifichiamo che non è sufficiente avere nulli tutti gli elementi al di sopra // della diagonale principale // ma occorre che ci sia almeno un elemento non nullo tra i restanti per // ottenere TRUE int[][] N ={{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,0,0,0}}; System.out.println(isTriangolareInferiore (N)); } }     

Tema 51

Scrivere un metodo creaTrasposta che riceve in ingresso una matrice di interi e crea la sua trasposta, cioè una matrice in cui saranno invertite righe e colonne.

Ad esempio, sia M la matrice così costituita

1	7	9	6
5	8	4	2

allora creaTrasposta (M) darà

1	5
7	8
9	4
6	2

 public class tema51 { public static int[][] creaTrasposta (int[][] M) { // prepariamo una matrice che dovrà avere le dimensioni di righe e colonne pari // rispettivamente a quelle // di colonne e righe della matrice di partenza int[][] T = new int[M[0].length][M.length]; for(int i = 0; i < M[0].length; i++){ for(int j = 0; j < M.length; j++) // trasferiamo in T gli elementi di M con indici invertiti rispetto alla // posizione di destinazione T[i][j] = M[j][i]; } return T; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println(); } }  /* Applicazione di prova */  public static void main(String[] args) { int[][] Q ={ {1, 7, 9, 6} , {5, 8, 4, 2} }; System.out.println("Stampa della matrice di partenza"); visualizzaMatrice (Q); System.out.println(); //separiamo i contenuti con una riga vuota System.out.println("Stampa della trasposta"); visualizzaMatrice (creaTrasposta(Q)); } }     

Tema 50

Scrivere un metodo verificaSeMatriceSimmetrica che riceve in ingresso una matrice di interi e restituisce TRUE se la matrice è simmetrica; FALSE altrimenti. Una matrice si dice simmetrica se l’elemento in posizione [i][j] è uguale all’elemento in posizione [j][i].

Ad esempio, sia M la matrice così costituita

1	7	3
7	1	5
3	5	9

allora verificaSeMatriceSimmetrica(M) = TRUE

 public class tema50 { public static boolean verificaSeMatriceSimmetrica ( int[][] M) { boolean simmetrica = false; // supponiamo non lo sia // scorriamo la matrice for(int i = 0; i < M.length; i++) { // facciamo partire l’indice i dal seguente valore in modo da confrontare // un’intera riga con un’intera colonna for(int j = i+1; j < M[0].length; j++) // scambiando l’indice di riga e l’indice di colonna controlliamo gli elementi // di nostro interesse if(M[i][j] == M[j][i]) simmetrica=true; } return simmetrica; }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M ={{1, 7, 3} , {7, 1, 5}, {3, 5, 9}}; // il risultato sarà TRUE System.out.println(verificaSeMatriceSimmetrica(M) ); int[][] Q ={{1, 2, 3} , {4, 5, 6}, {7, 8, 9}}; // il risultato sarà FALSE System.out.println(verificaSeMatriceSimmetrica(Q)); } }     

Tema 49

Scrivere un metodo verificaSeMatriceIdentica che riceve in ingresso una matrice di interi e restituisce TRUE se la matrice è identica; FALSE altrimenti. Una matrice si dice identica se gli elementi sulla diagonale principale sono tutti uguali a 1 e gli elementi al di fuori della diagonale sono uguali a 0.

Ad esempio, sia M la matrice così costituita

1	0	0
0	1	0
0	0	1

allora verificaSeMatriceIdenticai(M) = TRUE

 public class tema49{ public static boolean verificaSeMatriceIdentica (int[][] M) { // creiamo una variabile boolean e impostiamo il suo valore su TRUE, supponendo // che la matrice sia identica boolean identica = true; // scorriamo la matrice for(int i = 0; i < M.length; i++){ for(int j = 0; j < M[0].length; j++) // se si dovesse verificare uno dei seguenti casi il risultato del metodo // sarebbe FALSE if(i == j && M[i][j] != 1 || i != j && M[i][j] != 0) identica = false; } return identica; }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M ={ {1, 5} , {7, 9} }; // il risultato sarà FALSE System.out.println(verificaSeMatriceIdentica (M)); int[][] Q ={ {1, 0} , {0, 1} }; // il risultato sarà TRUE System.out.println(verificaSeMatriceIdentica (Q)); } }     

Tema 48

Scrivere un metodo trovaMassimoInMatrice che riceve in ingresso una matrice M di interi e stampa a video il valore più alto in essa presente.

 public class tema48 { public static int trovaMassimoInMatrice (int[][] M) { // il primo elemento di M viene scelto arbitrariamente come massimo provvisorio int max = M[0][0]; // effettuiamo una scansione della matricea riga per riga for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[0].length; j++) // se durante la scansione incontriamo un elemento più grande del primo, // sostituiamo il valore di max if (M[i][j] > max) max = M[i][j]; } return max; } /* Applicazione di Prova: Inizializziamo due matrici su cui testare il metodo;  * la prima matrice conterrà solo elementi positivi, la seconda matrice conterrà  * solo elementi negativi. */ public static void main(String[] args) { int[][] Q = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}; System.out.println("Il valore piu' grande contenuto nella matrice Q, e':"); System.out.println(trovaMassimoInMatrice (Q)); System.out.println(); int[][] H ={{-15,-4,-6}, {-5,-8,-7}, {-3,-6,-8}}; System.out.println("Il valore piu' grande contenuto nella matrice H, e':"); System.out.println(trovaMassimoInMatrice (H)); } }     

Tema 47

Scrivere un metodo verificaSeMatriciUguali che riceve in ingresso due matrice di interi M e Q e confronta uno a uno gli elementi per stabilire se le matrici sono uguali.

 public class tema47 { // approntiamo un metodo di supporto per confrontare le matrici riga per riga public static boolean verificaSeRigheUguali (int[] A, int[] B) { boolean uguali; if (A.length != B.length)    // se hanno dimensione diversa è ovvio che A e B sono diversi, perciò poniamo uguali = false; else { uguali = true; // confrontiamo A e B elemento per elemento for (int i = 0; uguali && i < A.length; i++) if (A[i] != B[i]) uguali = false;} return uguali; } // implementiamo adesso il metodo per verificare se le due matrici sono uguali public static boolean verificaSeMatriciUguali (int[][] M, int[][] Q) { boolean uguali; if (M.length != Q.length) // se le matrici hanno dimensione diversa il risultato è FALSE uguali = false; else { // verifichiamo che le matrici abbiano gli stessi elementi riga per riga uguali = true; for (int i = 0; uguali && i < M.length; i++) // sfruttiamo il metodo di supporto per verificare che le righe di una matrice // siano uguali // alle righe dell'altra, trattando ogni riga come fosse un array if (!verificaSeRigheUguali (M[i], Q[i])) uguali = false;} return uguali; }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M ={ {1, 5} , {7, 9} }; int[][] Q ={ {1, 5} , {7, 9} }; // matrici uguali ( il risultato sarà TRUE ) System.out.println(verificaSeMatriciUguali ( M, Q)); int[][] MM ={ {8, 9} , {3, 2} }; int[][] QQ ={ {2, 5} , {6, 9} }; // matrici diversi ( il risultato sarà FALSE ) System.out.println(verificaSeMatriciUguali ( MM, QQ)); } }     

Tema 46

Scrivere un metodo prodottoRighePerColonne che riceve in ingresso due matrici quadrate di interi e restituisce il risultato del prodotto righe per colonne.

Ad esempio, siano M e Q le matrici così costituite

1	2
3	4

2	5
1	1

allora prodottoRighePerColonne(M, Q) darà

(1×2)+(2×1) = 4	(1×5)+(2×1) = 7
(3×2)+(4×1) = 10	(3×5)+(4×1) = 19

 public class tema46{ public static int[][] prodottoRighePerColonne (int[][] M, int[][] Q){ // verifichiamo che il numero di righe di una matrice sia adeguato al numero di // colonne dell’altra matrice if (M.length != Q[0].length) return null; // la matrice risultante avrà naturalmente le seguenti dimensioni int[][] matriceRisultante  = new int[M.length][Q[0].length]; // approntiamo un contenitore in cui effettuare le operazioni tra gli elementi int calcolo = 0; for (int i = 0; i < matriceRisultante.length; i++) for (int j = 0; j < matriceRisultante[0].length; j++) { calcolo = 0; // usiamo un terzo ciclo che ci consentirà di spostarci solo tra le colonne di M // e solo tra le righe di Q for (int k = 0; k < M[0].length; k++) calcolo += M[i][k] * Q[k][j]; matriceRisultante[i][j] = calcolo; } return matriceRisultante; }  public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println();} }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = new int[][]{{1,2},{3,4}}; int[][] Q = new int[][]{{2,5}, {1,1}}; int[][] MxQ = prodottoRighePerColonne(M,Q); visualizzaMatrice(MxQ); } }     

Tema 45

Scrivere un metodo moltiplicaDueRighe che riceve in ingresso una matrice M e due interi R1 ed R2 e restituisce il risultato del prodotto tra la riga R1 e la riga R2.

Ad esempio, sia M la matrice così costituita

1	2	3	4
1	4	5	3
3	5	6	1
2	3	6	2

allora moltiplicaDueRighe(M, 1, 3) = (1×2)+(4×3)+(5×6)+(3×2) = 50

 public class tema45 { public static int moltiplicaDueRighe (int[][] M, int R1, int R2) { // prepariamo un contenitore di tipo intero in cui effettueremo le operazioni int calcolo = 0; // è sufficiente un solo ciclo visto che gli indici di riga sono valori noti for (int j = 0; j < M[0].length; j++) calcolo += M[R1][j]*M[R2][j]; return calcolo; }  /* Applicazione di prova */  public static void main(String[] args) { int[][] M = { {1,2,3,4},{1,4,5,3},{3,5,6,1},{2,3,6,2 }}; System.out.println(moltiplicaDueRighe(M, 1, 3)); } }     

Tema 44

Scrivere un metodo isSommaOgniRigaUguale che riceve in ingresso una matrice di interi M e restituisce TRUE se la somma degli elementi di ciascuna riga di M fornisce lo stesso risultato; FALSE altrimenti.

Ad esempio, sia M la matrice così costituita

1	3	0	6
2	1	7	0
4	3	1	2
8	1	1	0

allora isSommaOgniRigaUguale(M) = TRUE in quanto la somma di ogni riga è 10

 public class tema44 { public static boolean isSommaOgniRigaUguale (int[][] M) { // calcoliamo inizialmente la somma della prima riga int sommaPrimaRiga = 0; for (int j = 0; j < M[0].length; j++) { sommaPrimaRiga += M[0][j]; } // calcoliamo adesso la somma delle successive righe a partire dalla seconda for (int i = 1; i < M.length; i++) { int sommaSuccessiva = 0; for (int j = 0; j < M[0].length; j++) sommaSuccessiva += M[i][j]; // verifichiamo che la somma degli elementi di ogni altra riga sia uguale alla // somma della prima riga if (sommaSuccessiva != sommaPrimaRiga) return false; } return true; }  /* Applicazione di prova */ public static void main(String[] args) { int[][] M = new int[][]{{1,3,0,6}, {2,1,7,0}, {4,3,1,2}, {8,1,1,0}}; System.out.println(isSommaOgniRigaUguale(M)); } }     

Tema 43

Scrivere un metodo isPrimaRigaInversaDiUltimaRiga che riceve una matrice di interi M e restituisce TRUE se nella prima riga ci sono gli stessi elementi dell’ultima riga ma in ordine inverso.

Ad esempio, sia M la matrice così costituita

0	1	2	3	4
6	5	2	9	1
7	7	3	2	8
0	5	0	7	2
4	3	2	1	0

allora isPrimaRigaInversaDiUltimaRiga(M) = TRUE

 public class traccia71{ public static boolean isPrimaRigaInversaDiUltimaRiga (int[][] M){ boolean inversa = true; for (int i=0; i < M[0].length && inversa; i++) if (M[0][i] != M[M.length -1][M[0].length -1 -i]) inversa = false; return inversa; }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = {{0, 1, 2, 3, 4}, {6, 5, 2, 9, 1}, {7, 7, 3, 2, 8}, {0, 5, 0, 7, 2},{4, 3, 2, 1, 0}}; System.out.println(isPrimaRigaInversaDiUltimaRiga (M)); } }     

Tema 42

Scrivere un metodo isPrimaColonnaInversaDiUltimaColonna che riceve una matrice di interi M e restituisce TRUE se nella prima colonna ci sono gli stessi elementi dell’ultima colonna ma in ordine inverso.

Ad esempio, sia M la matrice così costituita

1	0	9	7	5
2	3	4	6	4
3	2	2	0	3
4	8	5	9	2
5	3	5	3	1

allora isPrimaColonnaInversaDiUltimaColonna(M) = TRUE

 public class tema42{ public static boolean isPrimaColonnaInversaDiUltimaColonna (int[][] M){ boolean inversa = true; for (int i = 0; i < M.length && inversa; i++) if (M[i][0] != M[M.length -1 -i][M[0].length -1]) inversa = false; return inversa; }  /* Applicazione di prova */  public static void main(String args[]) { int[][] M = { {1, 0, 9, 7, 5}, {2, 3, 4, 6, 4}, {3, 2, 2, 0, 3}, {4, 8, 5, 9, 2}, {5, 3, 5, 3, 1}}; System.out.println(isPrimaColonnaInversaDiUltimaColonna(M)); } }     

Tema 41

Scrivere un metodo isPrimaColonnaUgualeUltimaColonna che riceve una matrice di interi M e restituisce TRUE se la prima colonna è uguale all’ultima.

Ad esempio, sia M la matrice così costituita

1	2	4	6	1
2	8	10	3	2
3	6	9	1	3
4	5	7	8	4
5	3	2	1	5

allora isPrimaColonnaUgualeUltimaColonna(M) = TRUE

 public class tema41{ public static boolean isPrimaColonnaUgualeUltimaColonna (int[][] M){ boolean verifica = true; for (int i = 0; i < M.length && verifica; i++) if (M[i][0] != M[i][M[0].length -1]) verifica = false; return verifica; }  /* Applicazione di prova */  public static void main(String[] args){ int[][] M = new int[][] { {1, 2, 4, 6, 1}, {2, 8, 10, 3, 2}, {3, 6, 9, 1, 3}, {4, 5, 7, 8, 4}, {5, 3, 2, 1, 5}}; System.out.println(isPrimaColonnaUgualeUltimaColonna ( M )); } }     

Tema 40

Scrivere un metodo sommaElementiMatrice che riceve in ingresso una matrice di interi M e dopo aver effettuato la somma dei suoi elementi ne restituisce il risultato

Ad esempio, sia M la matrice così costituita

1	1	1
2	2	2
3	3	3

allora sommaElementiMatrice(M) = (1+1+1+2+2+2+3+3+3) = 18

 public class tema40 { public static int sommaElementiMatrice (int[][] M) { // prepariamo un contenitore di tipo intero in cui effettueremo l’operazione di // somma int somma = 0; // scorriamo gli elementi della matrice for (int i = 0; i < M.length; i++) for (int j = 0; j < M[i].length; j++) // aggiorniamo il risultato somma += M[i][j]; return somma; }  /* Applicazione di prova */  public static void main(String[] args) { int[][] Q = { {1,1,1},{2,2,2},{3,3,3} }; System.out.println(sommaElementiMatrice (Q)); } }     

Tema 39

Scrivere un metodo visualizzaMatrice che riceve in ingresso una matrice di interi M e visualizza i suoi elementi secondo una struttura bidimensionale.

 public class tema39 { public static void visualizzaMatrice (int[][] M) { for (int i = 0; i < M.length; i++) { for (int j = 0; j < M[i].length; j++) System.out.print(M[i][j] + " "); System.out.println(); } }  /* Applicazione di prova */  public static void main(String[] args) { int[][] Q = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};  /*nonostante abbiamo dato agli elementi una disposizione lineare, il metodo  * visualizzerà la matrice per quello che realmente è, cioè una struttura  * bidimensionale 3x3*/ visualizzaMatrice ( Q ); } }     

Tema 38

Scrivere un metodo riempiMatrice che consente di impostare le dimensioni di una matrice e di inserire gli elementi al suo interno.

 public class tema38{ public static int[][] riempiMatrice(){ // usiamo la class ReadStream per inserire da tastiera i valori delle dimensioni // e gli elementi ReadStream in = new ReadStream(); System.out.println("Inserisci il numero di righe "); int numeroRighe = in.readInt(); System.out.println("Inserisci il numero di colonne "); int numeroColonne = in.readInt(); int[][] M = new int[numeroRighe][numeroColonne]; System.out.println("Inserie elementi"); for (int i = 0; i < M.length; i++) for (int j = 0; j < M[0].length; j++) M[i][j] = in.readInt(); return M; }  /*APPLICAZIONE DI PROVA: Dichiariamo una matrice Q di interi pronta a ospitare  * gli elementi che saranno inseriti tramite l’invocazione del metodo  * riempiMatrice.*/  public static void main(String[] args) { int[][] Q = riempiMatrice(); } }     

Nota: Per l’inserimento da tastiera in questo caso è stata usata la classe ReadStream per comodità dell’autore. Naturalmente potrebbe essere usata una qualunque altra applicazione, ad esempio Console o Scanner.

Tema 37

Scrivere un metodo creaArrayConElementiMultipliDeiPrecedenti che riceve in ingresso un array di interi V e restituisce un array di interi A contenente gli elementi di V che sono multipli di tutti gli elementi da cui sono preceduti.

Ad esempio, sia V un array così costituito

5

2

10

30

3

90

allora creaArrayConElementiMultipliDeiPrecedenti(V) darà

10

30

90

 public class tema37 { // creiamo un metodo di supporto che ci consentirà di valutare se un elemento è // multiplo dei precedenti public static boolean isMultiploDeiPrecedenti (int[] V, int j) { for (int i = 0; i < j; i++) if(V[j] % V[i] != 0) return false; return true; }  // con il seguente metodo calcoliamo la dimensione che dovrà avere il vettore da // realizzare public static int calcolaDim (int[] V) { int dim = 0; for (int i = 1; i < V.length; i++) if (isMultiploDeiPrecedenti(V,i)) dim++; return dim; }  // creiamo il metodo richiesto dalla traccia public static int[] creaArrayConElementiMultipliDeiPrecedenti (int[] V) { int dim = calcolaDim(V); int[] W = new int[dim]; int indice = 0; for (int i = 1; i < V.length; i++) if (isMultiploDeiPrecedenti(V,i)) { W[indice] = V[i]; indice++; } return W; }  /* Applicazione di Prova */  public static void main (String[] args) { int[] V = {5,2,10,30,3,90}; int[] A = creaArrayConElementiMultipliDeiPrecedenti(V); for (int i =0 ; i < A.length; i++) System.out.println(A[i]); } }     

Tema 36

Scrivere un metodo isPariSommaElementiSuccessivii che riceve in ingresso un array di interi V e restituisce un array di boolean, della stessa dimensione di V, in cui il valore dell’i-esima posizione è uguale a TRUE se la somma degli elementi in posizione maggiore uguale ad i è un numero pari; FALSE altrimenti.

Ad esempio, se V così costituito

1

2

3

4

5

6

7

allora isPariSommaElementiSuccessivi(V) darà

true

false

false

true

true

false

false

 public class tema36 { public static boolean[] isPariSommaElementiSuccessivi (int[] V) { // approntiamo un array di boolean della stessa dimensione di V boolean [] B = new boolean[V.length]; // cominciamo a scorrere l’array dal primo elemento for (int i = 0; i < V.length; i++){ int somma = 0; // con un secondo ciclo, che parte dall’i-esimo elemento e giunge all’ultimo // elemento aggiorniamo la somma for(int j = i ; j < V.length; j++) somma = somma + V[j]; // verifichiamo se tale somma è un numero pari o dispari e a seconda del // risultato poniamo l’iesimo valore // dell’array B a TRUE oppure a FALSE if(somma % 2 == 0) B[i] = true; else B[i]=false;} return B; } /* Applicazione di Prova */  public static void main(String[] args) { int [] A = {1,2,3,4,5,6,7}; boolean[] B = isPariSommaElementiSuccessivi (A); for (int i = 0; i < B.length; i++) System.out.println(B[i]); } }     

Tema 35

Scrivere un metodo isPariSommaElementiPrecedenti che riceve in ingresso un array di interi V e restituisce un array di boolean, della stessa dimensione di V, in cui il valore dell’i-esima posizione è uguale a TRUE se la somma degli elementi in posizione minore uguale ad i è un numero pari; FALSE altrimenti.

Ad esempio, sia V l’array così costituito

1

2

3

4

5

6

7

allora isPariSommaElementiPrecedenti(V) darà

false

false

true

true

false

false

true

 public class tema35 { public static boolean[] isPariSommaElementiPrecedenti (int[] V) { // approntiamo un array di boolean della stessa dimensione di V boolean [] B = new boolean[V.length]; // cominciamo a scorrere l’array dal primo elemento for (int i = 0; i < V.length; i++){ // prepariamo un contenitore in cui effettueremo la somma degli elementi int somma = 0; // con un secondo ciclo, che parte dal primo elemento e giunge all’i-esimo // elemento aggiorniamo la somma for(int j = 0; j <= i; j++) somma = somma + V[j]; // verifichiamo se tale somma è un numero pari o dispari e a seconda del // risultato poniamo l’iesimo valore // dell’array  B a TRUE oppure a FALSE if(somma % 2 == 0) B[i] = true; else B[i] = false;} return B; }  /* Applicazione di Prova */  public static void main(String[] args) { int [] A = {1,2,3,4,5,6,7}; boolean[] B = isPariSommaElementiPrecedenti (A); for (int i = 0; i < B.length; i++) System.out.println(B[i]); } }     

Tema 34

Scrivere un metodo trovaElementoConMaggioreFrequenzaInArray che riceve in ingresso un array di interi V e restituisce l’elemento dell’array che compare più volte.

Ad esempio, sia V l’array così costituito

1

2

3

4

5

2

4

2

6

4

2

5

6

4

4

allora trovaElementoConMaggioreFrequenzaInArray(V) = 4

 public class tema34 { // creiamo un metodo di supporto con cui calcolare la frequenza di ogni elemento public static int calcolaFrequenza (int[] V, int k) { int cont = 0; for (int i = 0; i < V.length; i++) if(V[i] == k) cont++; return cont; } // creiamo il metodo richiesto dalla traccia public static int trovaElementoConMaggioreFrequenzaInArray (int[] V) { // dichiariamo un array della stessa dimensione di V in cui memorizzare la // frequenza di ciascun elemento int[] arrayFrequenze = new int[V.length]; for (int i = 0; i < V.length; i++) { // memorizziamo nell’array le frequenze degli elementi calcolate col metodo // precedente arrayFrequenze[i] = calcolaFrequenza (V, V[i]); } //inizializziamo una variabile che useremo nella procedura di ricerca del valore //massimo dell’arrayFrequenze int max = 0; // inizializziamo una variabile in cui memorizzeremo l’elemento dell’array di // partenza associato alla // frequenza più alta int elementoCorrispondente = 0; for (int i = 0; i < arrayFrequenze.length; i++) if( arrayFrequenze[i] > max) { max = arrayFrequenze[i]; elementoCorrispondente = V[i]; } return elementoCorrispondente; }  /* Applicazione di Prova */  public static void main (String[] args) { int[] V = {1, 2, 3, 4, 5, 2, 4, 2, 6, 4, 2, 5, 6, 4, 4}; System.out.println (trovaElementoConMaggioreFrequenzaInArray (V)); } }     

Tema 33

Scrivere un metodo verificaSeOgniElementoDelPrimoArrayOccorrePiuVolteNelSecondoArray che riceve in ingresso due vettori di interi A e B e estituisce TRUE se ciascun elemento del primo array è presente al più una volta nel secondo; FALSE altrimenti.

 public class tema33{ public static boolean verificaSeOgniElementoDelPrimoArrayOccorrePiuVolteNelSecondoArray (int[] A, int[] B) { for (int i = 0; i < A.length; i++) { int n = 0; for (int j = 0; j < B.length; j++) { if (A[i] == B[j]) n++; if (n > 1) return false;} } return true; }  /* Applicazione di Prova */  public static void main(String args[]) { int[] V = { 5, 9, 12, 1 }; int[] W = { 2, 3, 9, 10, 9 }; int[] Z = { 5, 9, 12, 1, 3, 4, 7 }; System.out.println(verificaSeOgniElementoDelPrimoArrayOccorrePiuVolteNelSecondoArray (V, W)); // otterremo FALSE perché non tutti gli elementi di V sono presenti in W e il 9 // si ripete più volte System.out.println(verificaSeOgniElementoDelPrimoArrayOccorrePiuVolteNelSecondoArray (V, Z)); // otterremo TRUE perchè ogni elemento di V è presente solo una volta in Z } }     

Tema 32

Scrivere un metodo creaArrayConElementiDiApresentiMassimoDueVolteInBminimoQuattroIn che riceve in ingresso tre array di interi A, B, C e restituisce un array che contiene solo gli elementi di A presenti massimo due volte in B e minimo quattro volte in C.

Ad esempio, siano A, B, C i vettori così costituiti

A
4	5	6	7	9

B
4	10	6	6	12	4	3	7

C
4	6	4	4	4

allora creaArrayConElementiDiApresentiMassimoDueVolteInBminimoQuattroInC( A, B, C) = 4

 public class tema32{ // creiamo un metodo di supporto per verificare se un elemento è presente al // massimo 2 volte in un array public static boolean isPresenteMassimoDueVolte (int p, int[] V) { boolean esito = false; int contaPresenze = 0; for (int i = 0; i < V.length; i++) { if (V[i] == p) // man mano che un elemento risulta presente più volte nell’array incrementiamo // la variabile contaPresenze ++; // controlliamo che il numero di presenze non superi il numero 2 if (contaPresenze <= 2) // e in tal caso poniamo a TRUE la variabile boolean esito = true; } return esito; }  public static boolean isPresenteAlmenoQuattroVolte (int p, int[] V) { // creiamo un metodo di supporto per verificare se un elemento è presente almeno // 4 volte in un array boolean esito = false; int contaPresenze = 0; for (int i = 0; i < V.length; i++) { if (V[i] == p) // man mano che un elemento risulta presente più volte nell’array incrementiamo // la variabile contaPresenze++; // controlliamo che il numero di presenze non sia inferioe al numero 4 if (contaPresenze >= 4) // e in tal caso poniamo a TRUE la variabile boolean esito = true; } return esito; } // creaimo adesso il metodo finale public static int[] creaArrayConElementiDiApresentiMassimoDueVolteInBminimoQuattroInC (int[] A, int[] B, int[] C) { // approntiamo un array temporaneo della stessa dimensione di A // la scelta di tale dimensione è dovuta al fatto che tutti gli elementi di A // potrebbe soddisfare il requisito int[] arrayTemporaneo = new int[A.length]; // inizializziamo un indice per scorrere l’array temporaneo int indice = 0; // iniziamo a scorrere l’array da testare for (int i = 0; i < A.length; i++) // effettuiamo I controlli usando i metodi precedent che invochiamo sui singoli // elementi dell’array A // e rispettivamente sugli array B e C if (isPresenteMassimoDueVolte (A[i], B) && isPresenteAlmenoQuattroVolte (A[i], C)) // nel caso di esito affermativo da parte di entrambi i metodi precedenti, // trasferiamo gli elementi // che hanno soddisfatto il requisito nell’array temporaneo arrayTemporaneo[indice] = A[i]; // incrementiamo l’indice indice++; // prepariamo adesso un array con la giusta dimensione int[] Z = new int[indice]; for (int i = 0; i < Z.length; i++) Z[i] = A[i]; return Z; }  /* Applicazione di Prova */  public static void main (String args[]) { int[] A= {4, 5, 6, 7, 9}; int[] B = {4, 10, 6, 6, 12, 4, 3, 7 }; int[] C = {4, 6, 4, 4, 4 }; int[] V = creaArrayConElementiDiApresentiMassimoDueVolteInBminimoQuattroInC (A, B, C); // stampiamo l’array contenente il risultato del metodo for (int i = 0; i < V.length; i++) System.out.println (V[i]); } }     

Tema 31

Scrivere un metodo creaArrayConMedieOppureConDifferenze che riceve in ingresso un vettore di interi V e restituisce un vettore A della stessa dimensione di V e così costituito: A[i] è pari alla media degli elementi di V con indice maggiore o uguale di i, se tale media è maggiore o uguale di V[i]; in caso contrario A[i] è pari alla differenza tra la somma degli elementi alla sinistra di V[i] e la somma degli elementi alla destra di V[i]; Se non ci sono elementi alla destra o alla sinistra dell’elemento, tale somma vale zero.

Ad esempio, se V =[ 12, 4, 9, 6, 1, 7] allora A =[ -27, 5, 2, 17, 4, 7 ].

 public class tema31{ public static int[] creaVettoreConMedieOppureConDifferenze (int[] V){ // creiamo un array della stessa dimensione di V int[] A = new int[V.length]; // scorriamo l’array e calcoliamo la media degli elementi successivi for (int i = 0; i < V.length; i++){ int somma = 0; for (int j = i; j < V.length; j++) somma += V[j]; double media = somma / (V.length - i); if (media >= V[i]) // se la media soddisfa il requisito collochiamo il valore della media // nell’array A // forziamo ad int il valore della media che naturalmente potrebbe anche essere // un valore decimale A[i] = (int)media; else{ // prepariamo il contenitore delle somme inizializzandolo a 0 int sigma = 0; for (int j = 0; j < V.length; j++){ if (j < i) sigma += V[j]; if(j  > i) sigma -= V[j]; } A[i] = sigma; } } return A; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] V = { 12, 4, 9, 6, 1, 7}; int[] A = creaVettoreConMedieOppureConDifferenze (V); for (int i = 0; i < A.length; i++) System.out.print(A[i] + " "); System.out.println(); } }     

Tema 30

Scrivere un metodo estraiElementiDelPrimoArrayMultipliDiQualcheElementoDelSecond che riceve in ingresso due vettori A e B di interi, e restituisce un vettore Z contenente gli elementi di B che sono multipli di qualche elemento di A. Ad esempio, siano A e B due array così costituiti

A
25	13	19	8

B
2	3	5	7	11

allora estraiElementiDelPrimoArrayMultipliDiQualcheElementoDelSecondo( A, B) darà

25

8

 public class tema30{ // creiamo un metodo per individuare se un valore è multiplo di qualche elemento // contenuto in un array public static boolean isMultiplo (int x, int[] V){ boolean esito = false; for (int i = 0; i < V.length && !esito; i++){ if (x % V[i] == 0) esito = true; } return esito; }  // creiamo adesso il metodo richiesto dalla traccia static int[] estraiElementiDelPrimoArrayMultipliDiQualcheElementoDelSecondo (int[] V, int[] W){ // creiamo un array temporaneo della stessa dimensione dell’array i cui elementi // dovranno soddisfare il // criterio, nel caso in cui tutti gli elementi soddisfino il requisito int[] arrayTemporaneo = new int[W.length]; // creiamo un indice per scorrere l’array temporaneo int indice = 0; for (int i = 0; i < W.length; i++){ if (isMultiplo(W[i],V)) { // ogni elemento di W che risulta essere multiplo di un elemento di V sarà // collocato nell’array temporaneo arrayTemporaneo[indice] = W[i]; indice++;} } // adesso creiamo un array Z con l’esatta dimensione per contenere solo gli // elementi che hanno soddisfatto il // criterio int[] Z = new int[indice]; for (int i = 0; i < Z.length; i++){ Z[i] = arrayTemporaneo[i]; } return Z; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] A = {2, 3, 5, 7, 11}; int[] B = {25, 13, 19, 8}; int[] Z = estraiElementiDelPrimoArrayMultipliDegliElementiDelSecondoArray (A, B); for (int i = 0; i < Z.length; i++) System.out.println(Z[i]); } }     

Tema 29

Scrivere un metodo creaVettoreConElementiDiARipetutiInB che riceve in ingresso due vettori di interi A e B e restituisce un vettore di interi Z contenente gli elementi di A che sono presenti in B un numero di volte pari all’elemento stesso.

Ad esempio, se A = [1, 2, 3, 4, 5] e B = [4, 2, 4, 2, 7, 4, 4, 9, 5], il metodo restituisce Z = [2, 4] poiché il 2 è presente esattamente due volte in B e il 4 è presente esattamente quattro volte in B.

 public class tema29{ // creiamo un metodo di supporto per verificare quante volte un elemento è // presente in un array public static int verificaPresenza (int[] V, int k){ int contaPresenze = 0; for (int i = 0; i < V.length; i++) if (V[i] == k) contaPresenze++; return contaPresenze; } // creiamo un metodo che calcola la dimensione che dovrà avere il nuovo array in // base a quanti elementi // rispettano il criterio public static int calcolaDim (int[] V, int[] T){ int dim = 0; for (int i = 0; i < V.length; i++) // verifichiamo se la frequenza di un elemento di un array, nell'altro array, è // pari al numero stesso if (verificaPresenza ( T, V[i] ) == V[i]) // in caso affermativo incrementiamoo la dimensione dim++; return dim; } // creiamo adesso il metodo conclusivo public static int[] creaVettoreConElementiRipetuti (int[] V, int[] W){ // calcoliamo la dimensione che dovrà avere l'array finale int dim = calcolaDim(V, W); int[] arrayFinale = new int[dim]; // creiamo un indice per scorrere l’array finale int indice = 0; // scorriamo l’array da valutare for (int i = 0; i < V.length; i++) // verifichiamo se ci sono elementi che soddisfano il criterio if (verificaPresenza (W, V[i]) == V[i]) { // in caso affermativo copiamo tali elementi nell'array finale arrayFinale[indice] = V[i]; indice++; } return arrayFinale; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] A ={1, 2, 3, 4, 5}; int[] B ={4, 2, 4, 2, 7, 4, 4, 9, 5}; int[] Z = creaVettoreConElementiRipetuti (A, B); for (int i = 0; i < Z.length; i++){ System.out.print(Z[i]+" ");} } }     

Tema 28

Scrivere un metodo esisteElementoInACheSommatoConElementoDiBverificaSomma che riceve in ingresso due vettori di interi A e B e un intero k e restituisce TRUE se per ogni elemento di A esiste in B un elemento corrispondente tale che A[i] + B[j] = k, FALSE altrimenti.

Ad esempio, siano A e B due array così costituiti

A
3	7	6	1	8

B
5	4	11	7	9	8	2	3

allora esisteCorrispondenteCheVerificaSomma ( A, B, k) = TRUE

 public class tema28 { public static boolean esisteCorrispondenteCheVerificaSomma (int[] A, int[] B, int k){ // cominciamo a scorrere l’array A dal primo elemento for (int i = 0; i < A.length; i++){ boolean esiste = false; // ora scorriamo l’array B alla ricerca di un elemento che soddisfi il criterio for (int j = 0; j < B.length && !esiste; j++) if (A[i] + B[j] == k) // se l’elemento cercato esiste impostiamo la variabile boolean sul valore TRUE esiste = true; if (!esiste) return false; } return true; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] A ={3, 7, 6, 1, 8}; int[] B ={5, 4, 11, 7, 9, 8, 2, 3}; System.out.println(esisteCorrispondenteCheVerificaSomma (A, B, 10)); } }     

Tema 27

Scrivere un metodo creaArrayConFattoriali che riceve in ingresso un vettore di interi V e restituisce un vettore A della stessa dimensione di V contenente in ogni cella il fattoriale del corrispondente elemento dell’array V.

Ad esempio, sia V così costituito

3

4

0

5

6

7

allora creaArrayConFattoriali (V) darà

6

24

1

120

720

5040

 public class tema27 { // approntiamo un metodo per calcolare il fattoriale di un numero qualunque public static int fattoriale (int n) { // naturalmente il fattoriale può essere calcolato solo su valori >=0 if (n == 0) // poichè il fattoriale di 0 è 1 return 1; else { int fattor = 1; for (int i = 1; i < = n; i++) fattor  *= i; return fattor;} }  // adesso implementimo il metodo richiesto dalla traccia public static int[] creaArrayConFattoriali (int[] V) { // prepariamo un array di interi della stessa dimensione di V int[] A = new int [V.length]; for (int i = 0; i < V.length; i++) // in ogni cella di A collochiamo il risultato del metodo fattoriale applicato // al corrispondente elemento A[i] = fattoriale(V[i]); return A; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] V ={3, 4, 0, 5, 6, 7}; int[] A = creaArrayConFattoriali (V); for (int i = 0; i < A.length; i++) System.out.println(A[i]); } }     

Tema 26

Scrivere un metodo verificaSeUnArrayContieneUnSecondoArray che riceve in ingresso due vettori di interi A e B, e restituisce TRUE se il vettore B è contenuto in A, cioè se tutti gli elementi di B sono presenti in A consecutivamente e nello stesso ordine.

Ad esempio, se A = [ 1, 2, 3, 4, 5] e B = [ 2, 3, 4 ], il metodo restituisce TRUE; se B = [3, 4, 5, 6, 7] il metodo restituisce FALSE.

 public class tema26 { public static boolean verificaSeUnArrayContieneUnSecondoArray (int[] A, int [] B) { // se già la dimensione di B fosse maggiore della dimensione di A otterremmo // FALSE if (B.length > A.length) return false; // in caso contrario creiamo un ciclo il cui indice ha come limite massimo il // valore dato dalla differenza // tra le dimensioni dei due array for (int i = 0; i < = A.length - B.length; i++) { boolean contenuto = true; // con un secondo ciclo scorriamo gli elementi dell’array B for (int j = 0; j < B.length && contenuto; j++) if (B[j] != A[i + j]) contenuto = false; if (contenuto) return true; } return false; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] A ={1, 2, 3, 4, 5}; int[] B ={2, 3, 4}; System.out.println(verificaSeUnArrayContieneUnSecondoArray (A, B)); // in questo caso otteniamo TRUE int[] Z ={3, 4, 5, 6, 7}; System.out.println(); System.out.println(verificaSeUnArrayContieneUnSecondoArray (A, Z)); // in questo caso otteniamo FALSE } }     

Tema 25

Scrivere un metodo trovaDueConsecutiviPositiviOppureNegativi che riceve in ingresso un vettore V e restituisce TRUE se in V sono presenti due elementi consecutivi entrambi positivi o entrambi negativi. Ad esempio, se V =[1, -4, 6, 0, 5, -1] il metodo restituisce FALSE; se V =[7, -2, 9, 1, -6] il metodo restituisce TRUE

 public class tema25{ public static boolean trovaDueConsecutiviPositiviOppureNegativi (int[] V){ // inizializziamo una variabile boolean al valore FALSE boolean esistono = false; // la scansione dell’array verrà portata avanti fin quando il valore della // variabile esistono non verrà modificato e cioè fin quando i due elementi non // verranno trovati for (int i = 1; i < V.length && !esistono; i++) if ((V[i] > 0) && (V[i-1] > 0) || (V[i] < 0) && (V[i-1] < 0)) esistono = true; return esistono; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] A ={1, -4, 6, 0, 5, -1}; int[] B ={7, -2, 9, 1, -6}; System.out.println(trovaDueConsecutiviPositiviOppureNegativi (A)); System.out.println(); System.out.println(trovaDueConsecutiviPositiviOppureNegativi (B)); } }     

Tema 24

crivere un metodo stampaElementiDelPrimoArrayMaggioriDegliElementiDelSecondoArray che riceve in ingresso due vettori di interi A e B e stampa gli elementi di A maggiori di tutti gli elementi di B.

Ad esempio, siano A e B due array così costituiti

A
60	30	25	38

B
16	20	30	28	15

allora stampaElementiDelPrimoArrayMaggioreDegliElementiDelSecondoArray (A, B) darà

60

38

 public class tema24{ // usiamo come metodo di supporto il metodo trovaMassimo già illustrato in // precedenza public static int trovaMassimo (int[] V) { //il primo elemento di V viene scelto arbitrariamente come massimo provvisorio int max = V[0]; //effettuiamo una scansione dell'array partendo dal secondo elemento for (int i = 1; i < V.length; i++) { //se durante la scansione incontriamo un elemento più grande del primo, //aggiorniamo il valore di max if (V[i] > max) max = V[i]; } return max; } // creiamo il metodo conclusivo public static void stampaElementiDelPrimoArrayMaggioriDegliElementiDelSecondoArray (int[] A, int[] B){ // usiamo il metodo trovaMassimo sull’array B int massimoDiB = trovaMassimo (B); // effettuiamo una scansione  su A alla ricerca degli elementi più grandi // rispetto al massimo di B for (int i = 0; i < A.length; i++) if (A[i] > massimoDiB) // man mano che saranno trovati verranno stampati a video System.out.println(A[i]); }  /* Applicazione di Prova */  public static void main(String[] args){ int[] A ={60, 30, 25, 38}; int[] B ={16, 20, 30, 28, 15}; stampaElementiDelPrimoArrayMaggioriDegliElementiDelSecondoArray (A, B); } }     

Tema 23

Scrivere un metodo sommaElementiPrimoArrayConIndiceDatoDaElementiSecondoArray che riceve in ingresso due array di interi A e B, e calcola la somma degli elementi di A i cui indici coincidono con gli elementi di B. Ad esempio, se A =[12, 7, 4, 9, 10, 8] e B =[1, 3, 5], allora il risultato sarà 24 poiché verrebbero sommati gli elementi con indice 1, 3, 5, cioè il 7, il 9 e l’8.

 public class tema23{ public static int sommaElementiPrimoArrayConIndiceDatoDaElementiSecondoArray (int[] V, int[] W) { int somma = 0; // creiamo un ciclo per scorrere l’array V for (int i = 0; i < V.length; i++) { // creiamo un secondo ciclo per scorrere l’array W for (int j = 0; j < W.length; j++) // verifichiamo se l’indice su cui si trova il primo ciclo è uguale al valore // dell’elemento in W if (i == W[j]) { // in caso positivo aggiorniamo la somma addizionando il corrispondnete valore // dell’array V somma += V[i]; } } return somma; } /* Applicazione di Prova */ public static void main(String[] args) { int[] A = { 12, 7, 4, 9, 10, 8 }; int[] B = { 1, 3, 5}; System.out.println(sommaElementiPrimoArrayConIndiceDatoDaElementiSecondoArray(A, B)); } }     

Tema 22

Scrivere un metodo isArrayValoriAlternatiPariDispari che riceve in ingresso un vettore di interi V e restituisce TRUE se V è un vettore a valori alternati pari e dispari, cioè non ci sono due elementi consecutivi entrambi pari o entrambi dispari. Si consideri lo 0 come valore pari. Ad esempio, V = [4, 5, 2, 7, 6, 1] è a valori alternati pari e dispari, mentre il vettore A = [3, 5, 2, 7,4, 9 ] non lo è.

 public class tema22{ public static boolean isArrayValoriAlternati (int[] V) { // inizializziamo una variabile boolean al valore TRUE che modificheremo appena // dovessimo // incontrare due valori che non rispettano il criterio richiesto boolean valoriAlternati = true; // facciamo partire il ciclo dal secondo elemento per rendere il procedimento // coerente con // la scelta fatta sui controlli i quali mirano a verificare un elemento e il // suo precedente for (int i=1; i < V.length && valoriAlternati; i++) if ((V[i] % 2 == 0) && (V[i-1] % 2 == 0) || (V[i] % 2 == 1) && (V[i-1] % 2 == 1)) valoriAlternati = false; return valoriAlternati; } /* Applicazione di Prova */ public static void main(String[] args){ int[] A ={4, 5, 2, 7, 6, 1}; // array a valori alternati per il quale atterremo TRUE int[] B ={3, 5, 2, 7,4, 9 }; // array a valori non alternati per il quale otterremo FALSE System.out.println(isArrayValoriAlternati (A)); System.out.println(); System.out.println(isArrayValoriAlternati (B)); } }     

Tema 21

Scrivere un metodo estraiMassimiDaiSottovettori che riceve in ingresso un vettore di interi V e un intero k e restituisce un sottovettore W formato dai massimi dei sottovettori di V ottenuti considerando k elementi consecutivi di V alla volta. Ad esempio, se V = [ 10, -8, 20, 15, 7, 38, 50, 80, 100, 75] e k = 3, allora W = [20, 38, 100, 75] avendo considerato i sottovettori [10, -8, 20], [15, 7, 38], [50, 80, 100] e [75]

 public class tema21{ public static int [] estraiMassimiDaiSottovettori (int[] V, int k) { int arrotondamento = 0; // verifichiamo che la dimensione dell'array V sia multipla dell'estensione dei // sottovettori if (V.length  %  k > 0) arrotondamento = 1; // se la divisione tra la dimensione di V e l'estensione dei sottovettori non è // esatta (presenta quindi un // resto), la dimensione dell'array risultante sarà data dalla seguente // operazione int [] arrayRisultante = new int[V.length/k + arrotondamento]; for (int i = 0; i < arrayRisultante.length; i++) { // creiamo un indice, posizione, che ci consenta di fare salti pari // all'estensione nello scorrere l'array int posizione = i*k; // con il solito meccanismo, poniamo arbitrariamente che il primo elemento di // ogni sottovettore sia il // valore massimo int max = V[posizione]; // andiamo adesso a verificare se all'interno del sottovettore ci sono elementi // maggiori con cui // sostituire il valore di max for (int j = posizione; j < (posizione + k) && j < V.length; j++) if (max < V[j]) max = V[j]; // inseriamo in arrayRisultante i valori più alti individuati nei sottovettori arrayRisultante[i] = max; } return arrayRisultante; }  public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); }  /* Applicazione di Prova */  public static void main(String args[]) { int[] V = {10, -8, 20, 15, 7, 30, 80, 50, 100, 75}; visualizzaArray (V); int[] A = estraiMassimiDaiSottovettori (V, 3); visualizzaArray (A); } }     

Tema 20

Scrivere un metodo ricercaBinaria che riceve in ingresso un array ordinato di interi V e uno specifico elemento da cercare al suo interno. Il metodo suddivide l’array in due metà e scarta, di volta in volta, la metà che di certo non contiene il valore cercato.

 public class tema20 { public static int ricercaBinaria (int[] V, int valoreCercato) { // inizializziamo il valore della variabile posizione a -1 int posizione = -1; int sinistra;    // indice del primo elemento dello spazio di ricerca int destra;      // indice del primo elemento oltre lo spazio di ricerca int centro;     // indice dell'elemento centrale dello spazio di ricerca // inizialmente lo spazio di ricerca comprende tutti gli elementi di V sinistra = 0; destra = V.length; while (posizione == -1 && sinistra < destra) { centro = (sinistra+destra)/2; // verifichiamo se l’elemento centrale dell’array coincide con valoreCercato, if (V[centro] == valoreCercato) // in tal caso avremmo già il risultato posizione = centro; else if (V[centro] > valoreCercato) // se l’elemento centrale è maggiore di valoreCercato, la ricerca continuerà // nella metà sinistra // dell’array e quindi centro diverrà il nuovo estremo destro dello spazio di // ricerca destra = centro; else // altrimenti, la ricerca continuerà nella metà destra dell’array e centro+1 // diverrà il nuovo // estremo sinistro dello spazio di ricerca sinistra = centro+1; } return posizione; }  /* Applicazione di Prova */  public static void main(String[] args) { System.out.println(ricercaBinaria(new int[] { 5, 7, 11, 4, 3, 27, 42 }, 27)); } }     

Tema 19

Scrivere un metodo ricercaSequenziale che riceve in ingresso un array di interi V e uno specifico elemento da cercare al suo interno. Il metodo scorre uno alla volta tutti i valori fino a trovare l’elemento voluto e restituisce la posizione che esso occupa nell’array. Se l’elemento cercato non si trova nell’array, il metodo restituisce il valore -1.

 public class tema19 { public static int ricercaSequenziale(int[] V, int valoreCercato) { // inizializziamo il valore della variabile posizione a -1 int posizione = -1; // scorriamo gli elementi di V alla ricerca della prima occorrenza di // valoreCercato for (int i = 0; posizione == -1 && i < V.length; i++) if (V[i] == valoreCercato) posizione = i; return posizione; }  /* Applicazione di Prova */  public static void main(String[] args) { // forniamo un array vuoto nel quale cerchiamo il numero 7; naturalmente il // risultato sarà -1 System.out.println(ricercaSequenziale(new int[] { }, 7)); System.out.println(); System.out.println(ricercaSequenziale(new int[] { 6, 9, 2 }, 2)); System.out.println(); // nel caso in cui valoreCercato figuri più volte nell'array, il metodo // restituisce la posizione del primo // elemento trovato System.out.println(ricercaSequenziale(new int[] { 5, 3, 2, 3 }, 3)); } }     

Tema 18

Scrivere un metodo unisciDueArrayOrdinati che riceve in ingresso due array ordinati di interi A e B, e restituisce un unico array costituito dagli elementi di A e di B, congiunti in modo crescente. Ad esempio, siano A e B due array così costituiti

A
1	3	7	10

B
5	9	14	21

allora unisciDueArrayOrdinati (A, B) darà

1

3

5

7

9

10

14

21

 public class tema18 { // siano A e B due array ordinati in modo non decrescente public static int[] unisciDueArrayOrdinati (int[] A, int[]B) { // l'array risultante avrà dimensione pari alla somma delle due dimensioni dei // singoli array int[] arrayRisultante = new int[A.length+B.length]; int iA = 0; // indice per la scansione dell'array A int iB = 0; // indice per la scansione dell'array B int iR = 0; // indice per la scansione dell'array arrayRisultante while (iA < A.length && iB < B.length) { // inseriamo in arrayRisultante il valore più piccolo tra A[iA] e B[iB] if (A[iA] < B[iB]) { arrayRisultante[iR] = A[iA]; iA++; } else { arrayRisultante[iR] = B[iB]; iB++; } iR++; } // a questo punto inseriamo gli elementi  di A e B che inizialmente erano stati // tralasciati per rispettare // l’ordinamento crescente // inseriamo prima gli elementi di A while (iA < A.length) { arrayRisultante[iR] = arrayRisultante[iA]; iA++;    iR++; } // adesso inseriamo gli elementi di B while (iB < B.length) { arrayRisultante[iR] = B[iB]; iB++;    iR++; } return arrayRisultante; }  public static void visualizzaArray (int[] V) { for (int i = 0; i < V.length; i++) System.out.print(V[i] + " "); System.out.println(); }  /* Applicazione di Prova: Usiamo due array su cui testare il metodo  * inizializzandoli direttamente all'interno dell'invocazione del metodo  * unisciArray, a sua volta innestato all'interno del metodo visualizza. */  public static void main(String[] args) { visualizzaArray ( unisciDueArrayOrdinati ( new int[] { 1,3,7,10 }, new int[] { 5,9,14,21 } ) ); } }     

Tema 17

Scrivere un metodo contaReplicatiInArray che riceve in ingresso un array di interi V e restituisce il numero di elementi replicati di V, cioè quelli che occorrono più volte. Ad esempio, se V =[1, 2, 3, 2, 4, 5, 2] il risultato sarà 3, infatti V[1] compare 3 volte. Se V =[1, 2, 3, 4, 5, 6] il risultato sarà 0.

 public class tema17 { public static int contaReplicatiInArray (int[] V) { int j; int contatore = 0; for (int i = 0; i < V.length; i++) { for (j = 0; j < V.length; j++) // ogni volta che nell'array verrà trovato un elemento replicato il ciclo // interno sarà interrotto if (i != j && V[i] == V[j]) break; if (j == V.length) contatore++; } // questo metodo si serve della stessa struttura del metodo contaDistinti // presentato precedentemente, ma in questo caso il risultato si ottiene // sottraendo dalla dimensione totale dell’array gli elementi distinti return V.length-contatore; }  /* Applicazione di Prova */  public static void main(String args[]) { int[] A ={1, 2, 3, 2, 4, 5, 2}; // in questo caso otterremo 3 perchè il 2 si ripete tre volte System.out.println(contaReplicatiInArray (A)); System.out.println(); int[] Z ={1, 2, 3, 4, 5, 6}; // in questo caso otterremo 0 perchè nessun elemento si ripete System.out.println(contaReplicatiInArray (Z)); } }     

Tema 16

Scrivere un metodo contaDistintiInArray che riceve in ingresso un array di interi V e restituisce il numero di elementi distinti di V, cioè quelli che compaiono una sola volta. Ad esempio, se V =[15, 12, 3, 15, 7, 12] il risultato sarà 2, infatti solo V[2] e V[4] compaiono una sola volta ciascuno; se V =[15, 12, 15, 12] il risultato sarà 0, infatti non ci sono elementi distinti.

 public class tema16{ public static int contaDistintiInArray (int[] V){ int j; // creiamo una variabile contatore che sarà aggiornata ogni volta che verrà // individuato un elemento senza // duplicati nell'array int contatore = 0; for (int i = 0; i < V.length; i++){ for (j = 0; j < V.length; j++) // effettuiamo i controlli, tenendo in considerazione il fatto che l’indice i // deve essere diverso dall’indice j // per evitare di considerare un elemento come se fosse il duplicato di se’ // stesso if (i != j && V[i] == V[j]) break; if (j == V.length) contatore ++; } return contatore; }  /* Applicazione di Prova */  public static void main(String args[]) { int[] V ={1,2,3,4,5,6,7,8,9}; System.out.println(contaDistintiInArray (V)); // in questo caso otterremo 9 System.out.println(); nt[] W ={1, 7, 1, 3, 4, 7}; // in questo caso otterremo 2 System.out.println(contaDistintiInArray (W)); System.out.println(); int[] Z ={3, 6, 3, 6, 8, 8}; // in questo caso otterremo 0 System.out.println(contaDistintiInArray (Z)); } }     

Tema 15

Scrivere un metodo esisteCorispondenteInModulo che riceve in ingresso due vettori di interi A e B, e restituisce TRUE se per ogni elemento di A esiste in B un elemento con lo stesso valore assoluto ma di segno opposto, FALSE altrimenti. Ad esempio, siano A e B due array così costituiti

A
A =	-8	5	9	-7

B
7	2	8	-5	-9	4

allora esisteCorrispondenteInModulo (A, B) = TRUE

 public class tema15{ public static boolean esisteCorrispondenteInModulo (int[] A, int[] B){ // scorriamo gli elementi dell’array A for (int i = 0; i < A.length; i++) { boolean esiste = false; // scorriamo l’array B cercando un elemento uguale all’i-esimo elemento di A ma // di segno opposto for (int j = 0; j < B.length && !esiste; j++) if (A[i] == -B[j]) esiste = true; if (!esiste) return false;} return true; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] A ={-8, 5, 9, -7}; int[] B ={7, 2, 8, -5, -9, 4 }; System.out.println(esisteCorrispondenteInModulo (A, B)); // otterremo TRUE System.out.println(); int[] Z ={7, 2, 8, -5, 9, 4}; System.out.println(esisteCorrispondenteInModulo (A, Z)); // otterremo FALSE } }     

Tema 14

Scrivere un metodo creaVettoreConSommeDegliElementiPositivi che riceve in ingresso un array di interi V e restituisce un vettore di interi Z di dimensione pari alla dimensione di V, in cui l’i-esimo elemento è dato dalla somma degli elementi positivi a partire da V[i]. Ad esempio, sia V un array così costituito

8

-3

4

-7

9

1

2

allora creaVettoreConSommeDegliElementiPositivi (V) darà

24

16

16

12

12

3

2

 public class tema14{ public static int[] creaVettoreConSommeDegliElementiPositivi (int[] V){ // dichiariamo un array Z con la stessa dimensione di V int[] Z = new int[V.length]; for (int i = 0; i < V.length; i++){ // creiamo il contenitore in cui effettuare e conservare la somma // è importante collocare il contenitore somma in questa posizione in modo che // per ogni elemento // venga cancellato il risultato delle somme precedenti int somma = 0; // per sommare gli elementi creiamo un ciclo che parta esattamente dallo stesso // valore sul quale si trova il // ciclo precedente for (int j = i; j < V.length; j++){ if (V[j] > 0) somma += V[j]; } // collochiamo la somma degli elementi positivi, a partire dall’i-esimo // elemento, nell’array Z Z[i] = somma; } return Z; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] V = {8, -3, 4, -7, 9, 1, 2}; int[] Z = creaVettoreConSommeDegliElementiPositivi (V); for (int i = 0; i < Z.length; i++){ System.out.println(Z[i]);} } }     

Tema 13

Scrivere un metodo estraiPositiviPosizioniDispariMaggioriDelParametroFornito che riceve in ingresso un vettore di interi V e un intero k, e restituisce un sottovettore di interi A contenente tutti gli elementi di V di valore positivo e strettamente maggiore di k che si trovano in posizione dispari. Ad esempio, sia V l’array così costituito

18

-4

7

-1

12

21

allora estraiPositiviPosizioniDispariMaggioriDiK (V,5) darà

21

 public class tema13 { public static int[] estraiPositiviPosizioniDispariMaggioriDiK (int[] V, int k){ // creiamo inizialmente un array temporaneo in cui posizionare gli elementi che // soddisfano il criterio int[] arrayTemporaneo = new int[V.length]; // indice per scorrere l’array temporaneo int indiceArray = 0; for (int i = 1; i < V.length; i += 2){ // effettuiamo il doppio controllo if (V[i] > 0 && V[i] > k) { // trasferiamo nell’array temporaneo gli elementi che soddisfano il requisito arrayTemporaneo[indiceArray] = V[i]; indiceArray++; } } // adesso creiamo un array W con la giusta dimensione int[] arrayFinale = new int[indiceArray]; for (int i = 0; i < W.length; i++){ // trasferiamo gli elementi che erano stati memorizzati nell’array temporaneo arrayFinale[i] = arrayTemporaneo[i]; } return arrayFinale; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] V ={18, -4, 7, -1, 12, 21}; // creiamo un array in cui conservare il risultato del metodo applicato // all’array V int[] A = estraiPositiviPosizioniDispariMaggioriDiK (V, 5); // creiamo un ciclo per stampare gli elementi dell’array contenente i risultati for (int i = 0; i < A.length; i++) System.out.println(A[i]); } }     

Tema 12

Scrivere un metodo creaArrayConElementiDiAcorrispondentiAgliElementiMinoriDiB che riceve in ingresso due array di double A e B e restituisce un array contenente gli elementi di A che si trovano nelle stesse posizioni in cui, nell’array B, si trovano i valori minori. Ad esempio, siano A e B gli array così costituiti

A
6.0	7.1	0.4	10.3	4.1	9.1	8.3

B
1.0	3.9	4.4	3.9	1.0	2.2	1.0

allora creaArrayConElementiDiAcorrispondentiAgliElementiMinoriDiB (A, B9 darà

6.0

4.1

8.3

 public class tema12 { public static double[]creaArrayConElementiDiAcorrispondentiAgliElementiMinoriDiB (double[] A, double[] B) { //il primo elemento di V viene scelto arbitrariamente come minimo provvisorio double min = B[0]; // prepariamo un array temporaneo in cui inserire gli elementi del primo array // che corrispondono // alle posizioni degli elementi minori del secondo array double[] arrayTemporaneo = new double[A.length]; // creiamo un indice per scorrere l’array temporaneo int indice = 0; //effettuiamo una scansione degli array for (int i = 0; i < B.length; i++) //se durante la scansione incontriamo un elemento più piccolo di min, //aggiorniamo il valore di min if (B[i] < min) { min = B[i]; } // una volta trovato il valore più basso di B, scorriamo nuovamente l’array per // verificare se ci sono // altri valori uguali al min for (int i = 0; i < B.length; i++) if (B[i] == min) { // ogni volta che in B troviamo un valore uguale al min, inseriamo nell’array // temporaneo il corrispondente // valore dell’array A arrayTemporaneo[indice]  = A[i]; indice++; } // prepariamo un array con la giusta dimensione double [] arrayFinale = new double[indice]; for (int i = 0; i < arrayFinale.length; i++) { // trasferiamo gli elementi che erano stati memorizzati nell’array temporaneo arrayFinale[i] = arrayTemporaneo[i]; } return arrayFinale; }  /* Applicazione di Prova */  public static void main(String[] args) { double[] A={6.0, 7.1, 0.4, 10.3, 4.1, 9.1, 8.3}; double[] B={1.0, 3.9, 4.4, 3.9, 1.0, 2.2, 1.0}; double[] V = creaArrayConElementiDiAcorrispondentiAgliElementiMinoriDiB ( A, B); for (int i = 0; i < V.length; i++) System.out.println(V[i]); } }     

Tema 11

Scrivere un metodo verificaSommaEprododttoDiOgniElementoConSuccessivo che riceve in ingresso un vettore di interi V (di dimensione pari) e un intero k e restituisce TRUE se per ogni elemento di V in posizione pari la sua somma con l’elemento successivo è minore o uguale a k e il suo prodotto con l’elemento successivo è maggiore o uguale a k. Ad esempio, se V =[14, 6, 6, 10, 16, 6, 18, 4] e k = 30 il metodo restituirà TRUE.

 public class tema11{ public static boolean verificaSommaProdottoDiOgniElementoConSuccessivo (int[] V, int k){ for (int i = 0; i < V.length; i += 2) if (V[i] + V[i+1] >= k && V[i] * V[i+1] < = k) return false; return true; }  /* Applicazione di Prova */  public static void main(String[] args) { int[] V = {14, 6, 6, 10, 16, 6, 18, 4}; System.out.println(verificaSommaProdottoDiOgniElementoConSuccessivo (V, 30)); } }     

Tema 10

Scrivere un metodo verificaSommaTraIndiceEdElemento che riceve in ingresso un array di interi V e restituisce TRUE se ogni elemento di V, a partire dal secondo, è pari alla somma i + V[i-1], cioè pari alla somma dell’indice della posizione che esso occupa e del valore dell’elemento che lo precede. Ad esempio, se V =[5, 6, 8, 11, 15, 20, 26], il metodo restituirà TRUE, in quanto: V[1] = 1 + V[0], V[2] = 2 + V[1] e così via.

 public class tema10{ public static boolean verificaSommaTraIndiceEdElemento (int[] V){ boolean esito = true; for (int i = 1; i < V.length && esito; i++){ if (V[i] != i + V[i-1]) esito = false; i++; } return esito; }  /* Applicazione di Prova */  public static void main(String[] args){ int[] V= {5,6,8,11,15,20,26}; System.out.println(verificaSommaTraIndiceEdElemento (V)); } }