calculate the biggest sum of consecutive Elements ( in a list) - c++

Question

I'm trying to calculate the biggest sum of consecutive elements of a vector<int>, but I don't really know how to do:
I started to code that:
#include <iostream>
#include <vector>
using namespace std;
void calcule_somme(vector<int> tab);
void calcule_somme(vector<int> tab) {
int somme_partielle(0);
vector<int> element_les_plusgrand;
for(size_t i(0);tab.size();++i) {
for(size_t j(i+1);tab.size();++i) {
element_les_plusgrand.pushback(tab[i]);
if (tab[i]+tab[j]>compteur) {
element_les_plusgrand.push_back(tab[j]);
compteur = tab[i]+tab[j];
}
}
int main() {
return 0;
}
The function has to return: the biggest sum of consecutive element is "4,5,78" which is equal to 87.

Answer 1

#include <iostream>
#include <vector>
using namespace std;
int sum(const vector<int>& tab) {
int sum = 0;
for (size_t i = 0; i < tab.size(); i++) {
sum += tab[i];
}
return sum;
}
vector<int> calculate_sume(const vector<int>& tab) {
vector<int> ret, current;
int previous = -32767;
for (size_t i = 0; i < tab.size(); i++) {
if ((tab[i] > previous) == false) {
if (current.size() >= ret.size() && sum(current) > sum(ret))
ret = current;
current.clear();
}
current.push_back(tab[i]);
previous = tab[i];
}
for(size_t w(0);w<ret.size();++w) {
cout << ret[w]<< " ";
}
return ret;
}
int main() {
vector<int> tab ={-4,5,6,-9,24,-35,4,5,78};
sum(tab);
calculate_sume(tab);
return 0;
}
Tell me -4 5 6

Answer 2

First off, you'll need to keep track of two vectors, one to hold the largest sequence of characters and one to hold the values that currently being calculated.
From there, you just need to iterate through the elements in the source vector keeping track of the previous and current value in the vector.
If the current value is greater than the previous value, you push the current value into the current vector and then assign the previous value to the current value.
If it's less than (or I'm assuming equal), the consecutive sequence is completed and you should start with the next sequence. This means that you need to do the following:
Determine if the current vector's size is greater than or equal the largest vector's size and the sum of the current vector is greater than the sum of the largest. If it is, assign largest = current;
Clear the current list
Assign previous to the current int value.
Here is how I would write it:
int sum(const vector<int>& tab) {
int sum = 0;
for (size_t i = 0; i < tab.size(); i++) {
sum += tab[i];
}
return sum;
}
vector<int> calculate_some(const vector<int>& tab) {
vector<int> ret, current;
int previous = tab[0];
current.push_back(previous);
for (size_t i = 1; i < tab.size(); i++) {
current.push_back(tab[i]);
if (tab[i] <= previous || i == (tab.size() - 1)) {
if (current.size() >= ret.size() && sum(current) > sum(ret))
ret = current;
current.clear();
}
previous = tab[i];
}
return ret;
}
And here is how I am calling it:
int main() {
vector<int> tab = { -4,5,6,-9,24,-35,4,5,78 };
vector<int> results = calculate_some(tab);
for (size_t w(0); w<results.size(); ++w) {
cout << results[w] << " ";
}
system("pause");
return 0;
}

Answer 3

pseudocode:
Algorithm Biggest_Consecutive_Sum
Input: Vector v
Output: Biggest_Sum
begin
index = 0, Biggest_Sum = 0
while(index < v.size()){
Sum = 0
while (Sum + V[index] > Sum){
Sum = Sum + V[index]
index = index + 1
}
if(Sum > Biggest_Sum) Biggest_Sum = Sum
index = index + 1
}
return Biggest_Sum
end