Comment résumer les éléments d'un vecteur C ++?

Quels sont les bons moyens de trouver la somme de tous les éléments dans un std::vector?

Supposons que j'ai un vecteur std::vector<int> vectorcontenant quelques éléments. Maintenant, je veux trouver la somme de tous les éléments. Quelles sont les différentes façons de faire la même chose?

En fait, il existe plusieurs méthodes.

int sum_of_elems = 0;

C ++ 03

1. Classique pour boucle:

   for(std::vector<int>::iterator it = vector.begin(); it != vector.end(); ++it)
       sum_of_elems += *it;

2. En utilisant un algorithme standard:

   #include <numeric>
   
   sum_of_elems = std::accumulate(vector.begin(), vector.end(), 0);

   Remarque importante: Le type du dernier argument est utilisé non seulement pour la valeur initiale, mais également pour le type du résultat . Si vous y mettez un int, il accumulera des ints même si le vecteur a flotté. Si vous additionnez des nombres à virgule flottante, passez 0à 0.0ou 0.0f(grâce à nneonneo). Voir également la solution C ++ 11 ci-dessous.

C ++ 11 et supérieur

2. b. Suivi automatique du type de vecteur, même en cas de modifications futures:

   #include <numeric>
   
   sum_of_elems = std::accumulate(vector.begin(), vector.end(),
                                  decltype(vector)::value_type(0));

3. En utilisant std::for_each:

   std::for_each(vector.begin(), vector.end(), [&] (int n) {
       sum_of_elems += n;
   });

4. Utilisation d'une boucle for basée sur une plage (grâce à Roger Pate):

   for (auto& n : vector)
       sum_of_elems += n;

La façon la plus simple est d'utiliser std:accumuateun vector<int> A:

#include <numeric>
cout << accumulate(A.begin(), A.end(), 0);

Prasoon a déjà proposé une multitude de façons différentes (et bonnes) de le faire, dont aucune n'a besoin d'être répétée ici. Je voudrais cependant suggérer une approche alternative pour la vitesse.

