¿Cómo resumir elementos de un vector C ++?

¿Cuáles son las buenas maneras de encontrar la suma de todos los elementos en a std::vector?

Supongamos que tengo un vector std::vector<int> vectorcon algunos elementos. Ahora quiero encontrar la suma de todos los elementos. ¿Cuáles son las diferentes formas de lo mismo?

En realidad, hay bastantes métodos.

int sum_of_elems = 0;

C ++ 03

1. Clásico para loop:

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

2. Usando un algoritmo estándar:

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

   Nota importante: El tipo del último argumento se usa no solo para el valor inicial, sino también para el tipo del resultado . Si coloca un int allí, acumulará entradas incluso si el vector tiene flotación. Si está sumando números de coma flotante, cambie 0a 0.0o 0.0f(gracias a nneonneo). Vea también la solución C ++ 11 a continuación.

C ++ 11 y superior

2. si. Seguimiento automático del tipo de vector incluso en caso de cambios futuros:

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

3. Utilizando std::for_each:

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

4. Uso de un bucle for basado en rango (gracias a Roger Pate):

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

La forma más fácil es usar std:accumuateun vector<int> A:

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

Prasoon ya ha ofrecido una gran cantidad de formas diferentes (y buenas) de hacer esto, ninguna de las cuales necesita repetirse aquí. Sin embargo, me gustaría sugerir un enfoque alternativo para la velocidad.

Si va a hacer esto un poco, es posible que desee considerar "subclasificar" su vector para que una suma de elementos se mantenga por separado (en realidad no es un subclasificación de vectores que es dudoso debido a la falta de un destructor virtual: estoy hablando más de una clase que contiene la suma y un vector dentro de ella, en has-alugar de is-a, y proporciona los métodos de tipo vector).

Para un vector vacío, la suma se establece en cero. En cada inserción en el vector, agregue el elemento que se inserta a la suma. En cada eliminación, restarlo. Básicamente, cualquier cosa que pueda cambiar el vector subyacente se intercepta para garantizar que la suma se mantenga constante.

De esa manera, tiene un método O (1) muy eficiente para "calcular" la suma en cualquier momento (solo devuelva la suma calculada actualmente). La inserción y la eliminación tardarán un poco más a medida que ajuste el total y debe tener en cuenta este éxito de rendimiento.

Los vectores en los que la suma se necesita con más frecuencia que el vector que se cambia son los que probablemente se beneficiarán de este esquema, ya que el costo de calcular la suma se amortiza en todos los accesos. Obviamente, si solo necesita la suma cada hora y el vector cambia tres mil veces por segundo, no será adecuado.

Algo como esto sería 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, ese es un seudocódigo y es posible que desee tener un poco más de funcionalidad, pero muestra el concepto básico.

¿Por qué realizar la suma hacia adelante cuando puedes hacerlo al revés ? Dado:

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

Podemos usar suscripciones, contando hacia atrás:

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

Podemos usar "suscripciones" controladas por rango, contando hacia atrás (por si acaso)

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

Podemos usar iteradores inversos en un ciclo for:

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

Podemos usar iteradores hacia adelante, iterando hacia atrás, en un bucle for (¡oooh, complicado!):

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

Podemos usar accumulatecon iteradores inversos:

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

Podemos usar for_eachcon una expresión lambda usando iteradores inversos:

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

Por lo tanto, como puede ver, hay tantas formas de sumar el vector hacia atrás como de sumar el vector hacia adelante, y algunas de ellas son mucho más emocionantes y ofrecen muchas más oportunidades para errores fuera de uno.

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

También se puede usar std::valarray<T>así

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

Algunos pueden no encontrar esta manera eficiente ya que el tamaño de las valarraynecesidades debe ser tan grande como el tamaño del vector y la inicialización valarraytambién llevará tiempo.

En ese caso, no lo use y tómelo como otra forma de resumir la secuencia.

Solo C ++ 0x:

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

Esto es similar al BOOST_FOREACH mencionado en otra parte y tiene el mismo beneficio de claridad en situaciones más complejas, en comparación con los functores con estado utilizados con acumular o para cada uno.

Soy un usuario de Perl, un juego que tenemos es encontrar diferentes formas de incrementar una variable ... eso no es realmente diferente aquí. La respuesta a cuántas formas de encontrar la suma de los elementos de un vector en C ++ es probablemente an infinity...

Mis 2 centavos:

Usando BOOST_FOREACH, para liberarse de la sintaxis del iterador feo:

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

iterando sobre índices (realmente fácil de leer).

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

Este otro es destructivo, accediendo al vector como una pila:

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

Encontré la forma más fácil de encontrar la suma de todos los elementos de un vector

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

}

En este programa, tengo un vector de tamaño 10 y se inicializan en 1. He calculado la suma mediante un bucle simple como en una matriz.

Es fácil. C ++ 11 proporciona una manera fácil de resumir elementos de un vector.

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