Programma che genera matrice quadrata casuale e array con sottoprogrammi

nabboc++

il 11 nov 2018, 22:11

25 risposte

25 Risposte - Pagina 2

O
oregon
Super Famoso
Iscritto da
nov, 2011
Messaggi:
21552
Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi
13 nov 2018, 08:28
Un chiarimento... ma tu la teoria la stai affrontando su un libro o no?
Nippolo
Molto attivo
Iscritto da
mar, 2018
Messaggi:
1241
Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi
13 nov 2018, 12:39
nabboc++ ha scritto:
Dipende dai valori di M ed N, '%' e l'operatore modulo, che restituisce 0 od 1 a seconda del resto della divisione.
Ad esempio se M=10 ed N=2, il valore restituito sarà 0, mentre se M=10 ed N=3, il valore restituito sarà 1.
Supposto che M e N siano due interi (con N>0), l'intervallo in cui può ricadere il risultato della suddetta operazione dipende solo da N, e in particolare sarà compreso tra 0 e N-1.
Perchè dici che può restituire solo 0 o 1?!
nabboc++ ha scritto:
'r' indica il numero di righe/colonne della matrice generata, sennò facciamo girare il ciclo for all'infinito?
Forse non ci siamo capiti, io mi riferivo alla funzione numero_righe_e_colonne(). Mi spiego meglio... tu hai scritto:
```
int numero_righe_e_colonne(int r)
{
    r = 5 + rand() % 6;
    return(r);
}

int main()
{  
    int r = numero_righe_e_colonne(r);
    ...
}
```
quando in realtà basta fare
```
int numero_righe_e_colonne()
{
    return 5 + rand() % 6;
}

int main()
{  
    int r = numero_righe_e_colonne();
    ...
}
```
oppure
```
void numero_righe_e_colonne(int &r)
{
    r = 5 + rand() % 6;
}

int main()
{  
    int r;
    numero_righe_e_colonne(r);
    ...
}
```
nabboc++ ha scritto:
Come ho risposto prima ad oregon, dopo aver modificato e compilato il programma, eseguiva ma mi dava sempre errori nella stampa a schermo, come se non modificasse il file .exe dopo la compilazione.
Ho usato un altro IDE che ha generato un altro .exe è tutto è filasciato liscio.
Non sono sicuro di aver compreso bene quale fosse il problema, in ogni caso nel momento in cui scrivi int v[DIM]={n} stai inizializzando il primo valore dell'array v ad n e i restanti DIM-1 elementi a 0.
nabboc++ ha scritto:
In realtà dovrebbe ritornare tutto il vettore di interi...
Un paio di domande: cosìè un array? Quando passiamo un array ad una funzione, cosa gli stiamo effettivamente passando?
nabboc++ ha scritto:
Come sopra, in realtà dovrebbe ritornare tutto il vettore di interi...
return (vettpari[lunghezzapari]) semplicemente ritorna l'elemento di vettpari di indice lunghezzapari... detto questo e ricordando che gli indici degli elementi di vettpari variano tra 0 e lunghezzapari-1, implica che con la sudetta scrittura vai a leggere un'area di memoria esterna a quella riservata per l'array.
nabboc++ ha scritto:
La variabile numeratore come mi hai fatto notare è superflua quindi l'ho rimossa, l'altra mi sembra necessaria.
Qualcosa del genere non va bene?
```
void generazione_vettorepari(int r, int matrice[R][R], int vettore_pari[R*R])
{
    unsigned int k = 0;
    for(unsigned int i = 0; i < r; ++i)
    {
        for(unsigned int j = 0; j < r; ++j)
        {
            if(matrice[i][j] % 2 == 0)
            {
                vettore_pari[k++] = matrice[i][j];
            }
        }
   }
}
```
nabboc++ ha scritto:
Nel passaggio per valore si passano alla funzione delle copie delle variabili, quindi il valore della variabile non viene modificato nel programma che chiama la funzione, mentre nel passaggio per riferimento viene passato l'indirizzo e non la copia del valore della variabile.
Diciamo che una cosa è capire cos'è il passaggio per riferimento, un'altra è usarlo...
Ti basi sul sentite dire, oppure hai studiato l'argomento da qualche parte?
- se hai studiato, ma qualcosa non ti è chiaro, una domanda ben formulata su un forum può essere un buon modo per risolvere il problema;
- se invece la tua è solo una conoscenza superficiale basata sul sentito dire ti ricordo il sito che ti ho suggerito nell'altro topic per colmare le tue lacune sulla teoria... inoltre il libro di testo del corso, per quanto mal fatto, credo sia cmq in grado di spiegare un argomento del genere.
N
nabboc++
Pochi posts
Iscritto da
nov, 2018
Messaggi:
33
Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi
13 nov 2018, 15:43
oregon ha scritto:
Un chiarimento... ma tu la teoria la stai affrontando su un libro o no?
Si, sul libro del corso, però non è che spiega proprio bene gli esercizi, di fatti sto vedendo anche su internet per comprendere meglio.

