Как найти сумму всех элементов вектора

Using inclusive_scan (C++17 and above):

The advantage is you can get sums of first «N» elements in a vector. Below is the code. Explanation in comments.

To use inclusive_scan , need to include «numeric» header.

    //INPUT VECTOR
    std::vector<int> data{ 3, 1, 4, 1, 5, 9, 2, 6 };

    //OUTPUT VECTOR WITH SUMS
    //FIRST ELEMENT - 3 
    //SECOND ELEMENT - 3 + 1 
    //THIRD ELEMENT - 3 + 1 + 4 
    //FOURTH ELEMENT - 3 + 1 + 4 + 1
    // ..
    // ..
    //LAST ELEMENT - 3 + 1 + 4 + 1 + 5 + 9 + 2 + 6
    std::vector<int> sums(data.size());

    //SUM ALL NUMBERS IN A GIVEN VECTOR.
    inclusive_scan(data.begin(), data.end(),
        sums.begin());

    //SUM OF FIRST 5 ELEMENTS.
    std::cout << "Sum of first 5 elements :: " << sums[4] << std::endl;

    //SUM OF ALL ELEMENTS
    std::cout << "Sum of all elements :: " << sums[data.size() - 1] << std::endl;

Also there is an overload where the execution policy can be specified. Sequential execution or Parallel execution. Need to include «execution» header.

    //SUM ALL NUMBERS IN A GIVEN VECTOR.
    inclusive_scan(std::execution::par,data.begin(), data.end(),
        sums.begin());

Using reduce :

One more option which I did not notice in the answers is using std::reduce which is introduced in c++17.

But you may notice many compilers not supporting it (Above GCC 10 may be good). But eventually the support will come.

With std::reduce, the advantage comes when using the execution policies. Specifying execution policy is optional. When the execution policy specified is std::execution::par, the algorithm may use hardware parallel processing capabilities. The gain may be more clear when using big size vectors.

Example:

//SAMPLE
std::vector<int> vec = {2,4,6,8,10,12,14,16,18};
    
//WITHOUT EXECUTION POLICY
int sum = std::reduce(vec.begin(),vec.end());
    
//TAKING THE ADVANTAGE OF EXECUTION POLICIES
int sum2 = std::reduce(std::execution::par,vec.begin(),vec.end());
    
std::cout << "Without execution policy  " << sum << std::endl;
std::cout << "With execution policy  " << sum2 << std::endl;

You need <numeric> header for std::reduce.
And '<execution>' for execution policies.

Given a vector, find the sum of the elements of this vector using STL in C++.

Example:

Input: vec = {1, 45, 54, 71, 76, 12}
Output: 259

Input: vec = {1, 7, 5, 4, 6, 12}
Output: 35

Approach: 

Sum can be found with the help of accumulate() function provided in STL.

Syntax:

accumulate(first_index, last_index, initial value of sum);

Vector: 1 45 54 71 76 12 

Sum = 259

Time Complexity: It is linear in the distance between first_index and last_index i.e if your  vector contains n number of elements between two given indices , the time complexity will be O(n).
Auxiliary Space: O(1)

Another Approach: (Using the for_each() function)

The for_each() function is an STL algorithm that applies a given function to each element in a range defined by a pair of iterators.
To find the sum of all elements in a vector using the for_each() function, we can define a lambda function or a function object that adds each element to a running total.

Syntax:

for_each(InputIt first, InputIt last, UnaryFunction f);

Vector: 1 45 54 71 76 12 
Sum = 259

Time Complexity: O(N), , where N is the number of elements in the range.
Auxiliary Space: O(1)

Last Updated :
16 Apr, 2023

Like Article

Save Article

Sum up of all elements of a C++ vector can be very easily done by std::accumulate method. It is defined in <numeric> header. It accumulates all the values present specified in the vector to the specified sum.

Algorithm

Begin
   Declare v of vector type.
      Initialize some values into v vector in array pattern.
      Print “Sum of all the elements are:”.
      Call accumulate(v.begin(),v.end(),0) to calculate the sum of all
      values of v vector.
      Print the result of sum.
End.

Example Code

 Live Demo

#include<iostream>
#include<vector>
#include<numeric>
using namespace std;
int main() {
   vector<int> v = {2,7,6,10};
   cout<<"Sum of all the elements are:"<<endl;
   cout<<accumulate(v.begin(),v.end(),0);
}

