C++ 增广算法

我正在寻找一种算法来实现以下行为。如果当前元素和后续元素的总和小于或等于前一个元素，则总和将添加到新向量。以下是一些例子：

例1：

例2：

例3：

---

下面的代码可以工作，但在某些情况下，此代码可能会失败。我很确定一个月后我会忘记自己代码的细节。我想使用一个可靠的代码。std或boost中是否有标准算法可以实现我提到的功能

#include<vector>
#include<iostream>

void augmented_sort(const std::vector<double>& invec, std::vector<double>& outvec)
{
    if (invec.empty()) return;

    outvec.push_back(invec[0]);

    auto augment = [&invec](double& current, double previous, int& ai)
    {
        if (ai >= invec.size()) return false;
        int start = ai;
        current = invec[ai];
        int ri = 1;

        while(true)
        {
            current += invec[start+ri];
            std::cout << "previous = " << previous << std::endl;
            std::cout << "current = " << current << std::endl;
            if (current <= previous)
            {
                ++ri; 
                ai += 2;
                std::cout << "ri = " << ri << std::endl;
                std::cout << "ai = " << ai << std::endl;
                if (start+ri >= invec.size())
                    return true;
            }
            else if (ai == start)
                return false;
            else
            {
                current -= invec[start+ri];
                return true;
            }
        }
    };

    int ai = 1; // absolute index. start from second element.
    double current; 
    double previous = invec[ai-1];

    while (ai < invec.size())
    {
        bool success = augment(current, previous, ai);
        if (success)
        {
            outvec.push_back(current);
            previous = current;
        }
        else
        {
            outvec.push_back(invec[ai]);
            previous = invec[ai];
            ai += 1;
        }
    }
}

int main ()
{
    //std::vector<double> invec = {17, 10, 6, 3, 2};
    //std::vector<double> invec = {41, 15, 10, 5, 2};
    std::vector<double> invec = {1, 1, 1, 1, 1};
    std::vector<double> outvec;
    augmented_sort(invec, outvec);
    for (double d: outvec)
        std::cout << "d = " << d << std::endl;
    return 0;
}

#包括
#包括
无效增广_排序（常量std:：vector和invec，std:：vector和outvec）
{
if（invec.empty（））返回；
输出向量推回（invec[0]）；
自动增广=[&invec]（双倍当前值、双倍先前值、整数和ai）
{
如果（ai>=invec.size（））返回false；
int start=ai；
电流=invec[ai]；
int ri=1；
while（true）
{
电流+=invec[start+ri]；
我可能错了，但你的问题似乎太小了，没有标准的算法

然而，这里有一些简单得多的代码，它涉及在输入向量上循环一次，同时跟踪当前和，如果将当前元素添加到输出向量中，则只将当前元素添加到输出向量中，将导致和大于添加的最后一个元素：

void augmented_sort(const std::vector<double>& input, std::vector<double>& output)
{
    if (input.empty())
        return;
    output.push_back(input[0]);
    int sum = 0;
    for (int i = 1; i < input.size(); i++)
    {
        if (sum + input[i] > output.back())
        {
            output.push_back(sum);
            sum = 0;
        }
        sum += input[i];
    }
    if (input.size() > 1)
        output.push_back(sum);
}

void增广排序（常量std:：vector&input，std:：vector&output）
{
if（input.empty（））
返回；
输出。推回（输入[0]）；
整数和=0；
对于（int i=1；ioutput.back（））
{
输出。推回（总和）；
总和=0；
}
总和+=输入[i]；
}
if（input.size（）>1）
输出。推回（总和）；
}

如果您想让它按降序处理向量以外的任何东西（如前所述，需求似乎没有明确说明预期的行为），则需要进行一些更改。
但可能会出现此代码失败的情况-单元测试在哪里？！：）@BartekBanachewicz我通过提供不同的输入向量来测试代码。
original vector: 1 | 1 | 1 | 1 | 1
new vector:      1 | 1 | 1 | 1 | 1

#include<vector>
#include<iostream>

void augmented_sort(const std::vector<double>& invec, std::vector<double>& outvec)
{
    if (invec.empty()) return;

    outvec.push_back(invec[0]);

    auto augment = [&invec](double& current, double previous, int& ai)
    {
        if (ai >= invec.size()) return false;
        int start = ai;
        current = invec[ai];
        int ri = 1;

        while(true)
        {
            current += invec[start+ri];
            std::cout << "previous = " << previous << std::endl;
            std::cout << "current = " << current << std::endl;
            if (current <= previous)
            {
                ++ri; 
                ai += 2;
                std::cout << "ri = " << ri << std::endl;
                std::cout << "ai = " << ai << std::endl;
                if (start+ri >= invec.size())
                    return true;
            }
            else if (ai == start)
                return false;
            else
            {
                current -= invec[start+ri];
                return true;
            }
        }
    };

    int ai = 1; // absolute index. start from second element.
    double current; 
    double previous = invec[ai-1];

    while (ai < invec.size())
    {
        bool success = augment(current, previous, ai);
        if (success)
        {
            outvec.push_back(current);
            previous = current;
        }
        else
        {
            outvec.push_back(invec[ai]);
            previous = invec[ai];
            ai += 1;
        }
    }
}

int main ()
{
    //std::vector<double> invec = {17, 10, 6, 3, 2};
    //std::vector<double> invec = {41, 15, 10, 5, 2};
    std::vector<double> invec = {1, 1, 1, 1, 1};
    std::vector<double> outvec;
    augmented_sort(invec, outvec);
    for (double d: outvec)
        std::cout << "d = " << d << std::endl;
    return 0;
}

void augmented_sort(const std::vector<double>& input, std::vector<double>& output)
{
    if (input.empty())
        return;
    output.push_back(input[0]);
    int sum = 0;
    for (int i = 1; i < input.size(); i++)
    {
        if (sum + input[i] > output.back())
        {
            output.push_back(sum);
            sum = 0;
        }
        sum += input[i];
    }
    if (input.size() > 1)
        output.push_back(sum);
}