Trouver la fréquence la plus élevée d'un élément dans un tableau (parfois cela fonctionne)

Question

Salut, j'ai rencontré un léger problème avec mon code ci-dessous. Parfois, la fréquence maximale renvoyée est correcte mais parfois non. Lorsque l'erreur se produit, elle renvoie toujours 1 trop. Je n'arrive pas à trouver l'erreur. J'ai essayé d'écrire la première boucle nrofpeople-1 mais cela ne fait pas de différence.

#include <stdio.h> 
#include <string.h> 
#include <time.h> 
#include <stdlib.h> 

#define MAX 10000 

int main(int argc, const char *argv[]) { 
    int nrofpeople; 
    int array[MAX]; 
    int num = 0; 
    int index; 

    srand((unsigned int)time(NULL)); 

    printf("How many people?"); 
    scanf("%d", &nrofpeople); 

    for (int i = 0; i < nrofpeople; i++) { 
     array[i] = rand() % 3 + 1; // generate random number to test 
    } 

    int maxcount = 0; 
    for (int i = 0; i < nrofpeople; i++) { 
     index = 1; 

     for (int j = 1; j < nrofpeople; j++) { 
      if (array[i] == array[j]) { 
       index++; 
      } 
     } 
     if (index > maxcount) { 
      maxcount = index; 
      num = array[i]; 
     } 
    } 

    printf("Number: %d Occurred: %d times\n", num, maxcount); 
    return 0; 
} 

Answer 1

Il y a quelques problèmes dans votre code:

• Vous ne vérifie pas la validité du nombre de personnes entrées, ce qui conduit à un comportement non défini pour l'entrée non valide.

• Votre algorithme pour trouver la fréquence la plus élevée est défectueux: vous comptez array[i] deux fois pour i > 0. Vous pouvez réellement faire en sorte que la boucle interne vérifie moins d'entrées, seule la première occurrence d'un nombre donné produisant le nombre maximum.

Voici une version améliorée:

#include <stdio.h> 
#include <string.h> 
#include <time.h> 
#include <stdlib.h> 

#define MAX 10000 

int main(int argc, const char *argv[]) { 
    int nrofpeople; 
    int array[MAX]; 

    printf("How many people?"); 
    if (scanf("%d", &nrofpeople) != 1 || nrofpeople <= 0 || nrofpeople > MAX) { 
     printf("invalid number of people\n"); 
     return 1; 
    } 

    srand((unsigned int)time(NULL)); 
    for (int i = 0; i < nrofpeople; i++) { 
     array[i] = rand() % 3 + 1; // generate random number to test 
    } 

    int num = 0, maxcount = 0; 
    for (int i = 0; i < nrofpeople; i++) { 
     int count = 1; 
     for (int j = i + 1; j < nrofpeople; j++) { 
      if (array[i] == array[j]) { 
       count++; 
      } 
     } 
     if (count > maxcount) { 
      maxcount = count; 
      num = array[i]; 
     } 
    } 
    printf("Number: %d Occurred: %d times\n", num, maxcount); 
    return 0; 
} 

Answer 2

(parfois ça marche)

Je suis en fait surpris que cela fonctionne toujours. Dans tous les cas, si vous voulez trouver la plus grande entrée dans votre tableau d'entrée, vous pouvez le faire en faisant un seul passage:

int maxcount = 0; 

for (int i=0; i < nrofpeople; i++) 
{ 
    if (array[i] > maxcount) 
    { 
     maxcount = array[i]; 
    } 
} 

Vous utilisez actuellement une double boucle sur le réseau, ce qui serait approprié si vous deviez faire une comparaison de style de produits croisés du tableau. Mais cela ne semble pas être en accord avec votre énoncé de problème.

Answer 3

Si vous avez l'intention de trouver la fréquence de chaque nombre dans un tableau donné, vous pouvez faire un autre tableau qui contient tous les éléments que contient le tableau original moins les nombres répétés. Ensuite, vous pouvez définir un tableau de comptage pour compter la fréquence de tous les nombres dans le tableau d'origine.