Output

Sum of all the elements are:
25

Вопрос:

Лучший ответ:

int sum_of_elems = 0;

Ответ №1

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

Ответ №2

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

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

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

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

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

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

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

Ответ №3

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

Ответ №4

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

Ответ №5

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

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

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

Ответ №6

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

Ответ №7

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

Ответ №8

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

}

Ответ №9

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

Как суммировать элементы вектора С++?

Каковы хорошие способы найти сумму всех элементов в std::vector ?

Предположим, что у меня есть вектор std::vector vector с несколькими элементами в нем. Теперь я хочу найти сумму всех элементов. Каковы разные способы для этого?

На самом деле существует довольно много методов.

Классический для цикла:

Использование стандартного алгоритма:

Будьте осторожны с накоплением. Последний тип аргумента используется не только для начального значения, но и для типа результата. Если вы поместите int туда, он будет накапливать int, даже если вектор имеет float. Если вы суммируете числа с плавающей запятой, измените 0 на 0.0 или 0.0f (благодаря nneonneo).

С++ 11 и выше

Использование цикла, основанного на диапазоне (спасибо Roger Pate):

Prasoon уже предложил множество различных (и хороших) способов сделать это, ни один из которых не нужно повторять здесь. Однако я хотел бы предложить альтернативный подход к скорости.

Если вы собираетесь делать это совсем немного, вы можете рассмотреть возможность “подклассификации” вашего вектора, чтобы сумма элементов поддерживалась отдельно (а не вектором подклассификации, что сомнительно из-за отсутствия виртуальный деструктор – я говорю больше о классе, который содержит сумму и вектор внутри него, has-a , а не is-a , и предоставляет вектороподобные методы).

Для пустого вектора сумма устанавливается равной нулю. При каждой вставке в вектор добавляйте вставляемый элемент в сумму. На каждом удалении вычтите это. По сути, все, что может изменить базовый вектор, перехватывается, чтобы обеспечить постоянство суммы.

Таким образом, у вас есть очень эффективный метод O (1) для “вычисления” суммы в любой момент времени (просто верните вычисленную в данный момент сумму). Вставка и удаление займет немного больше времени, так как вы корректируете общее значение, и вы должны учитывать этот показатель эффективности.

Векторы, в которых сумма требуется чаще, чем вектор, который можно изменить, – это те, которые могут выиграть от этой схемы, поскольку стоимость расчета суммы амортизируется по всем доступам. Очевидно, что если вам нужна только сумма каждый час, а вектор меняется три тысячи раз в секунду, она не подойдет.

Что-то вроде этого будет достаточно:

Очевидно, что этот псевдокод и вам может потребоваться немного больше функциональности, но он показывает основную концепцию.

Зачем выполнять суммирование вперед, когда вы можете сделать это назад? Дано:

Мы можем использовать индексирование, считая назад:

Мы можем использовать “подписи”, проверенные по диапазону, “отсчет назад (на всякий случай):

Мы можем использовать обратные итераторы в цикле for:

Мы можем использовать итераторы вперед, итерации назад, в цикле for (oooh, tricky!):

Мы можем использовать accumulate с обратными итераторами:

Мы можем использовать for_each с выражением лямбда с использованием обратных итераторов:

Таким образом, как вы можете видеть, существует так же много способов суммирования вектора назад, как и для того, чтобы суммировать вектор вперед, а некоторые из них гораздо более захватывают и предлагают гораздо большую возможность для ошибок по отдельности.

Самый простой способ – использовать std:accumuate vector A :

Я пользователь Perl, игра, которую мы имеем, состоит в том, чтобы найти всевозможные способы увеличения переменной… что здесь совсем не так. Ответ на то, сколько способов найти сумму элементов вектора в С++, вероятно, an infinity …

Используя BOOST_FOREACH, чтобы освободиться от уродливого синтаксиса итератора:

итерирование по индексам (очень легко читается).

Этот другой является деструктивным, доступ к вектору, как стек:

Это похоже на BOOST_FOREACH, упомянутый в другом месте, и имеет то же преимущество ясности в более сложных ситуациях, по сравнению с функторами состояния, используемыми с накоплением или for_each.

Можно также использовать std:: valarray, как этот