Si vous allez faire cela un peu, vous voudrez peut-être envisager de "sous-classer" votre vecteur afin qu'une somme d'éléments soit maintenue séparément (pas réellement un vecteur de sous-classification qui est incertain en raison de l'absence d'un destructeur virtuel - je parle plus d'une classe qui contient la somme et un vecteur, has-aplutôt que is-a, et fournit les méthodes de type vecteur).

Pour un vecteur vide, la somme est mise à zéro. À chaque insertion dans le vecteur, ajoutez l'élément inséré à la somme. À chaque suppression, soustrayez-le. Fondamentalement, tout ce qui peut changer le vecteur sous-jacent est intercepté pour garantir la cohérence de la somme.

De cette façon, vous disposez d'une méthode O (1) très efficace pour «calculer» la somme à tout moment (il suffit de renvoyer la somme actuellement calculée). L'insertion et la suppression prendront un peu plus de temps lorsque vous ajustez le total et vous devez prendre en compte ce résultat de performance.

Les vecteurs où la somme est nécessaire plus souvent que le vecteur n'est changé sont ceux susceptibles de bénéficier de ce schéma, puisque le coût de calcul de la somme est amorti sur tous les accès. Évidemment, si vous n'avez besoin que de la somme toutes les heures et que le vecteur change trois mille fois par seconde, il ne conviendra pas.

Quelque chose comme ça suffirait:

class UberVector:
    private Vector<int> vec
    private int sum

    public UberVector():
        vec = new Vector<int>()
        sum = 0

    public getSum():
        return sum

    public add (int val):
        rc = vec.add (val)
        if rc == OK:
            sum = sum + val
        return rc

    public delindex (int idx):
        val = 0
        if idx >= 0 and idx < vec.size:
            val = vec[idx]
        rc =  vec.delindex (idx)
        if rc == OK:
            sum = sum - val
        return rc

Évidemment, c'est du pseudo-code et vous voudrez peut-être avoir un peu plus de fonctionnalités, mais cela montre le concept de base.

Pourquoi effectuer la sommation vers l'avant alors que vous pouvez la faire vers l'arrière ? Donné:

std::vector<int> v;     // vector to be summed
int sum_of_elements(0); // result of the summation

Nous pouvons utiliser l'indice, en comptant à rebours:

for (int i(v.size()); i > 0; --i)
    sum_of_elements += v[i-1];

Nous pouvons utiliser la "souscription" vérifiée par intervalle (au cas où):

for (int i(v.size()); i > 0; --i)
    sum_of_elements += v.at(i-1);

Nous pouvons utiliser des itérateurs inverses dans une boucle for:

for(std::vector<int>::const_reverse_iterator i(v.rbegin()); i != v.rend(); ++i)
    sum_of_elements += *i;

Nous pouvons utiliser des itérateurs avant, itérant en arrière, dans une boucle for (oooh, délicat!):

for(std::vector<int>::const_iterator i(v.end()); i != v.begin(); --i)
    sum_of_elements += *(i - 1);

Nous pouvons utiliser accumulateavec des itérateurs inversés:

sum_of_elems = std::accumulate(v.rbegin(), v.rend(), 0);

Nous pouvons utiliser for_eachavec une expression lambda en utilisant des itérateurs inverses:

std::for_each(v.rbegin(), v.rend(), [&](int n) { sum_of_elements += n; });

Ainsi, comme vous pouvez le voir, il existe autant de façons de faire la somme du vecteur en arrière que de faire la somme du vecteur en avant, et certaines d'entre elles sont beaucoup plus intéressantes et offrent beaucoup plus de possibilités d'erreurs ponctuelles.

#include<boost/range/numeric.hpp>
int sum = boost::accumulate(vector, 0);

On peut aussi utiliser std::valarray<T>comme ça

#include<iostream>
#include<vector>
#include<valarray>

int main()
{
    std::vector<int> seq{ 1,2,3,4,5,6,7,8,9,10 };
    std::valarray<int> seq_add{ seq.data(), seq.size() };
    std::cout << "sum = " << seq_add.sum() << "\n";

    return 0;
}

Certains peuvent ne pas trouver cette méthode efficace car la taille de valarraydoit être aussi grande que la taille du vecteur et l'initialisation valarrayprendra également du temps.

Dans ce cas, ne l'utilisez pas et considérez-le comme une autre façon de résumer la séquence.

C ++ 0x uniquement:

vector<int> v; // and fill with data
int sum {}; // or = 0 ... :)
for (int n : v) sum += n;

Ceci est similaire au BOOST_FOREACH mentionné ailleurs et a le même avantage de clarté dans des situations plus complexes, par rapport aux foncteurs avec état utilisés avec accumulate ou for_each.

Je suis un utilisateur de Perl, un jeu que nous avons est de trouver toutes les différentes façons d'incrémenter une variable ... ce n'est pas vraiment différent ici. La réponse au nombre de façons de trouver la somme des éléments d'un vecteur en C ++ est probablement an infinity...

Mes 2 cents:

En utilisant BOOST_FOREACH, pour s'affranchir de la syntaxe de l'itérateur laid:

sum = 0;
BOOST_FOREACH(int & x, myvector){
  sum += x;
}

itération sur indices (très facile à lire).

int i, sum = 0;
for (i=0; i<myvector.size(); i++){
  sum += myvector[i];
}

Cet autre est destructeur, accédant au vecteur comme une pile:

while (!myvector.empty()){
   sum+=myvector.back();
   myvector.pop_back();
}

J'ai trouvé le moyen le plus simple de trouver la somme de tous les éléments d'un vecteur

#include <iostream>
#include<vector>
using namespace std;

int main()
{
    vector<int>v(10,1);
    int sum=0;
    for(int i=0;i<v.size();i++)
    {
        sum+=v[i];
    }
    cout<<sum<<endl;

}

Dans ce programme, j'ai un vecteur de taille 10 et suis initialisé par 1. J'ai calculé la somme par une simple boucle comme dans le tableau.

C'est facile. C ++ 11 fournit un moyen simple de résumer les éléments d'un vecteur.

sum = 0; 
vector<int> vec = {1,2,3,4,5,....}
for(auto i:vec) 
   sum+=i;
cout<<" The sum is :: "<<sum<<endl;