Come riassumere gli elementi di un vettore C ++?

Quali sono i buoni modi per trovare la somma di tutti gli elementi in a std::vector?

Supponiamo che io abbia un vettore std::vector<int> vectorcon alcuni elementi al suo interno. Ora voglio trovare la somma di tutti gli elementi. Quali sono i diversi modi per lo stesso?

In realtà ci sono alcuni metodi.

int sum_of_elems = 0;

C ++ 03

1. Classico per loop:

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

2. Utilizzando un algoritmo standard:

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

   Nota importante: l'ultimo tipo di argomento viene utilizzato non solo per il valore iniziale, ma anche per il tipo di risultato . Se inserisci un int lì, accumulerà ints anche se il vettore ha float. Se si sommano numeri in virgola mobile, passare 0a 0.0o 0.0f(grazie a nneonneo). Vedi anche la soluzione C ++ 11 di seguito.

C ++ 11 e versioni successive

2. b. Tenere traccia automaticamente del tipo di vettore anche in caso di modifiche future:

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

3. Utilizzando std::for_each:

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

4. Utilizzando un loop basato su range (grazie a Roger Pate):

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

Il modo più semplice è usare std:accumuateun vector<int> A:

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

Prasoon ha già offerto una serie di modi diversi (e buoni) per farlo, nessuno dei quali deve essere ripetuto qui. Vorrei tuttavia suggerire un approccio alternativo per la velocità.

Se avete intenzione di fare questo un bel po ', si può prendere in considerazione "sub-classificare" il vostro vettore in modo che una somma di elementi è mantenuta a parte (non in realtà vettore che è incerto sub-classing a causa della mancanza di un distruttore virtuale - Sto parlando più di una classe che contiene la somma e un vettore al suo interno, has-apiuttosto che is-ae fornisce i metodi simili al vettore).

Per un vettore vuoto, la somma è impostata su zero. Ad ogni inserimento nel vettore, aggiungi l'elemento da inserire alla somma. Ad ogni cancellazione, sottrarla. Fondamentalmente, tutto ciò che può cambiare il vettore sottostante viene intercettato per garantire che la somma sia mantenuta coerente.

In questo modo, hai un metodo O (1) molto efficiente per "calcolare" la somma in qualsiasi momento (basta restituire la somma attualmente calcolata). L'inserimento e l'eliminazione impiegheranno un po 'più di tempo a regolare il totale e dovresti prendere in considerazione questo risultato.

I vettori in cui la somma è necessaria più spesso della modifica del vettore sono quelli che possono beneficiare di questo schema, poiché il costo del calcolo della somma è ammortizzato su tutti gli accessi. Ovviamente, se hai solo bisogno della somma ogni ora e il vettore cambia tremila volte al secondo, non sarà adatto.

Qualcosa del genere sarebbe sufficiente:

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

Ovviamente, questo è pseudo-codice e potresti voler avere un po 'più di funzionalità, ma mostra il concetto di base.

Perché eseguire la somma in avanti quando è possibile farlo all'indietro ? Dato:

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

Possiamo usare la sottoscrizione, contando all'indietro:

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

Possiamo usare la "sottoscrizione" controllata dal range, contando all'indietro (per ogni evenienza):

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

Possiamo usare iteratori inversi in un ciclo for:

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

Possiamo usare iteratori in avanti, ripetendo indietro, in un ciclo for (oooh, difficile!):

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

Possiamo usare accumulatecon iteratori inversi:

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

Possiamo usare for_eachcon un'espressione lambda usando iteratori inversi:

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

Quindi, come puoi vedere, ci sono tanti modi per sommare il vettore all'indietro quanti sono per sommare il vettore in avanti, e alcuni di questi sono molto più eccitanti e offrono opportunità molto maggiori per errori off-by-one.

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

Si può anche usare in std::valarray<T>questo modo

#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;
}

Alcuni potrebbero non trovare questo modo efficiente poiché la dimensione dei valarraybisogni deve essere grande quanto la dimensione del vettore e l'inizializzazione valarrayrichiederà anche tempo.

In tal caso, non usarlo e considerarlo come un altro modo per riassumere la sequenza.

Solo C ++ 0x:

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

Questo è simile al BOOST_FOREACH menzionato altrove e ha lo stesso vantaggio della chiarezza in situazioni più complesse, rispetto ai funzionali stateful usati con accumulate o for_each.

Sono un utente Perl, un gioco che abbiamo è quello di trovare modi diversi per incrementare una variabile ... non è molto diverso qui. La risposta a quanti modi per trovare la somma degli elementi di un vettore in C ++ è probabilmente an infinity...

I miei 2 centesimi:

Usando BOOST_FOREACH, per liberarti della brutta sintassi dell'iteratore:

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

iterando sugli indici (davvero facile da leggere).

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

Quest'altro è distruttivo, accedendo al vettore come uno stack:

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

Ho trovato il modo più semplice per trovare la somma di tutti gli elementi di un vettore

#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;

}

In questo programma, ho un vettore di dimensione 10 e sono inizializzato da 1. Ho calcolato la somma con un semplice ciclo come in un array.

È facile. C ++ 11 fornisce un modo semplice per riassumere elementi di un vettore.

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