nabboc++

Pochi posts

Iscritto da: nov, 2018

Messaggi:: 33

Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi

13 nov 2018, 15:46

Nippolo ha scritto:
In pratica adesso per ottenere i 2 vettori e le relative lunghezze scorri la matrice ben 4 volte, quando invece utilizzando una funzione del genere:
void genera_v_pari_dispari(int r, int &l_pari, int &l_dispari, int v_pari[R*R], int v_dispari[R*R], int matrice[R][R]);
basterebbe scorrere la matrice una volta sola.

Ho implementato la funzione scritta da te e funziona, grazie, penso finalmente di aver capito.

Codice funzionante del programma:


/*
Programma che genera una matrice quadrata numerica casuale e la stampa a schermo.
Aggiungere:
1)Memorizzi in due vettori di uscita gli elementi pari e quelli dispari della matrice di pixel, e successivamente li stampi a schermo
*/
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;
//variabili globali
const int R=10; //numero righe e colonne massimo possibile della matrice

//prototipi
int numero_righe_e_colonne (int r);
void genera_matrice(int r,int matrice[R][R]); 
void stampa (int r,int matrice[R][R]);
void stampa_vettore(int lunghezza_vettore, int vettore[R*R]);
void genera_v_pari_dispari(int r, int &lunghezza_pari, int &lunghezza_dispari, int vettore_pari[R*R], int vettore_dispari[R*R], int matrice[R][R]); 


//programma principale
int main(){
   
   srand(time(0)); //inizializzazione seme
   
   int r=numero_righe_e_colonne (r); //generazione numero di righe e colonne con un valore compreso tra 5 e 10
   
   cout<<"La matrice avra' "<<r<<" righe e "<<r<<" colonne\n\n";
   
   int matrice[R][R];
   
   cout<<"Ora uscira' a schermo una matrice casuale.\n\n";
   
   genera_matrice(r, matrice);  //generazione matrice
   
   stampa(r, matrice); //stampa a schermo della matrice
   
   //1)Memorizzi in due vettori di uscita gli elementi pari e quelli dispari della matrice di pixel
   
   int lunghezza_pari=0;
   int vettore_pari[R*R];
   int lunghezza_dispari=0;
   int vettore_dispari[R*R];
   
   //genera vettori pari e dispari e calcola le rispettive lunghezze
   
   genera_v_pari_dispari(r, lunghezza_pari, lunghezza_dispari, vettore_pari, vettore_dispari, matrice); 

   
   cout<<"\nIl vettore pari e' lungo (nel main): "<<lunghezza_pari<<endl;
   
   cout<<"\nOra stampera' a schermo il vettore pari\n";
   
   stampa_vettore(lunghezza_pari, vettore_pari); //stampa a schermo vettore pari
   
   cout<<"\nIl vettore dispari e' lungo (nel main): "<<lunghezza_dispari<<endl;
   
   cout<<"\nOra stampera' a schermo il vettore dispari\n";
   
   stampa_vettore(lunghezza_dispari, vettore_dispari); //stampa a schermo vettore dispari 
   
   cout<<"\n\n\n";

   return 0; 
}

//sottoprogrammi

//generazione numero di righe e colonne
int numero_righe_e_colonne (int r){
   r=5+rand()%6;
    return (r);
}

//generazione matrice
void genera_matrice(int r, int matrice[R][R]){
   for(int i=0; i<r; i++){
       for(int j=0; j<r; j++){
          matrice[i][j]=rand()%100;
      }
  }
}

//stampa a schermo matrice
void stampa(int r, int matrice[R][R]){
   for (int i=0; i<r; i++){
   cout<<"\n";
   for (int j=0; j<r; j++){
      cout<<matrice[i][j]<<" ";
   }
   }
}

