Esercizi di Fondamenti di Informatica

ESERCIZI VETTORI

Esercizio 1

Si scriva una funzione verificaMultipli che riceve in input due vettori A e B di

interi e restituisce un vettore C di booleani così formato: il valore nella i-esima

posizione di C sarà true se e solo se il valore nella i-esima posizione di A è

multiplo o sottomultiplo del valore contenuto nella i-esima posizione di B, false

altrimenti.

Esempio:

A = [3, 4, 10, 13, 5] , B = [2, 2, 5, 7, 15] allora C = [false, true, true, false, true].

public class Esercizio1 {

public static boolean[] verificaMultipli(int[] A, int[] B){

boolean[] C = new boolean[A.length];

for (int i = 0; i < C.length; i++) {

if(A[i] % B[i] == 0 || B[i] % A[i] == 0)

C[i] = true;

}

return C;

}

public static void main(String[] args) {

int[] A = {3,4,10,13,5};

int[] B = {2,2,5,7,15};

boolean[] C = verificaMultipli(A, B);

System.out.print("C = [ ");

for (int i = 0; i < C.length; i++) {

System.out.print(C[i]+ " ");

}

System.out.print("]");

}

}

Esercizio 2

Si scriva una funzione verificaConsecutivi che riceve in ingresso un vettore V di

interi e un intero k e restituisce True se e solo se V contiene almeno k elementi

consecutivi uguali.

Esempio:

Se V = [1, 8, 2, 1, 1, 1, 2, 1] e k = 3 allora il metodo restituisce True perché V

contiene 3 elementi consecutivi uguali.

public class Esercizio2 {

public static boolean verificaConsecutivi(int[] V, int k){

int precedente = V[0];

int cont = 1;

for (int i = 1; i < V.length; i++) {

if (V[i] == precedente){

cont++;

if (cont >= 3)

return true;

}else{

cont = 1;

}

precedente = V[i]; // Aggiorno il valore "precedente"

}

return false;

}

public static void main(String[] args) {

int[] V = {1,8,2,1,1,1,2,1};

boolean risultato = verificaConsecutivi(V, 1);

System.out.println("Il risultato del metodo è: "+risultato);

}

}

Esercizio 3

Si scriva una funzione listaMaggiori che riceve in ingresso un vettore V di interi e

restituisce un vettore W della stessa lunghezza di V, il cui generico elemento (W[i]) è

pari al primo elemento maggiore di V[i] presente in V. Se nessun elemento è maggiore

di V[i] allora W[i] sarà posto pari a V[i].

Esempio:

Se V = [6, 1, 7, 3, 7, 8, 9, 4], allora il metodo listaMaggiori fornisce come risultato il

vettore

W = [7, 6, 8, 6, 8, 9, 9, 6], perché il primo elemento in V maggiore di 6 è 7, il primo

elemento in V maggiore di 1 è 6, il primo elemento in V maggiore di 7 è 8 e così via.

public class Esercizio3 {

public static int[] listaMaggiori(int[] V){

int[] W = new int[V.length];

for (int i = 0; i < W.length; i++) {

W[i] = cercaMaggiore(V[i],V);

}

return W;

}

public static int cercaMaggiore(int x, int[] V){

for (int i = 0; i < V.length; i++) {

if(V[i] > x){

x = V[i];

return x;

}

}

return x;

}

public static void main(String[] args) {

int[] V = {6, 1, 7, 3, 7, 8, 9, 4};

int[] W = listaMaggiori(V);

System.out.print("W = [ ");

for (int i = 0; i < W.length; i++)

System.out.print(W[i]+ " ");

System.out.println("]");

}

}

Esercizio 5

Si scriva una funzione verificaMetaMultipli che riceve in input un vettore di interi A

e un intero k e restituisce true se ogni elemento della prima metà di A è un

sottomultiplo di almeno k elementi della seconda metà di A.

Esempio:

