In questa lezione risolveremo un semplice esercizio sui vettori in C++, al fine di capire meglio gli argomenti trattati finora.
Dati due vettori A e B di dimensione 10:
a) Inserire gli elementi da tastiera nei due vettori.
b) Moltiplicare gli elementi di indice pari del primo vettore per gli elementi di indice pari del secondo vettore e memorizzarli in un altro vettore C di 5 elementi. Visualizzare il vettore C in ordine decrescente.
c) Sommare gli elementi a due a due del vettore A e memorizzarli in un altro vettore D di 5 elementi. In questo modo: D[0] = A[0] + A[1] poi D[1] = A[2] + A[3]
d) Visualizzare il vettore D in ordine crescente.
e) Fare lo stesso per il vettore B e memorizzare le somme in un altro vettore E.
f) Visualizzare il vettore E ottenuto.
g) Unire i due vettori in un unico vettore F e visualizzarlo.
Innanzitutto dichiariamo i vettori necessari per il nostro algoritmo.
Quindi chiediamo all’utente di inserire gli elementi del primo vettore e poi quelli del secondo.
Dopo utilizziamo un ciclo for che scorre i vettori A e B e se l’indice è pari sommiamo i valori in un vettore C.
Utilizziamo un indice j che parte da 0 e arriva a 4, infatti lo incrementeremo di volta in volta solo se i è pari.
Dunque, considerando che gli elementi di indice pari sono: 0, 2, 4, 6, 8.
In tutto il vettore C avrà 5 elementi.
j = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0){
C[j] = A[i] * B[i];
j++;
}
}
Attenzione, quanto sopra descritto si può scrivere anche in maniera più elegante ed efficiente, evitando di utilizzare un if, incrementando la i ogni volta di 2. In questo modo:
j = 0;
for (int i = 0; i < N; i += 2) {
C[j] = A[i] * B[i];
j++;
}
Dopo visualizziamo gli elementi del vettore C in ordine decrescente, partendo dall’indice 4 e dunque da N/2-1 fino ad arrivare a 0 compreso.
cout << "Visualizzo gli elementi di c!\n";
for (int i = (N/2 - 1); i >= 0; i--) {
cout << "indice: " << i << " elemento " << c[i] << endl;
}
Poi analizziamo gli elementi di indice pari del vettore A e sommiamo gli elementi memorizzandoli in un altro vettore D.
Utilizziamo un indice j che va da 0 a 4, pertanto dobbiamo inizializzare nuovamente a 0 l’indice j.
Quindi possiamo scrivere:
j = 0
for (int i = 0; i < N; i += 2) {
D[j] = A[i] + A[i+1];
j++;
}
Ripetiamo poi lo stesso procedimento sommando gli elementi del vettore B e memorizzandoli in un vettore E.
Infine dobbiamo unire i due vettori.
Per farlo utilizziamo un ciclo for e se l’indice i è minore di N/2, cioè esattamente la metà, inseriremo nel vettore F gli elementi di D, altrimenti gli elementi di E. Notate che ho inserito l’istruzione:
F[j] = E[i - N/2];
Perché in questo modo riporto l’indice a 0, difatti deve aggiungere gli elementi del vettore E partendo dall’indice 0, invece nel punto in cui siamo la i vale 5.
j = 0;
for (int i = 0; i < N; i++) {
if(i < N / 2){
F[j] = D[i];
}
else {
F[j] = E[i - N / 2];
}
j++;
}
Ecco dunque il codice completo:
#include <iostream>
using namespace std;
#define N 10
int main() {
int j;
int A[N], B[N], C[N/2], D[N/2], E[N/2], F[N];
// Inserimento degli elementi nei vettori A e B
for (int i = 0; i < N; i++) {
cout << "Vettore a: ";
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cout << "Vettore b: ";
cin >> B[i];
}
// Calcolo degli elementi del vettore C
j = 0;
for (int i = 0; i < N; i += 2) {
C[j] = A[i] * B[i];
j++;
}
// Visualizzazione del vettore C in ordine decrescente
cout << "Visualizzo gli elementi di c!\n";
for (int i = N/2 - 1; i >= 0; i--) {
cout << "indice: " << i << " elemento " << C[i] << endl;
}
// Calcolo degli elementi del vettore D
j = 0;
for (int i = 0; i < N; i += 2) {
D[j] = A[i] + A[i + 1];
j++;
}
// Visualizzazione del vettore D in ordine crescente
cout << "Visualizzo gli elementi di d!\n";
for (int i = 0; i < N/2; i++) {
cout << "Elemento in posizione: " << i << " valore: " << D[i] << endl;
}
// Calcolo degli elementi del vettore E
j = 0;
for (int i = 0; i < N; i += 2) {
E[j] = B[i] + B[i + 1];
j++;
}
// Visualizzazione del vettore E
cout << "Visualizzo gli elementi di e!\n";
for (int i = 0; i < N/2; i++) {
cout << "Elemento in posizione: " << i << " valore: " << E[i] << endl;
}
// Unione dei vettori D ed E in un unico vettore F
for (int i = 0; i < N/2; i++) {
F[i] = D[i];
F[N/2 + i] = E[i];
}
cout << "Visualizzo gli elementi di f!\n";
for (int i = 0; i < N; i++) {
cout << "Elemento in posizione: " << i << " valore: " << F[i] << endl;
}
return 0;
}
Dato un vettore numerico di N posizioni caricato in memoria trovare il maggiore e il secondo maggiore, cioè determinare il valore più grande e quello immediatamente inferiore (il secondo), indicandone l’indice.
Per realizzare questo algoritmo occorre come al solito chiedere N e fare un controllo dell’input in modo da accettare solo valori maggiori o uguali a zero.
Dopo dichiariamo il vettore e con un ciclo for inseriamo tutti gli elementi.
Creiamo una variabile max per contenere il valore massimo dell’array e una variabile max2 per l’elemento immediatamente inferiore.
Dopo creiamo anche le variabili p e p2 che tengono traccia delle posizioni dei due valori che vogliamo trovare.
Inizializziamo poi che sia max che max2 al primo elemento dell’array e le due variabili p e p2 a 0, cioè all’indice del primo elemento dell’array.
Poi con un ciclo for scorriamo l’array e controlliamo se il valore contenuto nell’elemento a[i] è maggiore del massimo. Se è vero prima di scambiare il valore massimo assegniamo a max2 il valore di max e all’indice p2 il valore di p.
Questo perché qualunque valore contenesse max2 era comunque inferiore al max. Infatti se si trova un nuovo massimo comunque il vecchio massimo sarà maggiore del valore contenuto in max2.
Se invece a[i] non è maggiore del massimo, occorre con un altro if controllare se questo valore è maggiore di max2.
Innanzitutto scegliamo uno sfondo ed uno sprite a piacere.
Dopo creiamo le variabili necessarie, in questo caso i due giocatori: computere utente.
Quindi generiamo un numero a caso e lo memorizziamo nella variabile computer.
Dopo chiediamo all’utente per semplicità di inserire una lettera: s per sasso, f per forbice e c per carta. Quindi salviamo il carattere immesso da tastiera nella variabile utente.
Dopo con l’istruzione se allora altrimenti verifichiamo queste condizioni:
Se il computer ha generato 1 allora alla variabile computer assegniamo la lettera s.
Altrimenti se il computer ha generato 2 allora alla variabile computer assegniamo la lettera c.
Altrimenti alla variabile computerassegniamo la lettera f.
Questo passaggio è fondamentale per semplificare poi i confronti che faremo più avanti.
Adesso non ci resta che impostare le regole del gioco.
Quindi se computer = utente allora si ha la parità in quanto entrambi hanno giocato la stessa cosa.
L’utentevince in questi casi:
se utente= s e computer= f oppure
invece se utente= f e computer= c oppure
infine se utente= c e computer= s
Altrimenti vince il computer.
Ecco dunque il codice completo:
Provate a giocare più partite creando un ciclo che si ripete tante volte quante le partite desiderate. Per chi non sa usare anche i cicli si rimanda alla lezione successiva sui cicli.
Esercizi vettori C++. In questa lezione lezione affronteremo alcuni esercizi sui vettori al fine di consolidare l’argomento.
Esercizi vettori C++ – Primo esercizio
Inseriamo in un vettore di N elementi il valore del suo indice. Stampiamo poi il vettore e le sue posizioni.
Innanzitutto chiediamo all’utente di inserire N e facciamo un controllo dell’input per accettare solo valori maggiori o uguali a 0. Utilizziamo quindi per questo scopo un ciclo do-while.
Dopo con un indice i scorriamo il vettore e inseriamo il valore del suo indice. Per realizzare ciò basterà inserire all’interno del ciclo:
v[i] = i;
Quindi si avrà che v[0]=0, v[1]=1 e così via.
Dopo visualizziamo il vettore in ordine crescente e decrescente, stampando anche il valore dell’indice.
Ecco dunque il codice completo:
#include <iostream>
using namespace std;
const int N = 5; // Dimensione costante dell'array
int main() {
// Dichiarazione e inizializzazione dell'array
int v[N];
for (int i = 0; i < N; i++) {
v[i] = i;
}
// Visualizzazione degli elementi in ordine crescente
cout << "\nOrdine crescente:\n";
for (int i = 0; i < N; i++) {
cout << "Elemento in posizione " << i << ": " << v[i] << endl;
}
// Visualizzazione degli elementi in ordine decrescente
cout << "\nOrdine decrescente:\n";
for (int i = N - 1; i >= 0; i--) {
cout << "Elemento in posizione " << i << ": " << v[i] << endl;
}
return 0;
}
Secondo esercizio
Inseriamo in un vettore di N elementi il valore da 0 ad N, ma partendo da destra. Stampiamo poi il vettore e le sue posizioni.
Quindi se N è uguale a 5 allora si avrà:
L’esercizio è una variazione di quello precedente, basta infatti sostituire il ciclo for:
for (int i = 0; i < N; i++) {
v[i] = i;
}
Con questo:
for (int i = 0; i < N; i++) {
v[i] = N - 1 - i;
}
Cioè basta assegnare all’elemento v[i] il valore di N-1 meno l’indice i.
Inseriamo da tastiera in un vettore di N elementi i multipli di 3. Stampiamo poi il vettore in ordine crescente e decrescente.
Considerando che l’indice i si incrementa di volta in volta, basta inserire nell’elemento v[i] il valore dell’indice i più 1 e poi moltiplicarlo per 3.
L’unica cosa che cambia sarà dunque questo ciclo:
for (int i = 0; i < N; i++) {
v[i] = (i + 1) * 3;
}
Ecco dunque il codice completo:
#include <iostream>
using namespace std;
const int N = 5; // Dimensione costante dell'array
int main() {
int v[N];
// Popolamento dell'array con valori crescenti
for (int i = 0; i < N; i++) {
v[i] = (i + 1) * 3;
}
// Visualizzazione degli elementi in ordine crescente
cout << "Ordine crescente:" << endl;
for (int i = 0; i < N; i++) {
cout << "Elemento in posizione " << i << ": " << v[i] << endl;
}
// Visualizzazione degli elementi in ordine decrescente
cout << "\nOrdine decrescente:" << endl;
for (int i = N - 1; i >= 0; i--) {
cout << "Elemento in posizione " << i << ": " << v[i] << endl;
}
return 0;
}
Questi sono solo alcuni esercizi sui vettori in C++, nelle prossime lezioni ne proporrò degli altri.
Abbiamo già visto come utilizzare ivettori in C++, in questa lezione faremo un riepilogo di quanto appreso.
I Vettori in C++ – Primo esercizio
Caricare un vettore di N elementi con numeri interi inseriti da tastiera.
Si dichiara un intero N e si chiede all’utente di inserire il valore da tastiera. Con un ciclo do-while controlliamo questo valore e se è minore o uguale a 0, richiediamo l’inserimento.
Dopo dichiariamo un vettore di N elementi int v[N].
Poi con un ciclo for, con un indice i che scorre il vettore dalla prima posizione, inseriamo gli elementi.
Supponendo che N è 5, inseriamo i seguenti valori da tastiera: 3, 5, 12, -2, 9.
Partendo da sinistra si avrà dunque:
v[0]=3, v[1]=5, v[2]=12, v[3]=-2, v[4]=9.
L’indice varia da 0 a 4 (cioè N-1).
Ecco dunque cosa otterremo:
Scriviamo quindi l’algoritmo in C++:
#include <iostream>
using namespace std;
int main() {
// Dichiarazione delle variabili
int N;
// Input della dimensione dell'array
do {
cout << "Inserisci N: ";
cin >> N;
} while (N <= 0);
// Dichiarazione dell'array di dimensione N
int v[N];
// Input dei valori nell'array
for(int i = 0; i < N; i++) {
cout << "Inserisci un numero: ";
cin >> v[i];
}
return 0;
}
N.B. In realtà non è possibile dichiarare un array di dimensione variabile in C++. L’array deve avere una dimensione costante nota a tempo di compilazione. Ma alcune implementazioni di compilatori C++ consentono l’allocazione di array di dimensione variabile in fase di esecuzione, anche se non è standard secondo lo standard del linguaggio C++. Ecco perchè nei prossimi esempi utilizzerò N costante.
Parlo di array dinamici nel libro disponibile su Amazon:
Visualizzare il vettore precedentemente caricato dalla prima all’ultima posizione.
Per visualizzare il vettore basta realizzare un ciclo for che parte dalla prima posizione fino all’ultima e per ogni iterazione si stampa l’i-esimo elemento.
Quindi aggiungete il codice che segue all’algoritmo precedente poco prima del return 0.
cout << "Visualizzo gli elementi!\n";
for(int i = 0; i < N; i++) {
cout << v[i] <<'\t';
}
N.B. Se invece volessimo visualizzare gli elementi dall’ultima posizione del vettore alla prima, potremmo far partire l’indice da N-1 e a mano a mano decrementarlo fino ad arrivare a 0.
Ecco dunque la soluzione. Inserite il codice anche sotto il precedente per vedere la differenza.
cout << "Visualizzo gli elementi a partire dall'ultimo numero'!\n";
for(int i = N - 1; i >= 0; i--) {
cout << v[i] << '\t';
}
Terzo esempio – Modificare elementi di un vettore
Utilizziamo i vettori in C++ per modificare gli elementi in esso presenti.
Inserire N elementi in un vettore, visualizzarli in ordine crescente. Dopo modificare solo gli elementi pari moltiplicandoli per 3 e visualizzare gli elementi in ordine decrescente.
Quindi ripetiamo i passaggi fatti nel primo esercizio per inserire gli elementi nel vettore.
Dopo visualizziamo il vettore così come spiegato nell’esempio 2.
Poi modifichiamo solo gli elementi pari del vettore e li moltiplichiamo per 3. Attenzione non gli elementi con indice pari!
Infine visualizziamo il vettore in ordine inverso così come spiegato nell’esempio 2.
Ecco il codice completo:
#include <iostream>
using namespace std;
const int N = 5; // Dimensione costante dell'array
int main() {
int v[N];
// Input dei valori nell'array
for (int i = 0; i < N; i++) {
cout << "Inserisci un numero: ";
cin >> v[i];
}
// Visualizzazione degli elementi originali dell'array
cout << "Visualizzo gli elementi!" << endl;
for (int i = 0; i < N; i++) {
cout << v[i] << '\t';
}
// Modifica degli elementi pari dell'array
for (int i = 0; i < N; i++) {
if (v[i] % 2 == 0)
v[i] *= 3;
}
// Visualizzazione degli elementi modificati dell'array
cout << "\nVisualizzo gli elementi modificati!" << endl;
for (int i = N - 1; i >= 0; i--) {
cout << v[i] << '\t';
}
return 0;
}
Quarto esempio
In questo esempio modifichiamo gli elementi con indice dispari aggiungendo il valore 100. Visualizzarli poi in ordine decrescente.
L’esercizio è simile al precedente, basta cambiare questo punto:
for (int i = 0; i < N; i++) {
if (v[i] % 2 == 0)
v[i] *= 3;
}
Con questo:
for (int i = 0; i < N; i++) {
if (i % 2 != 0)
v[i] += 100;
}
Cioè non devo guardare l’elemento ma l’indice dispari. Basta controllare dunque che il resto della divisione di i diviso 2 sia diverso da zero. Se tale condizione è vera aggiungiamo all’elemento il valore 100.
Ecco il codice completo:
#include <iostream>
using namespace std;
const int N = 5; // Dimensione costante dell'array
int main() {
// Dichiarazione dell'array di dimensione N
int v[N];
// Input dei valori nell'array
for (int i = 0; i < N; i++) {
cout << "Inserisci un numero: ";
cin >> v[i];
}
// Visualizzazione degli elementi originali dell'array
cout << "Visualizzo gli elementi!" << endl;
for (int i = 0; i < N; i++) {
cout << v[i] << '\t';
}
// Modifica degli elementi in posizioni dispari dell'array
for (int i = 0; i < N; i++) {
if (i % 2 != 0)
v[i] += 100;
}
// Visualizzazione degli elementi modificati dell'array
cout << "\nVisualizzo gli elementi modificati!" << endl;
for (int i = N - 1; i >= 0; i--) {
cout << v[i] << '\t';
}
return 0;
}
Sommare gli elementi di un vettore
Utilizziamo i vettori in C++ per effettuare la somma degli elementi.
Inseriamo N elementi in un vettore. Li sommiamo e visualizziamo poi il vettore in ordine crescente e la somma.
Quindi in definitiva ripetiamo alcuni passaggi già visti per l’inserimento degli elementi nel vettore.
Poi con un ciclo for sommiamo gli elementi in una variabile s, precedentemente inizializzata a 0, e li visualizziamo.
#include <iostream>
using namespace std;
const int N = 5; // Dimensione costante dell'array
int main() {
int s = 0;
// Dichiarazione dell'array di dimensione N
int v[N];
// Input dei valori nell'array e calcolo della somma
for (int i = 0; i < N; i++) {
cout << "Inserisci un numero: ";
cin >> v[i];
s += v[i];
}
// Visualizzazione degli elementi dell'array
cout << "Visualizzo gli elementi!" << endl;
for (int i = 0; i < N; i++) {
cout << v[i] << '\t';
}
// Visualizzazione della somma degli elementi
cout << "\nLa somma e': " << s << endl;
return 0;
}
Nella prossima lezione proporrò ancora alcuni esercizi su come utilizzare i vettori in C++.
Commenti recenti