Jak podsumować elementy wektora C ++?

Jakie są dobre sposoby na znalezienie sumy wszystkich elementów w std::vector?

Załóżmy, że mam wektor std::vector<int> vectorz kilkoma elementami. Teraz chcę znaleźć sumę wszystkich elementów. Jakie są różne sposoby na to samo?

W rzeczywistości istnieje wiele metod.

int sum_of_elems = 0;

C ++ 03

1. Klasyczna pętla:

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

2. Za pomocą standardowego algorytmu:

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

   Ważna uwaga: Typ ostatniego argumentu jest używany nie tylko dla wartości początkowej, ale również dla typu wyniku . Jeśli umieścisz tam liczbę całkowitą, będzie ona kumulować liczbę całkowitą, nawet jeśli wektor ma zmienną liczbę. Jeśli sumujesz liczby zmiennoprzecinkowe, zmień 0na 0.0lub 0.0f(dzięki nneonneo). Zobacz także rozwiązanie C ++ 11 poniżej.

C ++ 11 i wyższy

2. b. Automatyczne śledzenie typu wektora, nawet w przypadku przyszłych zmian:

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

3. Używanie std::for_each:

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

4. Korzystanie z pętli bazującej na zakresie (dzięki Rogerowi Pate'owi):

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

Najprostszym sposobem jest użycie std:accumuatetematyce vector<int> A:

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

Prasoon zaproponował już wiele różnych (i dobrych) sposobów na zrobienie tego, z których żaden nie musi się tutaj powtarzać. Chciałbym jednak zaproponować alternatywne podejście do prędkości.

Jeśli zamierzasz to robić dość często, możesz rozważyć „podklasowanie” swojego wektora, aby suma elementów była utrzymywana osobno (nie tak naprawdę wektor podklasowania, który jest niepewny z powodu braku wirtualny destruktor - mówię więcej klasy, która zawiera sumę oraz wektor w nim, has-azamiast is-a, i zapewnia wektor-Like metod).

W przypadku pustego wektora suma jest ustawiona na zero. Przy każdym wstawieniu do wektora dodaj wstawiany element do sumy. Przy każdym usunięciu odejmij to. Zasadniczo wszystko , co może zmienić wektor bazowy, jest przechwytywane, aby zapewnić spójność sumy.

W ten sposób masz bardzo wydajną metodę O (1) do „obliczania” sumy w dowolnym momencie (wystarczy zwrócić sumę aktualnie obliczoną). Wstawianie i usuwanie potrwa nieco dłużej, gdy dostosujesz sumę, i powinieneś wziąć pod uwagę to uderzenie wydajności.

Wektory, w których suma jest potrzebna częściej niż wektor jest zmieniany, prawdopodobnie skorzystają z tego schematu, ponieważ koszt obliczenia sumy jest amortyzowany dla wszystkich dostępów. Oczywiście, jeśli potrzebujesz tylko sumy co godzinę, a wektor zmienia się trzy tysiące razy na sekundę, nie będzie to odpowiednie.

Wystarczy coś takiego:

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

Oczywiście jest to pseudo-kod i możesz chcieć mieć trochę więcej funkcjonalności, ale pokazuje podstawową koncepcję.

Po co przeprowadzać sumowanie do przodu, skoro można to zrobić wstecz ? Dany:

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

Możemy użyć indeksowania, odliczając wstecz:

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

Możemy użyć sprawdzania zakresu „indeksowania”, odliczając wstecz (na wszelki wypadek):

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

Możemy użyć iteratorów odwrotnych w pętli for:

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

Możemy używać iteratorów do przodu, iterujących do tyłu, w pętli for (oooh, trudne!):

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

Możemy używać accumulatez iteratorami wstecznymi:

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

Możemy użyć for_eachwyrażenia lambda przy użyciu iteratorów odwrotnych:

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

Tak więc, jak widać, istnieje tak samo wiele sposobów na sumowanie wektora do tyłu, jak i na sumowanie wektora do przodu, a niektóre z nich są znacznie bardziej ekscytujące i oferują znacznie większą szansę na błędy indywidualne.

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

Można również użyć w std::valarray<T>ten sposób

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

Niektórzy mogą nie uznać tej metody za skuteczną, ponieważ rozmiar valarraypotrzeb musi być tak duży, jak rozmiar wektora i inicjowanie valarrayrównież zajmie trochę czasu.

W takim przypadku nie używaj go i potraktuj jako kolejny sposób podsumowania sekwencji.

Tylko C ++ 0x:

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

Jest to podobne do BOOST_FOREACH wspomnianego gdzie indziej i ma tę samą zaletę przejrzystości w bardziej złożonych sytuacjach, w porównaniu z funkcyjnymi stanowymi funktorami używanymi z akumulacją lub dla każdego.

Jestem użytkownikiem Perla, grą, którą mamy, jest znalezienie różnych sposobów na zwiększenie zmiennej ... tutaj tak naprawdę nie jest inaczej. Odpowiedź na to, ile sposobów na znalezienie sumy elementów wektora w C ++ jest prawdopodobnie an infinity...

Moje 2 centy:

Używając BOOST_FOREACH, aby uwolnić się od brzydkiej składni iteratora:

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

iteracja po indeksach (bardzo łatwa do odczytania).

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

Ten drugi jest destrukcyjny, uzyskując dostęp do wektora jak stos:

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

Znalazłem najłatwiejszy sposób na znalezienie sumy wszystkich elementów wektora

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

}

W tym programie mam wektor o rozmiarze 10 i są inicjowane przez 1. Obliczyłem sumę za pomocą prostej pętli jak w tablicy.

To jest łatwe. C ++ 11 zapewnia łatwy sposób podsumowania elementów wektora.

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