accumulate() and partial_sum() in C++ STL

accumulate() and partial_sum() functions are used to find the sum or any other accumulated value that is obtained by doing the addition or any other binary operation on the elements in the given range. Both of these functions are the part of STL Numeric Library and defined inside <numeric> header.

std::accumulate()

The std::accumulate() function is used to find the sum (or any other binary operation) of all the values lying in a range.

Syntax

std::accumulate(first, last, init, op);

Parameters

• first: Iterator to the first element of the range.
• last: Iterator to the element one after the last element of the range.
• init: Initial value to start the accumulation with.
• op: An optional function pointer that provides the binary operation to perform. By default, addition is used to get the sum.

Return Value

• Returns the accumulated value after performing the operation on each element.

Examples of std::accumulate()

The below program illustrates how to use std::accumulate() functions in C++ program:

Example 1: Finding the Sum of All Elements of Vector Using std::accumulate()

// C++ program to demonstrate the use of std::accumulate function
#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<int> vec = { 5, 10, 15 };
  
  	// Defining range as whole array
  	auto first = vec.begin();
  	auto last = vec.end();

    // Use accumulate to find the sum of elements in the vector
    int sum = accumulate(first, last, 0);
  
    cout << sum << endl;

    return 0;
}

30

Example 2: Finding the Product of Vector Elements Using std::accumulate()

// C++ program to demonstrate the working of accumulate()
#include <bits/stdc++.h>
using namespace std;

// Custom function to multiply adjacent numbers
int op(int a, int b) {
    return a * b;
}

int main() {
    vector<int> vec = {5, 10, 15};
  
  	// Defining the range as whole array
  	auto first = vec.begin();
  	auto last = vec.end();
  
    // Using accumulate function with user-defined operation
  	int product = accumulate(first, last, 1, op);
  	
    cout << product;
    return 0;
}

750

Complexity Analysis of std::accumulate()

std::accumulates works by adding (or performing specified operation on) elements one by one. So, as long as the operation takes constant time, the time complexity will be linear.

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

Note: For adding larger values beyond the int range, the sum should be initialized with 0ll or any other value with the suffix ll, else the sum will be overflown. (here ll refers to long long int)

std::partial_sum()

std::partial_sum() function assigns the cumulative sum of all the set of values lying in the given range and stores it in another container at corresponding positions. Just like accumulate() function, we can modify the partial_sum() function to perform any other binary operation.

Syntax

std::partial_sum (first, last, res, op);

Parameters

• first: Iterator to the first element of the range
• last: Iterator to the last elements of range.
• res: iterator to the container (mostly vector) where partial sum will be stored.
• op: An optional function pointer that provides the binary operation to perform. By default, addition is used to get the sum.

Return Value

• Iterator to the imaginary element after the last element in the res container. (end iterator)

Example std::partial_sum()

The following program demonstrate how to use the partial_sum() sum in C++ program.

Example 1: Finding the Cumulative Sum of All Elements of Vector

// C++ program to demonstrate the use of std::partial_sum function
#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<int> vec = {5, 10, 15};
    vector<int> res(vec.size());
  
    // Defining range as the whole array
    auto first = vec.begin();
    auto last = vec.end();
  
    // Use partial_sum to calculate the cumulative sum of elements
    partial_sum(first, last, res.begin());

    for (int val : res)
        cout << val << " ";
    return 0;
}

5 15 30 

Example 2: Finding Cumulative Product of Vector Elements std::partial_sum()

// C++ program to demonstrate the working of partial_sum()
// with custom function
#include <bits/stdc++.h>
using namespace std;

// Custom function to multiply adjacent numbers
int op(int a, int b) {
    return a * b;
}

int main() {
    vector<int> vec = {5, 10, 15};
    vector<int> result(vec.size());
  
    // Defining the range as the whole array
    auto first = vec.begin();
    auto last = vec.end();
  
    // Using partial_sum with user-defined function (myfun)
    partial_sum(first, last, result.begin(), op);

    for (int val : result)
        cout << val << " ";
    return 0;
}

5 50 750 

Complexity Analysis of std::accumulate()

std::partial_sum() works in similar way as std::accumulate(). It adds (or performing specified operation) the elements one by one so as long as the operation takes constant time, the time complexity will be linear.

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