1 Corso di Informatica (Programmazione) Esercitazione 1 (26 novembre 2008)

1

Corso di Informatica

(Programmazione)Esercitazione 1 (26 novembre 2008)

2

Esercizi sugli arrayEsercizio 1

dato un array A di N interi calcolare la

somma degli elementi che sono multipli di 3

Esempio (N=10)

4 15 20 21 40 6 7 9 10 1

Risultato 15 + 21 + 6 + 9 = 51

A

3

Esercizi sugli arrayAlgoritmo: dichiaro una variabile s che dovrà

contenere il risultato finale e che inizialmente ha

valore 0. Scorro gli elementi di A dal

primo in posizione 0 (cioè A[0]) all’ultimo in

posizione (N-1) (cioè A[N-1]). Aggiungo a s

l’elemento che sto considerando nella generica

posizione i (cioè A[i]) ogni volta che questo

è multiplo di 3.

4

Esercizi sugli array

4 15 20 21 40 6 7 9 10 1A

Esecuzione dell’algoritmo per l’array A di 10interi dell’esempio precedente:

- all’inizio ho s=0- step 1 i=0 (i è l’indice che scandisce gli elementi di A)

A[0] è multiplo di 3? NO! Quindi s rimane a 0

5


4 15 20 21 40 6 7 9 10 1A

- step 2 i=1

A[1] è multiplo di 3? SI’! Quindi sommo a s il valoredi A[1] che è 15 s=s+15=0+15=15

4 15 20 21 40 6 7 9 10 1A

- step 3 i=2


6


4 15 20 21 40 6 7 9 10 1A

- step 4 i=3


4 15 20 21 40 6 7 9 10 1A

- step 5 i=4


7


4 15 20 21 40 6 7 9 10 1A

- step 6 i=5


4 15 20 21 40 6 7 9 10 1A

- step 7 i=6


8


4 15 20 21 40 6 7 9 10 1A

- step 8 i=7


4 15 20 21 40 6 7 9 10 1A

- step 9 i=8


9


4 15 20 21 40 6 7 9 10 1A

- step 10 i=9


Risultato 51

10

Esercizi sugli arraypublic class SommaMultipliTre {

public static void main(String arg[]) {int[] A={4,15,20,21,40,6,7,9,10,1};int i;int s, length;

length=10;i=0;s=0;while(i <= lentgth-1){

//Verifico se l’elemento i-esimo//è multiplo di 3if(A[i] % 3 == 0){

s=s+A[i];}i=i+1;

}

System.out.println(“Somma=“+s);}

}

11


dato un array A di N interi calcolare

contare il numero degli elementi pari

Esempio (N=10)

4 15 20 21 40 6 7 9 10 1

Risultato 5

A

12

Esercizi sugli arrayAlgoritmo: dichiaro una variabile c che dovrà

contenere il risultato finale e che inizialmente ha

valore 0. Scorro gli elementi di A dal

primo in posizione 0 (cioè A[0]) all’ultimo in

Posizione (N-1) (cioè A[N-1]). Incremento c di 1

ogni volta che l’elemento, che sto considerando

nella generica posizione i (cioè A[i]), è pari.

13


4 15 20 21 40 6 7 9 10 1A


- all’inizio ho c=0- step 1 i=0 (i è l’indice che scandisce gli elementi di A)

A[0] è pari? SI’! Quindi incremento c di 1, e c va a 1

14


15 21 7 94 20 40 6 10 1A

- step 2 i=1

A[1] è pari? NO! Quindi c rimane a 1

15 21 7 94 20 40 6 10 1A

- step 3 i=2


15


4 15 20 21 40 6 7 9 10 1A

- step 4 i=3


15 21 7 94 20 40 6 10 1A

- step 5 i=4


16


15 21 7 94 20 40 6 10 1A

- step 6 i=5


15 21 7 94 20 40 6 10 1A

- step 7 i=6


17


15 21 7 94 20 40 6 10 1A

- step 8 i=7


15 21 7 94 20 40 6 10 1A

- step 9 i=8


18


4 15 20 21 40 6 7 9 10 1A