//stampa a schermo vettore 

void stampa_vettore(int lunghezza_vettore, int vettore[]){
   cout<<"\nIl vettore e' costituito dai seguenti elementi: \n";
   for (int i=0; i<lunghezza_vettore; i++){
      cout<<vettore[i]<<" ";
   }
   cout<<"\n\n";
}

//genera vettori pari e dispari e calcola le rispettive lunghezze

void genera_v_pari_dispari(int r, int &lunghezza_pari, int &lunghezza_dispari, int vettore_pari[R*R], int vettore_dispari[R*R], int matrice[R][R]){
	int p=0;
	int d=0;
	for (int i=0; i<r; i++){
		for (int j=0; j<r;j++){
			if(matrice[i][j]%2==0){
                vettore_pari[p++]=matrice[i][j];
            }else{
            	vettore_dispari[d++]=matrice[i][j];
			}
		}
	}
			
	lunghezza_pari=p;
	lunghezza_dispari=d;
	cout<<"\n\nIl vettore pari e' lungo (nella funzione): "<<lunghezza_pari<<"\n";
	cout<<"\nIl vettore dispari e' lungo (nella funzione): "<<lunghezza_dispari<<"\n";
}

O
oregon
Super Famoso
Iscritto da
nov, 2011
Messaggi:
21552
Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi
13 nov 2018, 15:57
nabboc++ ha scritto:
oregon ha scritto:
Un chiarimento... ma tu la teoria la stai affrontando su un libro o no?
Si, sul libro del corso, però non è che spiega proprio bene gli esercizi, di fatti sto vedendo anche su internet per comprendere meglio.
Ma non parlo di "spiegare gli esercizi" ma proprio della teoria.

Ad esempio, il passaggio di parametri a funzione, l'uso di array statici e dinamici ...
N
nabboc++
Pochi posts
Iscritto da
nov, 2018
Messaggi:
33
Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi
13 nov 2018, 16:55
Nippolo ha scritto:
Supposto che M e N siano due interi (con N>0), l'intervallo in cui può ricadere il risultato della suddetta operazione dipende solo da N, e in particolare sarà compreso tra 0 e N-1.
Perchè dici che può restituire solo 0 o 1?!
Si hai ragione, mi ero confuso, quando uno si mette la notte tardi si scrivono castronerie.
Nippolo ha scritto:
Forse non ci siamo capiti, io mi riferivo alla funzione numero_righe_e_colonne(). Mi spiego meglio... tu hai scritto:
int numero_righe_e_colonne(int r) { r = 5 + rand() % 6; return(r); } int main() { int r = numero_righe_e_colonne(r); ... }
quando in realtà basta fare
int numero_righe_e_colonne() { return 5 + rand() % 6; } int main() { int r = numero_righe_e_colonne(); ... }
oppure
void numero_righe_e_colonne(int &r) { r = 5 + rand() % 6; } int main() { int r; numero_righe_e_colonne(r); ... }
Giusto, grazie per le osservazioni.

Nippolo ha scritto:
in ogni caso nel momento in cui scrivi int v[DIM]={n} stai inizializzando il primo valore dell'array v ad n e i restanti DIM-1 elementi a 0.
Chiaro, grazie per la precisazione.

Nippolo ha scritto:
Un paio di domande: cosìè un array? Quando passiamo un array ad una funzione, cosa gli stiamo effettivamente passando?
Un array (o vettore) è un insieme di variabili dello stesso tipo che occupano in memoria locazioni consecutive.
Gli stiamo passando l'indirizzo dell'array, no?

Nippolo ha scritto:
return (vettpari[lunghezzapari]) semplicemente ritorna l'elemento di vettpari di indice lunghezzapari... detto questo e ricordando che gli indici degli elementi di vettpari variano tra 0 e lunghezzapari-1, implica che con la sudetta scrittura vai a leggere un'area di memoria esterna a quella riservata per l'array.
Giusto, grazie per l'osservazione.
Nippolo ha scritto:
Qualcosa del genere non va bene?
void generazione_vettorepari(int r, int matrice[R][R], int vettore_pari[R*R]) { unsigned int k = 0; for(unsigned int i = 0; i < r; ++i) { for(unsigned int j = 0; j < r; ++j) { if(matrice[i][j] % 2 == 0) { vettore_pari[k++] = matrice[i][j]; } } } }
Si giusto, grazie per la correzione, l'ho implementato nella funzione.

