Trouver le Mode de Vecteur d'Entiers en C++

Donc je suis en train de faire un programme de base pour apprendre les bases du C++, je suis de la génération de 100 nombres aléatoires de 0 à 100 et de les stocker dans un vecteur, je suis ensuite l'affichage de la somme, la moyenne, la médiane, le mode, haut et bas du vecteur. J'ai tout fait sauf la mode qui est l'endroit où je suis coincé. Voici le code que j'ai jusqu'ici.

int modeFunction()
     {
         numMode = 0;
         count = 0;
         for (int n = 0; n < 100; n++)
         {
             for (int y = 0; y < 100; y++)
             {
                 if (numVector.at(y) == numVector.at(n))
                {
                    numMode = numVector.at(y);
                    count++;
                }
             }

         }
         return numMode;
     }

Après que je me retrouve bloqué parce que dans mon esprit qu'il convient de travail, mais il ne le fait pas. Il vient de sortir met le dernier numéro, généralement 100. Toute aide serait grandement appréciée.

si myVector est un std::vector<int> (on dirait que c'atleast), vous pouvez indexer un tableau: myVector[y] et myVector[n] donnera le même que le myVector.at version, mais c'est plus agréable à mon humble avis. 🙂
la différence étant que at a défini le comportement lorsque l'index est hors de portée. Sans doute operator[] est un micro-optimisation, même si comme vous le dites c'est aussi un peu un style de différence.
Ah, merci pour cette friandise. 🙂 Ne vous embêtez pas avec at encore, mais un tableau normal aussi a un comportement indéterminé pour hors de portée d'accès, mais il est certainement agréable d'avoir défini comportements quand vous en avez besoin. 🙂
pour être honnête, je n'ai jamais utiliser at moi-même. Je me demande parfois si je ne devrais pas, mais dans la pratique je n'ai jamais écrire de code que je veux lancer une exception lorsque l'index est en dehors des limites, donc il ne sert que de débogage aider, il "devrait" ne jamais se produire. En dépit de l'appeler un micro-optimisation, c'est un montant raisonnable de code redondant, donc au final si je veux une vérification de limites je viens de passer à Python 😉

OriginalL'auteur Cistoran | 2011-03-25

  1. 7

    depuis toutes les valeurs sont comprises entre 0 et 100, vous pouvez trouver le mode efficacement avec un histogramme:

    std::vector<int> histogram(101,0);
for( int i=0; i<100; ++i )
  ++histogram[ numVector[i] ];
return std::max_element( histogram.begin(), histogram.end() ) - histogram.begin();

    OriginalL'auteur bmcnett

  2. 5

    Puisque la mode est le nombre qui se produit plus fréquemment que vous ne devriez pas changer numMode à moins que le nouveau numéro du compteur est supérieure à numMode'comte.

    EDIT: Pour clarifier, vous avez besoin de garder un décompte de l'élément en cours et le nombre actuel que vous pensez est la mode. Idéalement, le réglage de newMode le premier élément est une bonne approche.

    En outre, le mode n'est pas nécessaire unique (c'est à dire "1 1 2 2"). Vous pouvez garder cela à l'esprit si vous vous souciez de cela.

    newMode = element[0]
modeCount = # of occurrence of newMode

for ( i-th element from [1 to end] ) {
   tmpCount = # of occurrence of element[i]
   if tmpCount > modeCount {
     newMode = element[i]
     modeCount = tmpCount
   }
}

    OriginalL'auteur nevets1219

  3. 1

    Votre algorithme est faux - il des sorties le dernier numéro dans le tableau parce que c'est tout ce qu'il peut faire. Chaque fois que le numéro d'index y correspond au numéro d'index n - vous remplacer les résultats de la précédente n. Depuis que vous utilisez la même boucle conditions, y et n sont toujours la même à au moins un point dans la boucle imbriquée pour chaque n valeur - et vous vous retrouvez toujours avec numMode être numVector.at(99).

    Vous avez besoin de changer votre algorithme pour enregistrer le nombre de chaque n index le long de la voie (ou au moins qui n index a terminé avec le plus grand count), de sorte que vous pouvez savoir à la fin de la n boucle dont la saisie a eu lieu la plupart du temps.

    OriginalL'auteur Carl Norum

  4. 1

    De solutions alternatives. Note: pas testé.

    int mode1(const std::vector<int>& values)
{   
    int old_mode = 0;
    int old_count = 0;
    for(size_t n=0; n < values.size(); ++n) 
    {
        int mode = values[n];
        int count = std::count(values.begin()+n+1, values.end(), mode);

        if(count > old_count) 
        {
            old_mode = mode;
            old_count = count;
        }
    }
    return old_mode;
}

int mode2(const std::vector<int>& values)
{   
    return std::max_element(values.begin(), values.end(), [](int value)
    {
        return std::count(values.begin(), values.end(), value);
    });
}

    OriginalL'auteur ronag

  5. 1

    bmcnett approche fonctionne très bien si nombre d'éléments sont assez petites. Si vous avez un grand nombre d'éléments, mais le tout élément de valeur sont dans une petite plage à l'aide de la carte/hashmap fonctionne bien. Quelque chose comme 

    typedef std::pair<int, int> mode_pair;

struct mode_predicate
{
  bool operator()(mode_pair const& lhs, mode_pair const& rhs)
  {
    return lhs.second < rhs.second;
  }
};

int modeFunction()
{
  std::map<int, int> mode_map;
  for (int n = 0; n < 100; n++)
    mode_map[numVector[n]]++;
  mode_predicate mp;
  return std::max_element(mode_map.begin(), mode_map.end(), mp)->first;
}

    OriginalL'auteur jbp

  6. 0

    Mode signifie un nombre avec la fréquence la plus élevée. La logique devrait être -

    //Start of function

int mode = 0, globalCount = 0 ;  
//Start of outer for loop
for i = 0 to length - 1    
   int localCount = 0   

  //Start of inner for loop  
  for j = 0 to length - 1      
     if vec[i] == vec[j]    
     ++localCount    
 //End of Inner for loop 

 if ( localCount > globalCount )  
     globalCount = localCount  
     mode = vec[i]  
//End of outer for loop  

if globalCount > 1 //This should be checked whether vec has repetitions at all
   return mode
else
   return 0

//End of function
    La logique peut être encore mieux à l'amélioration de l'efficacité, mais c'est ce que l'algorithme doit être en fonction de votre processus de pensée.

    OriginalL'auteur Mahesh