Некоторые из них могут оказаться неэффективными, поскольку размер valarray должен быть таким же большим, как размер вектора, и инициализация valarray также займет время.

В этом случае не используйте его и возьмите его как еще один способ суммирования последовательности.

Я нашел самый простой способ найти сумму всех элементов вектора

В этой программе у меня есть вектор размером 10 и инициализируется 1. Я вычислил сумму простым циклом, как в массиве.

Это легко. С++ 11 предоставляет простой способ суммировать элементы вектора.

Как суммировать элементы вектора C++?

Что такое хороший способы нахождения суммы всех элементов std::vector ?

Предположим у меня есть вектор std::vector vector с несколькими элементами в нем. Теперь я хочу найти сумму всех элементов. Что такое разные способы для одного и того же?

8 ответов

на самом деле существует довольно много методов.

обычный цикл for:

используя стандартный алгоритм:

будьте осторожны с аккумулировать. тип последнего аргумента используется не только для начального значения, но и для типа результата. Если вы поместите туда int, он будет накапливать ints, даже если вектор имеет плыть. Если вы суммируете числа с плавающей запятой, измените 0 to 0.0 или 0.0f (спасибо nneonneo).

C++11 и выше

использование диапазона на основе цикла for (благодаря Роджеру Пейту):

Прасун уже предложил множество различных (и хороших) способов сделать это, ни один из которых не нужно повторять здесь. Однако я хотел бы предложить альтернативный подход к скорости.

Если вы собираетесь делать это совсем немного, вы можете рассмотреть вопрос о «подклассе» вашего вектора, чтобы сумма элементов поддерживалась отдельно (не на самом деле вектор подкласса, который является неопределенным из — за отсутствия виртуального деструктора- я говорю больше о классе, который содержит сумму и вектор внутри нее, has-a , а не is-a , и предоставляет векторные методы).

для пустого вектора сумма равна нулю. При каждой вставке в вектор добавьте вставляемый элемент в сумму. При каждом удалении вычтите его. В основном, что-нибудь, который может изменить базовый вектор, перехватывается, чтобы обеспечить согласованность суммы.

таким образом, у вас есть очень эффективный метод O (1) для «вычисления» сумма в любой момент времени (просто верните сумму, рассчитанную в данный момент). Вставка и удаление займет немного больше времени, как вы регулируете общую сумму, и вы должны принять во внимание эту производительность хит.

векторы, где сумма необходима чаще, чем вектор изменяется, являются теми, которые, вероятно, выиграют от этой схемы, так как стоимость расчета суммы амортизируется по всем доступам. Очевидно, если вам нужна только сумма каждый час, а вектор меняется на три тысячи раз в секунду, это не подходит.

что-то вроде этого было бы достаточно:

очевидно, что это псевдо-код и вам может потребоваться немного больше функциональности, но он показывает основную идею.

Зачем выполнять суммирование вперед, когда вы можете это сделать назад? Дано:

мы можем использовать знак, обратный отсчет:

мы можем использовать диапазон-проверено «знак,» обратный отсчет (на всякий случай):

мы можем использовать обратные итераторы в цикле for:

мы можем использовать прямые итераторы, итерации назад, в цикле for (oooh, tricky!):

мы можем использовать accumulate с обратными итераторами:

можно использовать for_each С лямбда-выражением с использованием обратных итераторов:

Итак, как вы можете видеть, существует столько же способов суммировать вектор назад, сколько и суммировать вектор вперед, и некоторые из них гораздо более увлекательны и предлагают гораздо больше возможностей для ошибок off-by-one.

Вычислить сумму элементов вектора

Сложение и вычитание векторов

Формулы сложения и вычитания векторов

Формулы сложения и вычитания векторов для плоских задач

В случае плоской задачи сумму и разность векторов a = и b = можно найти, воспользовавшись следующими формулами:

Формулы сложения и вычитания векторов для пространчтвенных задач

В случае пространственной задачи сумму и разность векторов a = и b = можно найти, воспользовавшись следующими формулами:

Формулы сложения и вычитания n -мерных векторов

В случае n -мерного пространства сумму и разность векторов a = и b = можно найти, воспользовавшись следующими формулами:

Примеры задач на сложение и вычитание векторов

Примеры плоских задач на сложение и вычитание векторов