Nippolo ha scritto:
Ti basi sul sentite dire, oppure hai studiato l'argomento da qualche parte?
- se hai studiato, ma qualcosa non ti è chiaro, una domanda ben formulata su un forum può essere un buon modo per risolvere il problema;
- se invece la tua è solo una conoscenza superficiale basata sul sentito dire ti ricordo il sito che ti ho suggerito nell'altro topic per colmare le tue lacune sulla teoria... inoltre il libro di testo del corso, per quanto mal fatto, credo sia cmq in grado di spiegare un argomento del genere.
Per sentito dire la vedo difficile, ora sto vedendo online specialmente da quel corso che mi hai linkato.
Grazie per il consiglio sulle domande, nel caso se qualcosa non mi è chiaro scrivo qui.
Nippolo
Molto attivo
Iscritto da
mar, 2018
Messaggi:
1241
Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi
13 nov 2018, 17:13
nabboc++ ha scritto:
Ho implementato la funzione scritta da te e funziona, grazie, penso finalmente di aver capito.

Codice funzionante del programma:
...
L variabili p e d sono superflue, puoi utilizzare direttamente lunghezza_pari e lunghezza_dispari.
nabboc++ ha scritto:
Un array (o vettore) è un insieme di variabili dello stesso tipo che occupano in memoria locazioni consecutive.
Gli stiamo passando l'indirizzo dell'array, no?
Ok, ma cosa intendi con "l'indirizzo dell'array"?
N
nabboc++
Pochi posts
Iscritto da
nov, 2018
Messaggi:
33
Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi
13 nov 2018, 19:24
Nippolo ha scritto:
L variabili p e d sono superflue, puoi utilizzare direttamente lunghezza_pari e lunghezza_dispari.
Chiaro, ho modificato, grazie per la segnalazione.

Nippolo ha scritto:
Ok, ma cosa intendi con "l'indirizzo dell'array"?
L'indirizzo delle variabili dello stesso tipo che occupano in memoria locazioni consecutive.

nabboc++

Pochi posts

Iscritto da: nov, 2018

Messaggi:: 33

Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi

13 nov 2018, 19:27

Ho ampliato il programma inserendo altre funzioni, il codice compila e funziona tutto alla perfezione, se avete qualche suggerimento non esitate a scriverlo.

Codice funzionante:


/*
Programma che genera una matrice quadrata numerica casuale e la stampa a schermo.
Aggiungere:
1)Memorizzi in due vettori di uscita gli elementi pari e quelli dispari della matrice di pixel, e successivamente li stampi a schermo
2)Sostituisca gli elementi nulli della matrice con la media del vettore pari, e quelli pari a 50 con la media dei vettori dispari
3)Determini il massimo degli elementi della diagonale principale
4)(opzionale) Effettui l'eliminazione della riga della matrice dove si trova il valore massimo
*/
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;
//variabili globali
const int R=10; //numero righe e colonne massimo possibile della matrice

//prototipi
int numero_righe_e_colonne (int r);
void genera_matrice(int r, int matrice[R][R]); 
void stampa (int righe, int colonne, int matrice[R][R]);
void stampa_vettore(int lunghezza_vettore, int vettore[R*R]);
void genera_v_pari_dispari(int r, int &lunghezza_pari, int &lunghezza_dispari, int vettore_pari[R*R], int vettore_dispari[R*R], int matrice[R][R]);
int media_vettore(int lunghezza_vettore, int vettore[R*R]);
void sostituzione_valori_matrice (int r, int media_vettore_pari, int media_vettore_dispari , int matrice[R][R]);
void calcolo_massimo_diagonale_principale (int &indice_riga_massimo, int &massimo_diagonale_principale, int r, int matrice[R][R]);
void eliminazione_riga_massimo (int &indice_riga_massimo, int &r, int matrice[R][R], int &righe_nuova_matrice, int &colonne_nuova_matrice);

