C++ Calcul du mode d'un tableau trié
Je dois écrire un code C++ qui trouve la médiane et le mode d'un tableau. On me dit qu'il est beaucoup plus facile de trouver le mode d'un tableau APRÈS que les nombres aient été triés. J'ai trié la fonction mais je ne trouve toujours pas le mode.
int counter = 0;
for (int pass = 0; pass < size - 1; pass++)
for (int count = pass + 1; count < size; count++) {
if (array [count] == array [pass])
counter++;
cout << "The mode is: " << counter << endl;
Si le tableau a déjà été trié, vous pouvez compter les occurrences d'un nombre à la fois. Ensuite, enregistrez simplement le nombre qui a le plus grand nombre d’occurrences. Et vous pouvez trouver le mode dans une seule boucle for. Sinon, vous devrez faire plus d'une boucle for. Voir un exemple de détail sur le lien ci-dessous Trouver-le-mode-d'un-ensemble-de-nombres
Voici le code,
int number = array[0];
int mode = number;
int count = 1;
int countMode = 1;
for (int i=1; i<size; i++)
{
if (array[i] == number)
{ // count occurrences of the current number
++count;
}
else
{ // now this is a different number
if (count > countMode)
{
countMode = count; // mode is the biggest ocurrences
mode = number;
}
count = 1; // reset count for the new number
number = array[i];
}
}
cout << "mode : " << mode << endl;
Une solution consiste à utiliser le codage de longueur d'exécution. Dans l'encodage de la longueur d'exécution, la représentation serait la suivante: (Item, sa fréquence).
Ce faisant, gardez une trace de la fréquence maximale et de l’élément. Cela vous donnera le mode une fois que vous avez terminé la longueur d'exécution.
par exemple:
1 1 2 2 2 3 3 4 5
Ce codage de longueur d'exécution serait
{1, 2}, {2, 3}, {3, 2}, {4, 1}, {5, 1}
Il faut O(n) espace.
Voici comment je l’ai fait, ma solution prend un vecteur trié en entrée. Il a O(n) complexité temporelle et peut fonctionner avec le cas où il y a plus d'un nombre "mode" dans le vecteur.
void findMode(vector<double> data) {
double biggestMode = 1;
vector<double> mode, numbers;
numbers.Push_back(data.at(0));
mode.Push_back(1);
int count = 0;
for (int i = 1; i < data.size(); i++) {
if (data.at(i) == numbers.at(count)) {
mode.at(count)++;
}
else {
if (biggestMode < mode.at(count)) {
biggestMode = mode.at(count);
}
count++;
mode.Push_back(1);
numbers.Push_back(data.at(i));
}
}
for (int i = 0; i < mode.size(); i++) {
if (mode.at(i) == biggestMode)
cout << numbers.at(i) << " ";
}
cout << endl;
}
Voici l'extrait de code:
int number = array[0];
int mode = number;
int count = 1;
int countMode = 1;
for (int i=1; i<size; i++)
{
if (array[i] == number)
{
count++;
}
else
{
if (count > countMode)
{
countMode = count;
mode = number;
}
count = 1;
number = array[i];
}
}
cout << "mode : " << mode << endl;
Le "mode" est la valeur la plus fréquente. Si aucun numéro n'est répété, alors il n'y a pas de mode pour la liste. Il n'y aurait donc aucun avantage à trier si vous aviez besoin de connaître le "mode".
Êtes-vous sûr de ne pas parler de la médiane? La médiane est le nombre du milieu dans un ensemble. Si vous avez 1,2,3,4,5, la médiane (nombre du milieu) est le (nombre_fin)/2) arrondi si elle est impair, 2,5 - > 3 et notre médiane serait 3. vous ne pouvez vraiment calculer la médiane que si vos nombres sont triés. Si vous avez un nombre pair dans un ensemble 1,2,3,4,5,6 votre mode est l’emplacement 3,4 (par coïncidence également, 3,4) (total_number)/2 slot et (total_number)/2 + 1, pour tout tableau pair de nombres.
Cela avait fonctionné.
int vals[9];
sort(vals, vals + 9);
int key = vals[0], value = 1,max_key=0,max_value=0;
for (int l = 1; l < 9; l++){
if (key == vals[l]){
value++;
}
else{
if (value>max_value){
max_key = vals[l-1];
max_value = value;
}
key = vals[l];
value = 1;
}
}
cout<< "Mode: "<< max_key << endl;
Je l'ai fait de cette façon:
int main()
{
int mode,modecount2,modecount1;
bool is_nomode=false;
vector<int> numbers = { 15,43,25,25,25,25,16,14,93,93,58,14,55,55,55,64,14,43,14,25,15,56,78,13,15,29,14,14,16 };
sort(numbers);
//If you uncomment the following part, you can see the sorted list of above numbers
//for (int i = 0; i < numbers.size(); ++i) std::cout << numbers[i] << '\n';
//keep_window_open();
mode = numbers[0];
modecount1 = 0;
modecount2 = 1; //Obviously any number exists at least once!
for (int i = 1; i < numbers.size(); ++i) {
if(numbers[i]==numbers[i-1]) ++modecount2;
else {
if (modecount2 > modecount1) {
mode = numbers[i - 1];
modecount1 = modecount2;
}
else if (i != 1 && modecount2 == modecount1) { std::cout << "No mode!\n"; is_nomode = true; break; }
modecount2 = 1;
}
}
if(!is_nomode) std::cout << "Mode of these numbers is: " << mode << std::endl;
keep_window_open();
Vous pouvez aussi ajouter 25 autres numéros à la liste et voir ce qui se passera si deux nombres ont le même événement! J'espère que cela vous aidera.
Il y a un vieil adage qui dit: "Si vous mettez 10 programmeurs dans une pièce et leur donnez le même programme à coder, vous obtiendrez 12 résultats différents", d'où ma version de la réponse à votre question. Ce n’est peut-être pas aussi rapide (j’ai l’intention de tester sa vitesse par rapport à certaines autres suggestions), mais j’estime que cela est facile à comprendre.
#include <iostream>
using namespace std;
int main ()
{
short z[10];
short maxCount = 0, curCount = 0, cur = 0, most = 0;
for (int i = 0; i < 10; i++)
{
cout << "Enter a number: " << endl;
cin >> z[i];
}
for (int i = 0; i < 10; i++)
{
cur = z[i];
for (int a = i; a < 10; a++)
{
if (cur == z[a])
{
curCount++;
cur = z[a];
}
if (curCount > maxCount)
{
maxCount = curCount;
most = z[a];
}
}
curCount = 0;
}
cout << "the mode is : " << maxCount << ", the number is: " << most << endl;
}
Ce code trouve le mode en C++:
#include <iostream>
using namespace std;
int main(int argc, char** argv)
{
int i,j,k=0,n,repeat_max=0,cn=0;
int array1[50],mode[50],count[50]={0},c[50];
cout<<"\n inter count:\t";
cin>>n;
cout<<"\n";
for(i=0;i<n;i++)
cin>>array1[i];
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(array1[i]==array1[j])
{
count[i]++;
if(count[i]>=repeat_max)
{
repeat_max=count[i];
mode[k++]=array1[i];
}
}
}
}
cout<<"\n================\n";
for(i=1;i<k;i++)
cout<<"\t mode[i]="<<mode[i]<<"\n";
cout<<"\t\n\nrepeat array:"<<repeat_max;
return 0;
}
Ce code devrait vous donner le mode. S'il y a un nombre égal de deux nombres différents, il en sortira le premier.
int count = 1, mode = 0, m = 0, i = 1;
size_t sz = sizeof(array)/sizeof(*array);
while(i != sz+1) {
if(array[i-1] != array[i]) {
if(count > m) {
mode = array[i-1];
m = count;
count = 1;
}
}
else
++count;
++i;
}
std::cout << "mode: " << mode << std::endl;
Ce code utilise "map" pour trouver le MODE du tableau donné. Il suppose que le tableau est déjà trié.
int findMode(int * arr, int arraySize)
{
map<int, int> modeMap;
for (int i = 0; i < arraySize; ++i) {
++modeMap[arr[i]];
}
auto x = std::max_element(modeMap.begin(), modeMap.end(),
[](const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second; });
return x->first;
}