[C++] Esercizio: individuare il numero che appare più frequentemente in una matrice

[Stary]

Ciao ragazzi, mi sto esercitando per un esame di informatica che è basato sulla programmazione in c++.

*sono davanti ad un esercizio che mi chiede di costruire una matrice di n righe ed m colonne, e fin qui ci sono...

*mi chiede di stampare la diagonale, e ci sono pure...

*ora mi chiede di fare una funzione che mi dica, se esiste, il numero che è presente più volte (che non so realmente come fare)...

il codice che ho scritto fino ad ora è questo e comprende i punti 1 e 2 ma il punto 3 non c'è, valutate voi e consigliatemi per favore...

#include<iostream>
using namespace std;
int main()
{
int righe,colonne,ciclor,cicloc,valore,stampar,stampac,v=0;
cout << "Inserisci il numero delle righe" << endl;
cin >> righe;
cout << "Inserisci il numero delle cononne" << endl;
cin >> colonne;
int a[righe][colonne];
for(ciclor=0;ciclor<righe;ciclor++)
{
for(cicloc=0;cicloc<colonne;cicloc++)
{
cout << "Inserisci il numero da assegnare" << endl;
cin >> v;
a[ciclor][cicloc]=v;
}
}
system("cls");
cout << " La diagonale della matrice e': " << endl;
stampac=0;
stampar=0;
for(stampar=0;stampar<righe;stampar++)
{
cout << a[stampar][stampar] << endl;
}
system("pause");
return 0;
}

[Beavey]

Ciao,
ho provato a vedere velocemente di scrivere qualcosa che possa funzionare per la parte 3.

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

using namespace std;

int main() {
    //matrice n per m;
    int n = 2, m = 2;
    int matrice[2][2];

    matrice[0][0] = 1;
    matrice[0][1] = 1;
    matrice[1][0] = 1;
    matrice[1][1] = 4;

    int freq[4][2]; //array freq contiene il valore del numero e quante sono
    //le ricorrenze di questo numero
    //in freq, freq[n*m][0] = valore del numero; invece freq[n*m][1] = quante 
    //volte appare in matrice
    //percio' la prima colonna dell'array deve poter contenere al 
    //massimo n*m numeri (se sono tutti numeri diversi)

    //inizializziamo tutti i campi di freq a 0;
    for (int i = 0; i < (n*m); i++){
        freq[i][0] = 0;
        freq[i][1] = 0;
    }
    //cicliamo gli elementi di di freq per creare un array di numeri
    // che appaiono in matrice e la loro frequenza
    int numero;
    for (int e = 0; e < n; e++) {
        for (int f = 0; f < m; f++) {
            //prendi il numero dalla matrice e lo vai ad immettere nell'array delle frequenze
            numero = matrice[e][f];
            for (int g = 0; g < (e+f+1); g++) {
                //controlli se il numero e' gia stato inserito
                if (freq[g][1] == 0) {
                    //aumenti la frequenza di uno
                    freq[g][0] = numero;
                    freq[g][1] = 1;
                    break;
                }
                else {
                    if (freq[g][0] == numero) {
                        freq[g][1]++;
                        break;
                    }
                }
            }
        }
    }

    int freq_maggiore = 1;
    int numero_piu_frequente;
    int frequenza;
    //controllare quale e' il numero che appare piu volte
    for (int i = 0; i < (n*m); i++) {
        frequenza = freq[i][1];
        //controlla che questo numero, ovvero freq[i][0] appaia piu volte di 1.
        if (frequenza > freq_maggiore) {
                freq_maggiore = frequenza;
                numero_piu_frequente = freq[i][0];
        }
    }
    //controllare che il numero piu frequente sia solo uno
    int count = 0;
    for (int i = 0; i < (n*m); i++) {
        if (freq[i][0] == numero_piu_frequente) {
                count++;
        }
    }

    if (count > 1 || freq_maggiore == 1) {
        cout << "Non esiste un numero presente piu volte!" << endl;
    }
    else {
        cout << "Il numero che appare piu volte(" << freq_maggiore << " volte): ";
        cout << numero_piu_frequente << endl;
    }
}

Dovresti inserire questo codice sotto tutto il resto del tuo e cambiare la mia variabile matrice[][] in quella tua. Nel codice sopra, io ho creato una matrice 2x2 e ho inizializzato i campi nei numeri che ho scelto io. Per far funzionare il tuo codice con il mio devi cambiare il mio utilizzando le tue variabili (le mie righe = n, le mie colonne = m).

L'array freq, e' un array che salva il numero che e' stato inserito in matrice e quante volte questo numero appare in tutta la matrice. Non ho avuto modo di testare questo snippet a fondo, quindi potrebbero esserci dei bugs. Prova a compilarlo e a vedere se capisci come funziona.

Beavey

[Ippo343]

Io sfrutterei la map.

Spero che non verrò tritato dagli utenti esperti per l'algoritmo che sto per proporre , ma la map ha una caratteristica interessante.
Quando accedi ad una chiave che non esiste, la crea e inizializza il valore con il suo default.

Perciò, quando dichiari una map<int,int> (chiave intera, valori interi) e provi ad accedere alla map con una chiave che non esiste, il valore corrispondente viene creato col costruttore di default, che per gli interi è int(0).

Quindi ti basta fare un ciclo che scorra tutta la matrice, e ad ogni elemento della matrice incrementare il suo contatore, così:

 mappa_contatori[ matrice[i][j] ] += 1;

Una volta che hai scorso la matrice, avrai come chiavi della mappa tutti i numeri presenti nella matrice e come valori il numero di volte che ognuno di questi appare nella matrice.
A questo punto ti basta cercare la chiave a cui è associato il valore più grande.