//programma principale
int main(){
   
   srand(time(0)); //inizializzazione seme
   
   int r=numero_righe_e_colonne (r); //generazione numero di righe e colonne con un valore compreso tra 5 e 10
   
   cout<<"La matrice avra' "<<r<<" righe e "<<r<<" colonne\n\n";
   
   int matrice[R][R];
   
   cout<<"Ora uscira' a schermo una matrice casuale.\n\n";
   
   genera_matrice(r, matrice);  //generazione matrice
   
   stampa(r, r, matrice); //stampa a schermo della matrice
   
   //1)Memorizzi in due vettori di uscita gli elementi pari e quelli dispari della matrice di pixel
   
   int lunghezza_pari=0;
   int vettore_pari[R*R];
   int lunghezza_dispari=0;
   int vettore_dispari[R*R];
   
   //genera vettori pari e dispari e calcola le rispettive lunghezze
   
   genera_v_pari_dispari(r, lunghezza_pari, lunghezza_dispari, vettore_pari, vettore_dispari, matrice); 

   
   cout<<"\nIl vettore pari e' lungo (nel main): "<<lunghezza_pari<<endl;
   
   cout<<"\nOra stampera' a schermo il vettore pari\n";
   
   stampa_vettore(lunghezza_pari, vettore_pari); //stampa a schermo vettore pari
   
   cout<<"\nIl vettore dispari e' lungo (nel main): "<<lunghezza_dispari<<endl;
   
   cout<<"\nOra stampera' a schermo il vettore dispari\n";
   
   stampa_vettore(lunghezza_dispari, vettore_dispari); //stampa a schermo vettore dispari 
   
   //2)Sostituisca gli elementi nulli della matrice con la media del vettore pari, e quelli pari a 50 con la media dei vettori dispari
   
   int media_vettore_pari=0;
   int media_vettore_dispari=0;
   
   media_vettore_pari=media_vettore(lunghezza_pari, vettore_pari);  //calcolo media vettore pari
   
   cout<<"\nIl valore della media del vettore pari e': "<<media_vettore_pari;
   
   media_vettore_dispari=media_vettore(lunghezza_dispari, vettore_dispari); //calcolo media vettore dispari
   
   cout<<"\nIl valore della media del vettore dispari e': "<<media_vettore_dispari;
   
   sostituzione_valori_matrice(r, media_vettore_pari, media_vettore_dispari, matrice);
   
   cout<<"\nVerra' stampata a schermo la nuova matrice: \n";
   
   stampa(r, r, matrice); //stampa a schermo della matrice
   
   //3)Determini il massimo degli elementi della diagonale principale
   
   int massimo_diagonale_principale=0;
   int indice_riga_massimo=0;
   
   calcolo_massimo_diagonale_principale(indice_riga_massimo, massimo_diagonale_principale, r, matrice);
   
   cout<<"\n\nIl valore del massimo della diagonale principale e': "<<massimo_diagonale_principale;
   
   //4)(opzionale) Effettui l'eliminazione della riga della matrice dove si trova il valore massimo
   
   cout<<"\nLa riga nella quale si trova il massimo e' la: "<<indice_riga_massimo;
   
   int righe_nuova_matrice, colonne_nuova_matrice;
   
   eliminazione_riga_massimo(indice_riga_massimo, r, matrice, righe_nuova_matrice, colonne_nuova_matrice);
   
   cout<<"\n\nStampa a schermo della matrice senza la riga del massimo: ";
   
   stampa(righe_nuova_matrice, colonne_nuova_matrice, matrice); //stampa a schermo della matrice
   
   
   cout<<"\n\n\n";

   return 0; 
}

//sottoprogrammi

//generazione numero di righe e colonne
int numero_righe_e_colonne (int r){
   r=5+rand()%6;
    return (r);
}

//generazione matrice
void genera_matrice(int r, int matrice[R][R]){
   for(int i=0; i<r; i++){
       for(int j=0; j<r; j++){
          matrice[i][j]=rand()%100;
      }
  }
}

//stampa a schermo matrice
void stampa (int righe, int colonne,int matrice[R][R]){
   for (int i=0; i<righe; i++){
   cout<<"\n";
   for (int j=0; j<colonne; j++){
      cout<<matrice[i][j]<<" ";
   }
   }
}

//stampa a schermo vettore 

void stampa_vettore(int lunghezza_vettore, int vettore[]){
   cout<<"\nIl vettore e' costituito dai seguenti elementi: \n";
   for (int i=0; i<lunghezza_vettore; i++){
      cout<<vettore[i]<<" ";
   }
   cout<<"\n\n";
}

//genera vettori pari e dispari e calcola le rispettive lunghezze