Per A = [2, 4, 3, 8, 24, 9], k = 2, il metodo restituisce true, poiché gli elementi 2, 3 e 4

che compaiono nella prima metà del vettore hanno almeno k = 2 multipli nella seconda

metà del vettore (8,24 per gli interi 2 e 4 e 9,24 per il 3).

public class Esercizio5 {

public static boolean verificaMetaMultipli(int[] A, int k){

boolean risultato = true;

for (int i = 0; i < A.length/2; i++) {

if (!sottomultiplo(A[i],A,k))

risultato = false;

}

return risultato;

}

public static boolean sottomultiplo(int x, int[] V, int k){

// Restituisce TRUE se x ha k sottomultipli della seconda metà di V

int cont = 0;

for (int i = V.length/2; i < V.length; i++) {

if(V[i] % x == 0)

cont++;

}

return cont >= k;

}

public static void main(String[] args) {

int[] A ={2,4,3,8,24,9};

int k = 2;

System.out.println(verificaMetaMultipli(A, k));

}

}

Esercizio 6

Si scriva una funzione estraiNumeri che riceve in input un vettore di interi V e

restituisce un vettore W che contiene ogni valore V[i] che sia un numero primo e che

sia minori di tutti gli elementi che lo precedono in V. Il primo elemento di V si

considera un numero primo e si inserisce di default in W.

Esempio:

Se V = [13, 8, 6, 5, 7, 10, 3], allora w = [13, 5 , 3].

public class Esercizio6 {

public static int[] estraiNumeri(int[] V){

int[] W = new int[V.length];

int k = 1;

W[0] = V[0];

for (int i = 1; i < V.length; i++) {

if(numeroPrimo(V[i]) && minoreElementi(V[i],V,i)){

W[k] = V[i];

k++;

}

}

// Aggiustamento dimensione W

if(k == V.length)

return W;

int[] W1 = new int[k];

for (int i = 0; i < W1.length; i++) {

W1[i] = W[i];

}

return W1;

}

/* Metodo ausiliario per il test di primalità di un numero */

public static boolean numeroPrimo(int x){

// Deve essere maggiore di 1

if(x < 2)

return false;

// Se 'x' è 2 allora è primo

if (x == 2) {

return true;

} // Se è multiplo di 2 e non è 2 non è primo

if (x % 2 == 0)

return false;

// Si verifica se è divisibile per numeri dispari

for(int i = 3; i < x; i = i + 2) {

if(x % i == 0)

return false;

}

return true;

}

/* Metodo ausiliario per verifica elemento minore */

public static boolean minoreElementi(int x, int[] V, int indice){

// Restituisce true se x è minore di tutti gli elementi di V da 0 a indice

for (int i = 0; i < indice; i++) {

if (x > V[i])

return false;

}

return true;

}

public static void main(String[] args) {

int[] V = {13,8,6,5,7,10,3};

int[] W = estraiNumeri(V);

for (int i = 0; i < W.length; i++) {

System.out.print(W[i]+" ");

}

}

}

Esercizio 7

Si scriva una funzione pariDispari che riceve in ingresso due vettori di interi, V e W, e

restituisce la differenza tra la somma dei numeri pari contenuti in V e la somma dei numeri

dispari contenuti in W.

Esempio:

SeV=[7,4,7,8,2]eW=[4,3,1,5] il metodo restituisce 5. Poiché la somma dei pari in V

è 14 e la somma dei dispari in W è 9.

public class PariDispariVettori {

public static int pariDispari(int[] V, int[] W) {

int differenza = sommaPari(V) - sommaDispari(W);

return differenza;

}

public static int sommaPari(int[] V) {

int somma = 0;

for (int i = 0; i < V.length; i++) {

if (V[i] % 2 == 0) {

somma += V[i];

}

}

return somma;

}

public static int sommaDispari(int[] W) {

int somma = 0;

for (int i = 0; i < W.length; i++) {

if (W[i] % 2 != 0) {

somma += W[i];

}

}

return somma;

}

public static void main(String[] args) {

int[] V = {7, 4, 7, 8, 2};

int[] W = {4, 3, 1, 5};

int risultato = pariDispari(V,W);

System.out.print(risultato);

}

}

