Quindi analizzeremo innanzitutto la funzione rand() in C++ che serve a generare dei numeri casuali.
Prima di procedere con la spiegazione volevo evidenziare che la funzione rand() in C++ ha alcune limitazioni. In particolare
Non è considerata una buona pratica per generare numeri casuali di alta qualità: Anche se rand() può essere utilizzata per scopi semplici o casuali, non è considerata efficiente per generare numeri casuali di alta qualità a causa della sua distribuzione non uniforme e della mancanza di controllo sull’algoritmo di generazione.
Non è thread-safe: La funzione rand() non è thread-safe, il che significa che non può essere utilizzata in modo sicuro in contesti multithreading senza precauzioni aggiuntive per evitare interferenze tra thread.
Esistono alternative migliori: Con l’avvento di C++11 e versioni successive, è consigliabile utilizzare la libreria <random> per generare numeri casuali di alta qualità. Questa libreria offre una maggiore flessibilità e controllo sulla generazione di numeri casuali e fornisce algoritmi più sofisticati per ottenere risultati migliori rispetto a rand().
In sintesi, sebbene rand() sia ancora disponibile e funzionante in C++, è preferibile utilizzare <random> per generare numeri casuali di alta qualità e thread-safe. È importante considerare le esigenze specifiche del tuo programma e scegliere l’approccio migliore in base a esse.
La funzione rand() genera un numero che è compreso nell’intervallo tra 0 e RAND_MAX, dove RAND_MAX è un valore che cambia a seconda del compilatore usato, ad esempio nel caso di Dev C++ è 32767.
Per provarlo basta semplicemente scrivere questo piccolo programma in cui oltre all’header iostream includeremo anche l’header cstdlib.
#include <iostream>
#include <cstdlib>
using namespace std;
#define N 10
int main(){
cout<<"RAND_MAX:"<<RAND_MAX;
}
Ma la funzione rand() dà l’impressione che il numero sia casuale.
Infatti aggiungete questa linea di codice al programma precedente:
cout<<rand()<<endl;
Noterete che il numero generato, se mandate più volte in esecuzione il programma, è sempre lo stesso.
Questo succede perché il nostro numero casuale è prodotto a partire dallo stesso seme. Allora occorre intervenire proprio su questo per generare numeri casuali diversi.
Esempi c++ random
Per generare numeri casuali in C++ potremmo inizializzare i semi utilizzando la funzione srand(). Questa funzione inizializza il generatore di numeri con un valore passato come argomento.
Ad esempio srand(112233);
Facciamo dunque un esempio inserendo in un array dei numeri pseudo-casuali.
Creiamo due semi partendo da due valori diversi. Dopo con la funzione srand() passiamo i semi come argomento e poi con la funzione rand() generiamo dei numeri pseudo-casuali che inseriremo nei nostri array a e b.
#include <iostream>
#include <cstdlib>
using namespace std;
const int seme1 = 111222333;
const int seme2 = 112233444;
#define N 10
int main(){
int a[N],b[N];
int i;
srand(seme1);
for (i=0; i<N; i++){
a[i]=rand();
}
srand(seme2);
for (i=0; i<N; i++){
b[i]=rand();
}
cout<<"stampa primo array"<<endl;
for (i=0; i<N; i++){
cout<<a[i]<<endl;
}
cout<<"stampa secondo array"<<endl;
for (i=0; i<N; i++){
cout<<b[i]<<endl;
}
return 0;
}
Ma ogni volta che manderemo in esecuzione il programma avremo sempre gli stessi numeri.
La funzione time() restituisce il numero di secondi trascorsi dal 01 Gennaio 1970 rispetto alla data e all’ora corrispondenti all’invocazione di tale funzione.
Per utilizzare questa funzione devo includere l’header ctime.
Ecco quindi il listato completo d’esempio:
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
#define N 10
int main(){
int a[N];
int i;
srand(time(NULL));
for (i=0; i<N; i++){
a[i]=rand();
}
cout<<"stampa array"<<endl;
for (i=0; i<N; i++){
cout<<a[i]<<endl;
}
return 0;
}
In questo modo ogni volta che manderemo in esecuzione il programma, in istanti differenti, otterremo valori diversi.
Ottenere valori random in un determinato intervallo
Adesso vedremo come generare numeri in C++ random ma in un intervallo definito.
Se utilizziamo rand()%N visualizziamo i numeri compresi tra 0 ed N-1.
Quindi ad esempio rand()%10 restituisce i numeri da 0 a 9.
Se aggiungiamo un offset l’intervallo si può modificare, ad esempio rand()%10+1 restituisce tutti i numeri da 1 a 10 anziché da 0 a 9. In pratica aggiungiamo 1 ad entrambi i numeri del range.
Quindi se ad esempio volessimo generare i numeri da 10 a 20, considerando che rand()%11 genera valori da 0 a 10, allora dovremmo aggiungere l’offset 10.
Ecco il listato completo che mostra due array inizializzati uno con i numeri random da 1 a 10 e il secondo con i numeri random da 10 a 20.
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
#define N 10
int main(){
int a[N],b[N];
int i;
srand(time(NULL));
for (i=0; i<N; i++){
a[i]=rand()%10+1;
}
srand(time(NULL));
for (i=0; i<N; i++){
b[i]=rand()%11+10;
}
cout<<"stampa primo array"<<endl;
for (i=0; i<N; i++){
cout<<a[i]<<endl;
}
cout<<"stampa secondo array"<<endl;
for (i=0; i<N; i++){
cout<<b[i]<<endl;
}
return 0;
}
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.
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++.
Dichiariamo dunque un array a di N elementi e con un ciclo for inseriamo i valori nell’array.
Quindi poniamo il massimo uguale al primo elemento dell’array e l’indice uguale a 0.
Poi, controlliamo se ciascun elemento è maggiore del valore massimo. Se tale condizione è verificata allora aggiorniamo il valore del massimo e dell’indice.
N.B. Non è corretto indicare max = 0 in quanto, nell’ipotesi in cui, si inseriscano tutti i numeri negativi si avrebbe come valore massimo 0. Es: max = 0 N = 4 a[N] = {-2,-3,-4,-5} …. //calcolo il massimo Il valore massimo dovrebbe essere -2 ma l’algoritmo restituisce erroneamente zero.
Infine visualizziamo in output i valori ottenuti.
Ecco quindi l’algoritmo completo:
#include<iostream>
using namespace std;
#define N 10
int main() {
int i, max, p;
int a[N];
// Input dei numeri nell'array
for (i = 0; i < N; i++) {
cout << "Inserisci un numero: ";
cin >> a[i];
}
// Troviamo il massimo e il suo indice
max = a[0]; // Poniamo il massimo uguale al primo elemento
p = 0; // Poniamo l'indice uguale a 0
for (i = 0; i < N; i++) {
if (a[i] > max) {
max = a[i];
p = i;
}
}
// Output del massimo e del suo indice
cout << "Massimo, indice " << p << ", valore " << max << endl;
return 0;
}
Troviamo il maggiore e quante volte ricorre
Per realizzare questo algoritmo basta semplicemente aggiungere una variabile c che conta quante volte compare il valore massimo.
La faremo incrementare di 1 se trova lo stesso valore, mentre la inizializziamo a zero se trova un nuovo massimo.
#include<iostream>
using namespace std;
#define N 10
int main() {
int i, max, p, c;
int a[N];
// Input dei numeri nell'array
for (i = 0; i < N; i++) {
cout << "Inserisci un numero: ";
cin >> a[i];
}
// Troviamo il massimo, il suo indice e quante volte ricorre
max = a[0]; // Poniamo il massimo uguale al primo elemento
p = 0;
c = 1;
for (i = 0; i < N; i++) {
if (a[i] > max) {
max = a[i];
p = i;
c = 1;
} else if (a[i] == max) {
c++;
}
}
// Output del massimo, del suo indice e di quante volte ricorre
cout << "Massimo, indice " << p << ", valore " << max << ", ricorre " << c << " volte" << endl;
return 0;
}
Abbiamo realizzato alcuni semplici esempi per trovare il massimo elemento di un vettore, nelle prossime lezioni ci eserciteremo ancora sui vettori.
Commenti recenti