int flag = 0, a[nrpeople], k = 0; 
    for(int i = 0; i < nrpeople; i++){ 
    flag = 0; 
    for(int j = i+1; j<nrpeople; j++){ 
     if(array[i] == array[j]){ 
      flag = 1; 
      break; 
     } 
    } 
    if(flag == 0){ 
     a[k] = array[i]; 
     k++; 
    } 
    } 
    int count[k] = {0}; 
    for(int i=0; i<k; i++){ 
    for(int j = 0; j<nrpeople; j++){ 
     if(a[i] == array[j]) 
     count[i]++; 
    } 
    } 

Ensuite, faites ce que vous voulez avec la matrice de comptage.

Answer 4

Il y a des zones non-clarifiées dans l'énoncé du problème que vous voulez résoudre. Je pense qu'il aurait mieux valu que vous nous fournissiez plusieurs exemples (input + output attendu).

Quoi qu'il en soit, j'ai lu votre dernier commentaire et il semble que vous vouliez trouver l'élément (fréquent) le plus commun dans un tableau donné. Voici un moyen d'y parvenir. Il y a des commentaires dans le code: lisez-les attentivement.

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 

#define MAX 10 

// gcc main.c -o main -std=c99 
// ./main 

int main(int argc, const char * argv[]) 
{ 
    srand((unsigned int)time(NULL)); 

    int array[MAX]; 
    for(int i=0; i<MAX; i++) { 
     array[i] = -1; // to make sure there are no uninitialized fields 
    } 

    int npeople = -1; 
    do { 
     printf("How many people (1 to %d)? ", MAX); 
     scanf("%d", &npeople); 
    } 
    while(npeople<1 || npeople>MAX); 

    // Filling array with integer values in range [min, max] 

    const unsigned int min=5; 
    const unsigned int max=15; 
    for(int i=0; i<npeople; i++) { 
     array[i] = min + rand() % (max-min+1); 
    } 

    // Now searching for the most frequent element 

    const int f = max+1; 
    int freq[f]; 
    /* frequency array 
    * freq[i] = k means value i appears k times in array 
    * And to make things easier, we use up to max+1 fields for the frequency array. 
    * But normally, only max-min+1 fields are needed. 
    * However in that case, additional conversions (between array and freq) 
    * become mandatory. 
    */ 

    // initialization 
    for(int i=0; i<f; i++) { 
     freq[i] = 0; 
    } 

    // filling frequency array 
    for(int i=0; i<MAX; i++) { 
     freq[array[i]]++; 
    } 

    // Display 

    printf("\n"); 
    printf("Input array\n"); 
    printf("===========\n"); 
    for(int i=0; i<MAX; i++) { 
     printf("%d", array[i]); 
     i==MAX-1 ? printf("\n") : printf(" "); 
    } 

    printf("\n"); 
    printf("Frequency array\n"); 
    printf("===============\n"); 
    for(int i=0; i<f; i++) { 
     printf("%0d", freq[i]); 
     i==f-1 ? printf("\n") : printf(" "); 
    } 

    printf("\n"); 
    printf("Note\n"); 
    printf("====\n"); 
    printf("freq[i] = k MEANS value i appears k times in array\n"); 

    int mse = -1; // most frequent element 
    int h = -1; // highest occurrence 
    for(int i=0; i<f; i++) { 
     if(freq[i] > h) { 
      h = freq[i]; 
      mse = i; 
     } 
    } 
    printf("\n"); 
    printf("Conclusion\n"); 
    printf("==========\n"); 
    printf("The most frequent element is %d, appearing %d time(s).\n", mse, h); 

    return 0; 
} 

Cet algorithme fonctionne puisque nous connaissons les valeurs minimum et maximum dans le tableau. Si nous ne le faisons pas, nous pouvons d'abord trier le tableau en utilisant qsort et ensuite nous pourrons trouver l'extrema du tableau (valeurs extrêmes).

Espérons que ça aide.