Примеры пространственных задач на сложение и вычитание векторов

Примеры задач на сложение и вычитание векторов с размерностью большей 3

Любые нецензурные комментарии будут удалены, а их авторы занесены в черный список!

Добро пожаловать на OnlineMSchool.
Меня зовут Довжик Михаил Викторович. Я владелец и автор этого сайта, мною написан весь теоретический материал, а также разработаны онлайн упражнения и калькуляторы, которыми Вы можете воспользоваться для изучения математики.

Пример. Вычислить сумму элементов вектора Х.

Заметим, что составной оператор, повторно выполняемый при помощи оператора for, не должен содержать операторов, присваивающих значения управляющей переменной. Если необходимо завершить повторное выполнение составного оператора прежде, чем управляющая переменная примет конечное значение, то можно воспользоваться оператором goto. В таких случаях лучше воспользоваться оператором while или repeat.

После завершения выполнения операторов for значение управляющей переменной равно конечному значению, если же это не так, то значит цикл не был выполнен вообще. В этих случаях никакие значения управляющей переменной вообще не присваивались.

Дата добавления: 2015-08-08 ; просмотров: 529 ; ЗАКАЗАТЬ НАПИСАНИЕ РАБОТЫ

Как суммировать элементы вектора C++?

Что такое хороший способы нахождения суммы всех элементов std::vector ?

Предположим у меня есть вектор std::vector vector с несколькими элементами в нем. Теперь я хочу найти сумму всех элементов. Что такое разные способы для одного и того же?

8 ответов

на самом деле существует довольно много методов.

обычный цикл for:

используя стандартный алгоритм:

будьте осторожны с аккумулировать. тип последнего аргумента используется не только для начального значения, но и для типа результата. Если вы поместите туда int, он будет накапливать ints, даже если вектор имеет плыть. Если вы суммируете числа с плавающей запятой, измените 0 to 0.0 или 0.0f (спасибо nneonneo).

C++11 и выше

использование диапазона на основе цикла for (благодаря Роджеру Пейту):

Прасун уже предложил множество различных (и хороших) способов сделать это, ни один из которых не нужно повторять здесь. Однако я хотел бы предложить альтернативный подход к скорости.

Если вы собираетесь делать это совсем немного, вы можете рассмотреть вопрос о «подклассе» вашего вектора, чтобы сумма элементов поддерживалась отдельно (не на самом деле вектор подкласса, который является неопределенным из — за отсутствия виртуального деструктора- я говорю больше о классе, который содержит сумму и вектор внутри нее, has-a , а не is-a , и предоставляет векторные методы).

для пустого вектора сумма равна нулю. При каждой вставке в вектор добавьте вставляемый элемент в сумму. При каждом удалении вычтите его. В основном, что-нибудь, который может изменить базовый вектор, перехватывается, чтобы обеспечить согласованность суммы.

таким образом, у вас есть очень эффективный метод O (1) для «вычисления» сумма в любой момент времени (просто верните сумму, рассчитанную в данный момент). Вставка и удаление займет немного больше времени, как вы регулируете общую сумму, и вы должны принять во внимание эту производительность хит.

векторы, где сумма необходима чаще, чем вектор изменяется, являются теми, которые, вероятно, выиграют от этой схемы, так как стоимость расчета суммы амортизируется по всем доступам. Очевидно, если вам нужна только сумма каждый час, а вектор меняется на три тысячи раз в секунду, это не подходит.

что-то вроде этого было бы достаточно:

очевидно, что это псевдо-код и вам может потребоваться немного больше функциональности, но он показывает основную идею.

Зачем выполнять суммирование вперед, когда вы можете это сделать назад? Дано:

мы можем использовать знак, обратный отсчет:

мы можем использовать диапазон-проверено «знак,» обратный отсчет (на всякий случай):

мы можем использовать обратные итераторы в цикле for:

мы можем использовать прямые итераторы, итерации назад, в цикле for (oooh, tricky!):

мы можем использовать accumulate с обратными итераторами:

можно использовать for_each С лямбда-выражением с использованием обратных итераторов:

Итак, как вы можете видеть, существует столько же способов суммировать вектор назад, сколько и суммировать вектор вперед, и некоторые из них гораздо более увлекательны и предлагают гораздо больше возможностей для ошибок off-by-one.