Esercizio 8

Si scriva una funzione maggioreMassimo che riceve in ingresso un vettore di interi V e restituisce true se

e solo se la somma degli elementi in posizione pari (la posizione 0 si considera pari) è maggiore o uguale

al massimo del vettore V.

Esempio:

Se V = [2, 20, 8, 9, 3] il metodo restituisce false, perché gli elementi in posizioni pari sono

2, 8 e 3; la loro somma è 13 ma il massimo del vettore è 20. Dunque la somma degli elementi in posizione

pari non è maggiore del massimo.

public class MaggioreMassimoVettori {

public static boolean maggioreMassimo(int[] V) {

for (int i = 0; i < V.length; i++) {

if (sommaPari(V) >= maxVettore(V)) {

return true;

}

}

return false;

}

public static int sommaPari(int[] V) {

int somma = 0;

for (int i = 0; i < V.length; i++) {

if (V[i] % 2 == 0) {

somma += V[i];

}

}

return somma;

}

public static int maxVettore(int[] V) {

int max = 0;

int precedente = V[0];

for (int i = 0; i < V.length; i++) {

if (V[i] > precedente) {

precedente = V[i];

}

max = precedente;

}

return max;

}

public static void main(String[] args) {

int[] V = {2, 20, 8, 9, 3};

boolean risultato = maggioreMassimo(V);

System.out.print(risultato);

}

}

Esercizio 9

Si scriva una funzione indiciPositivi che riceve in ingresso un vettore di interi V e restituisce un

vettore W contenente gli indici di V in corrispondenza dei quali si trovano elementi positivi.

Esempio:

Se V = [2, -20, -8, -9, 3, 10, -5, 4] il metodo restituisce il vettore W = [0, 4, 5, 7], poiché 2 è

positivo e si trova nella posizione cui è associato indice 0; 3 è positivo e si trova nella posizione cui

è associato l’indice 4 e cosi via.

public class Esercizio9 {

public static int[] indiciPositivi(int[] V){

int[] W = new int[V.length];

int k = 0;

int numeroPositivi = 0;

// Ricerca indici positivi

for (int i = 0; i < V.length; i++) {

if (V[i] > 0){

numeroPositivi++;

W[k] = i;

k++;

}

}

// Aggiustamento dimensione W

int[] W1 = new int[numeroPositivi];

for (int i = 0; i < numeroPositivi; i++) {

W1[i] = W[i];

}

// Risultato

return W1;

}

public static void main(String[] args) {

int[] V = {2, -20, -8, -9, 3, 10, -5, 4};

int[] W = indiciPositivi(V);

System.out.println("Il vettore risultato del metodo è:");

for (int i = 0; i < W.length; i++) {

System.out.print(W[i]+" ");

}

}

}

Esercizio 10

Si scriva una funzione azzeraNegativi che riceve un vettore di interi V e

restituisce un vettore W della stessa lunghezza di V tale che, per ogni

elemento V[i]: se V[i] positivo allora W[i] deve essere uguale a V[i]; se V[i]

è negativo o pari a zero allora W[i] viene posto uguale a zero.

Esempio:

Se V = [2, -4, 0, -3, 1, -1, -2, 7] allora il risultato è il vettore W = [2, 0, 0, 0,

1, 0, 0, 7].

public class AzzeraNegativiVettori {

public static int[] azzeraNegativi(int[] V) {

int[] W = new int[V.length];

for (int i = 0; i < V.length; i++) {

if (V[i] > 0) {

W[i] = V[i];

} else if (V[i] <= 0) {

W[i] = 0;

}

}

return W;

}

public static void main(String[] args)