void genera_v_pari_dispari(int r, int &lunghezza_pari, int &lunghezza_dispari, int vettore_pari[R*R], int vettore_dispari[R*R], int matrice[R][R]){
	for (int i=0; i<r; i++){
		for (int j=0; j<r;j++){
			if(matrice[i][j]%2==0){
                vettore_pari[lunghezza_pari++]=matrice[i][j];
            }else{
            	vettore_dispari[lunghezza_dispari++]=matrice[i][j];
			}
		}
	}
}

//calcolo media vettore

int media_vettore(int lunghezza_vettore, int vettore[R*R]){
	int a=0;
	int numeratore, mediavettore;
	for (int i=0; i<lunghezza_vettore; i++){
		numeratore=vettore[i]+a;
		a=numeratore;
	}
	mediavettore=numeratore/lunghezza_vettore;
	 return (mediavettore);
}

//sostituzione valori matrice

void sostituzione_valori_matrice (int r, int media_vettore_pari, int media_vettore_dispari , int matrice[R][R]){
		for (int i=0; i<r; i++){
		for (int j=0; j<r; j++){
			if (matrice[i][j]==0){
				matrice[i][j]=media_vettore_pari;
			}else if(matrice[i][j]==55){
				matrice[i][j]=media_vettore_dispari;
			}else{}
		}
	}
}

//calcolo valore massimo diagonale principale e rispettivo indice di riga

void calcolo_massimo_diagonale_principale (int &indice_riga_massimo, int &massimo_diagonale_principale, int r, int matrice[R][R]){
	for (int i=0; i<r; i++){
		for (int j=0; j<r;j++){
			if (i==j  && massimo_diagonale_principale < matrice[i][j]){
				massimo_diagonale_principale=matrice[i][j];
				indice_riga_massimo=i+1;
			}
		}
	}
}

//eliminazione della riga nella quale è presente il massimo
void eliminazione_riga_massimo (int &indice_riga_massimo, int &r, int matrice[R][R], int &righe_nuova_matrice, int &colonne_nuova_matrice){
	indice_riga_massimo=indice_riga_massimo-1;
	for (int i=0; i<r; i++){
		for (int j=0; j<r; j++){
			if(i>=indice_riga_massimo){
				matrice[i][j]=matrice[i+1][j];
			}
		}
	}
	colonne_nuova_matrice=r;
	righe_nuova_matrice=r-1;
}

Nippolo
Molto attivo
Iscritto da
mar, 2018
Messaggi:
1241
Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi
13 nov 2018, 19:49
L'indirizzo delle variabili dello stesso tipo che occupano in memoria locazioni consecutive
Cioè nel momento in cui passiamo un array di N elementi ad una funzione gli stiamo passando N indirizzi di memoria?
Ho ampliato il programma inserendo altre funzioni, il codice compila e funziona tutto alla perfezione, se avete qualche suggerimento non esitate a scriverlo.
Appena ho tempo gli do un'occhiata.

Nippolo

Molto attivo

Iscritto da: mar, 2018

Messaggi:: 1241

Re: Programma che genera matrice quadrata casuale e array con sottoprogrammi

14 nov 2018, 01:08

Il codice mi sembra corretto, per quanto riguarda i suggerimenti ci sarebbero parecchie ottimizzazioni da fare, a scriverle tutte faccio prima a postarti il codice di come svolgerei io l'esercizio:

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

const unsigned int R = 10;

unsigned int numero_casuale(unsigned int MIN, unsigned int MAX);
void genera_matrice_casuale(int matrice[][R], unsigned int righe, unsigned int colonne);
void stampa_matrice(int matrice[][R], unsigned int righe, unsigned int colonne);
void genera_vettore_pari_dispari(int matrice[][R], unsigned int righe, unsigned int colonne, int v_pari[], unsigned int &dim_pari, int v_dispari[], unsigned int &dim_dispari);
void stampa_vettore(int vettore[], unsigned int dim);
int media_vettore(int vettore[], unsigned int dim);
void sostituzione_valori_matrice(int matrice[][R], unsigned int righe, unsigned int colonne, int target, int n);
unsigned int indice_max_diagonale_principale(int matrice[][R], unsigned int righe, unsigned int colonne);
void elimina_riga_matrice(int matrice[][R], unsigned int &righe, unsigned int colonne, unsigned int indice_riga);

