Como resumir elementos de um vetor C ++?

Quais são as boas maneiras de encontrar a soma de todos os elementos em a std::vector?

Suponha que eu tenha um vetor std::vector<int> vectorcom alguns elementos. Agora eu quero encontrar a soma de todos os elementos. Quais são as diferentes maneiras para o mesmo?

Na verdade, existem alguns métodos.

int sum_of_elems = 0;

C ++ 03

1. Clássico para loop:

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

2. Usando um algoritmo padrão:

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

   Nota importante: O tipo do último argumento é usado não apenas para o valor inicial, mas também para o tipo do resultado . Se você colocar um int lá, ele acumulará ints, mesmo que o vetor tenha flutuado. Se você estiver somando números de ponto flutuante, altere 0para 0.0ou 0.0f(graças a nneonneo). Veja também a solução C ++ 11 abaixo.

C ++ 11 e superior

2. b. Acompanhar automaticamente o tipo de vetor, mesmo em caso de alterações futuras:

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

3. Usando std::for_each:

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

4. Usando um loop for baseado em intervalo (graças a Roger Pate):

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

A maneira mais fácil é usar std:accumuateum vector<int> A:

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

Prasoon já ofereceu várias maneiras diferentes (e boas) de fazer isso, nenhuma das quais precisa ser repetida aqui. Eu gostaria de sugerir uma abordagem alternativa para a velocidade, no entanto.

Se você estiver fazendo isso um pouco, considere "subclassificar" seu vetor para que uma soma de elementos seja mantida separadamente ( na verdade, não um vetor de subclasse que é duvidoso devido à falta de um destruidor virtual - estou falando mais de uma classe que contém a soma e um vetor dentro dela, has-ae não is-ae fornece os métodos semelhantes a vetores).

Para um vetor vazio, a soma é definida como zero. Em todas as inserções no vetor, adicione o elemento que está sendo inserido na soma. Em cada exclusão, subtraia-o. Basicamente, qualquer coisa que possa alterar o vetor subjacente é interceptada para garantir que a soma seja mantida consistente.

Dessa forma, você tem um método O (1) muito eficiente para "calcular" a soma a qualquer momento (basta retornar a soma calculada atualmente). A inserção e exclusão levarão um pouco mais de tempo enquanto você ajusta o total e você deve levar em consideração esse desempenho atingido.

Os vetores em que a soma é necessária com mais frequência do que o vetor é alterado são os que mais se beneficiam com esse esquema, uma vez que o custo do cálculo da soma é amortizado em todos os acessos. Obviamente, se você precisar da soma a cada hora e o vetor mudar três mil vezes por segundo, isso não será adequado.

Algo assim seria suficiente:

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

Obviamente, isso é pseudo-código e você pode querer ter um pouco mais de funcionalidade, mas mostra o conceito básico.

Por que executar a soma para a frente quando você pode fazer isso para trás ? Dado:

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

Podemos usar a assinatura, contando ao contrário:

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

Podemos usar a "assinatura" com intervalo verificado, contando para trás (apenas no caso):

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

Podemos usar iteradores reversos em um loop for:

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

Podemos usar iteradores para frente, iterando para trás, em um loop for (oooh, complicado!):

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

Podemos usar accumulatecom iteradores reversos:

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

Podemos usar for_eachcom uma expressão lambda usando iteradores reversos:

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

Portanto, como você pode ver, existem tantas maneiras de somar o vetor para trás quanto de somar o vetor para frente, e algumas delas são muito mais empolgantes e oferecem uma oportunidade muito maior para erros isolados.

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

Pode-se também usar std::valarray<T>assim

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

Alguns podem não achar esse caminho eficiente, pois o tamanho das valarraynecessidades precisa ser tão grande quanto o tamanho do vetor e a inicialização valarraytambém levará tempo.

Nesse caso, não o use e tome-o como mais uma maneira de resumir a sequência.

Apenas C ++ 0x:

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

Isso é semelhante ao BOOST_FOREACH mencionado em outro lugar e tem o mesmo benefício de clareza em situações mais complexas, em comparação com os funcores com estado usados ​​com acumular ou for_each.

Eu sou um usuário Perl, um jogo que temos é encontrar todas as maneiras diferentes de incrementar uma variável ... isso não é realmente diferente aqui. A resposta para quantas maneiras de encontrar a soma dos elementos de um vetor em C ++ é provavelmente an infinity...

Meus 2 centavos:

Usando BOOST_FOREACH, para se livrar da sintaxe feia do iterador:

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

iterando nos índices (realmente fáceis de ler).

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

Este outro é destrutivo, acessando o vetor como uma pilha:

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

Encontrei a maneira mais fácil de encontrar a soma de todos os elementos de um vetor

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

}

Neste programa, eu tenho um vetor do tamanho 10 e sou inicializado por 1. Calculei a soma por um loop simples, como na matriz.

Isso é fácil. O C ++ 11 fornece uma maneira fácil de resumir elementos de um vetor.

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