- step 10 i=9


Risultato 5

Il programma per contare i dispari è analogo!

19

Esercizi sugli arraypublic class ContaPari {

public static void main(String arg[]) {int[] A={4,15,20,21,40,6,7,9,10,1};int i;int c, length;

length=10;i=0;c=0;while(i <= lentgth-1){

//Verifico se l’elemento i-esimo//è pari (multiplo di 2)if(A[i] % 2 == 0){

c=c+1;}i=i+1;

}

System.out.println(“Numero pari=“+c);}

}

20

Esercizi sugli arraypublic class ContaDispari {

public static void main(String arg[]) {int[] A={4,15,20,21,40,6,7,9,10,1};int i;int c, length;

length=10;i=0;c=0;while(i <= lentgth-1){

//Verifico se l’elemento i-esimo//è dispari (non è multiplo di 2)if(A[i] % 2 != 0){

c=c+1;}i=i+1;

}

System.out.println(“Numero dispari=“+c);}

}

21


dato un array A di N interi cercare

l’elemento minimo e la sua posizione in A

Esempio (N=10)

4 15 20 21 3 6 7 9 10 40

Risultato 3

A

22

Esercizi sugli arrayAlgoritmo: dichiaro due variabili, min e posMin, che

dovranno contenere i risultati finali (rispettivamente

il valore minimo e la sua posizione) e che inizialmente

sono uguali rispettivamente al valore del primo elemento

di A (cioè A[0]) e al valore della sua posizione in A (cioè 0).

Scorro gli elementi di A dal secondo in posizione 1 (cioè A[1])

all’ultimo in posizione (N-1) (cioè A[N-1]). Ogni volta che

l’elemento che sto considerando nella generica posizione i

(cioè A[i]) è minore del valore di min, allora aggiorno min con

il valore di A[i] e posMin con il valore i.

23


4 15 20 21 3 6 7 9 10 40A


- all’inizio ho min=A[0]=4 e posMin=0- step 1 i=1 (i è l’indice che scandisce gli elementi di A)

A[1] è minore di min? NO! Quindi min rimane a 4e posMin a 0

24


15 21 7 94 20 3 6 10 40A

- step 2 i=2


15 21 7 94 20 3 6 10 40A

- step 3 i=3


25


15 21 7 94 20 3 6 10 40A

- step 4 i=4

A[4] è minore di min? SI’! Quindi min assume il valore 3e posMin il valore 4

15 21 7 94 20 3 6 10 40A

- step 5 i=5


26


15 21 7 94 20 3 6 10 40A

- step 6 i=6


15 21 7 94 20 3 6 10 40A

- step 7 i=7


27


15 21 7 94 20 3 6 10 40A

- step 8 i=8


15 21 7 94 20 3 6 10 40A

- step 9 i=9


28


Risultato min è 3 e posMin è 4

Il programma per trovare il massimo è analogo!

29

Esercizi sugli arraypublic class TrovaMinimo {

public static void main(String arg[]) {int[] A={4,15,20,21,3,6,7,9,10,4};int i;int min, posMin, length;

length=10;i=1;posMin=0;min=A[posMin];while(i <= lentgth-1){

//Verifico se l’elemento i-esimo//è minore del minimo correnteif(A[i] < min){

min=A[i];posMin=i;

}i=i+1;

}

System.out.println(“Minimo=“+min+” in posizione “+posMin);}

}

30

Esercizi sugli arraypublic class TrovaMassimo {

public static void main(String arg[]) {int[] A={4,15,20,21,3,6,7,9,10,4};int i;int max, posMax, length;

length=10;i=1;posMax=0;max=A[posMax];while(i <= lentgth-1){

//Verifico se l’elemento i-esimo//è maggiore del massimo correnteif(A[i] > max){

max=A[i];posMax=i;

}i=i+1;

}

System.out.println(“Massimo=“+max+” in posizione “+posMax);}

}

1 Corso di Informatica (Programmazione) Esercitazione 1 (26 novembre 2008)

Documents

Transcript of 1 Corso di Informatica (Programmazione) Esercitazione 1 (26 novembre 2008)