int main()
{
    srand(time(0));
    int m[R][R];
    int v_p[R * R];
    int v_d[R * R];
    unsigned int l_p;
    unsigned int l_d;
    unsigned int r = numero_casuale(R / 2, R);
    unsigned int c = r;
    genera_matrice_casuale(m, r, c);
    cout << "MATRICE CASUALE:\n";
    stampa_matrice(m, r, c);
    genera_vettore_pari_dispari(m, r, c, v_p, l_p, v_d, l_d);
    cout << "\n\nVETTORE PARI:\n";
    stampa_vettore(v_p, l_p);
    cout << "\n\nVETTORE DISPARI:\n";
    stampa_vettore(v_d, l_d);
    sostituzione_valori_matrice(m, r, c,  0, media_vettore(v_p, l_p));
    sostituzione_valori_matrice(m, r, c, 50, media_vettore(v_d, l_d));
    elimina_riga_matrice(m, r, c, indice_max_diagonale_principale(m, r, c));
    cout << "\n\nMATRICE MODIFICATA:\n";
    stampa_matrice(m, r, c);
}

unsigned int numero_casuale(unsigned int MIN, unsigned int MAX)
{
    return MIN + rand() % (MAX - MIN + 1);
}

void genera_matrice_casuale(int matrice[][R], unsigned int righe, unsigned int colonne)
{
    for(unsigned int i = 0; i < righe; ++i)
    {
        for(unsigned int j = 0; j < colonne; ++j)
        {
            matrice[i][j] = numero_casuale(0, 99);
        }
    }
}

void stampa_matrice(int matrice[][R], unsigned int righe, unsigned int colonne)
{
    for(unsigned int i = 0; i < righe; ++i)
    {
        for(unsigned int j = 0; j < colonne; ++j)
        {
            if(matrice[i][j] < 10)
            {
                cout << " ";
            }
            cout << matrice[i][j] << " ";
        }
        cout << endl;
    }
}

void genera_vettore_pari_dispari(int matrice[][R], unsigned int righe, unsigned int colonne, int v_pari[], unsigned int &dim_pari, int v_dispari[], unsigned int &dim_dispari)
{
    dim_pari = 0;
    dim_dispari = 0;
    for(unsigned int i = 0; i < righe; ++i)
    {
        for(unsigned int j = 0; j < colonne; ++j)
        {
            if(matrice[i][j] % 2)
            {
                v_dispari[dim_dispari++] = matrice[i][j];
            }
            else
            {
                v_pari[dim_pari++] = matrice[i][j];
            }
        }
    }
}

void stampa_vettore(int vettore[], unsigned int dim)
{
    for(unsigned int i = 0; i < dim; ++i)
    {
        cout << vettore[i] << " ";
    }
}

int media_vettore(int vettore[], unsigned int dim)
{
    int somma = 0;
    for(unsigned int i = 0; i < dim; ++i)
    {
        somma += vettore[i];
    }
    return somma / dim;
}

void sostituzione_valori_matrice(int matrice[][R], unsigned int righe, unsigned int colonne, int target, int n)
{
    for(unsigned int i = 0; i < righe; ++i)
    {
        for(unsigned int j = 0; j < colonne; ++j)
        {
            if(matrice[i][j] == target)
            {
                matrice[i][j] = n;
            }
        }
    }
}

unsigned int indice_max_diagonale_principale(int matrice[][R], unsigned int righe, unsigned int colonne)
{
    unsigned int r = righe;
    if(colonne < righe)
    {
        r = colonne;
    }
    unsigned int indice = 0;
    for(unsigned int i = 1; i < r; ++i)
    {
        if(matrice[i][i] > matrice[indice][indice])
        {
            indice = i;
        }
    }
    return indice;
}

void elimina_riga_matrice(int matrice[][R], unsigned int &righe, unsigned int colonne, unsigned int indice_riga)
{
    --righe;
    for(unsigned int i = indice_riga; i < righe; ++i)
    {
        for(unsigned int j = 0; j < colonne; ++j)
        {
            matrice[i][j] = matrice[i + 1][j];
        }
    }
}

Magari puoi trarne qualche spunto. Se qualcosa non ti è chiaro o trovi qualche errore, fammi sapere!

EDIT:
corretto il verso della diseguaglianza nella funzione indice_max_diagonale_principale().

Devi accedere o registrarti per scrivere nel forum

25 risposte