基于最小和查找数组的元素 我在C++中写了一个循环，给我6个随机数，并把它们存储在一个数组中。 我想做的是对数组中的元素求和，直到得到一个大于数字“x”的值，但我想这样做，而不必将所有元素相加。目标是找到与x值相加的第一个元素

例如，数组是

[1,2,3,4,5,6]

和

x=6

，因此我要查找的是元素

[1,2,3]

---

我看过标准库，并尝试使用“valarray”中的sum函数，但这只是给出所有元素的和。任何关于如何成功编写此代码的想法都将不胜感激。

我假设您只需要数组中的前X个元素，直到它们的总和达到或超过阈值（这里的问题有点模糊）

如果是这样的话，我不知道如果没有你自己的循环怎么做：

int sum = 0;
int i = 0;
for( ; i < len; ++i ) {
    sum += array[i];
    if( sum >= 6 ) {
        break;
    }
}

int和=0；
int i=0；
对于（；i=6）{
打破
}
}

---

现在“i”包含了总和达到或超过阈值的索引。

好吧，我将使用向量

T addUntil(T array[],size_t len,T thres){
    vector<T> vec = vector_from_array(array,len)
    T sum;
    for (size_t i=0;i< vec.size(),sum<thresh;i++){
          sum+= vec[i];
    }
    return sum;
}

T addUntil（T数组[]，大小长度，T thres）{
vector vec=来自_数组的向量_（数组，len）
T和；
对于（size_t i=0；i
#include <algorithm>
struct SumToo
{
     SumToo(int val):m_val(val),m_sum(0) {}
     int m_val;
     int m_sum;

     bool operator()(int next)
     {
         m_sum += next;
         return m_sum >= m_val;
     }
 };

 int main()
 {
       int data[] = {1,2,3,4,5,6};

       int* find = std::find_if(data,data+6,SumToo(6));
 }

#包括
结构SumToo
{
SumToo（int val）：m_val（val），m_sum（0）{}
国际货币基金组织；
整数和；
布尔运算符（）（int-next）
{
m_sum+=下一个；
返回m_sum>=m_val；
}
};
int main（）
{
int数据[]={1,2,3,4,5,6}；
int*find=std:：find_if（数据，数据+6，SumToo（6））；
}
类似于：

struct StopAtValue{
  StopAtValue(int sum) : m_sum(sum), m_accumulated(0){}
  bool operator()(int val){
    m_accumulated += val;
    return m_accumulated >= sum;
  }
  int m_sum;
  int m_accumulated;
}


int* pos = std::find_if(&array[0], &array[n], StopAtValue(6));

您可以将std:：find_if（）与一个维护运行总数的functor一起使用，并且只有在找到使您处于或超过顶部的元素时，才从该functor中返回true

例如：

#include <cstdlib>
#include <algorithm>
#include <functional>
#include <iostream>
#include <string>
using namespace std;

// functor returns true when the running total >= findVal
struct running_total : public unary_function<int, bool>
{
    running_total(int findVal) : findVal_(findVal), runningTtl_(0) {};
    bool operator()(int rhs) const
    {
        runningTtl_ += rhs;
        if( runningTtl_ >= findVal_ )
            return true;
        else
            return false;
    }
private:
    mutable int runningTtl_;
    const int findVal_;
};

int main()
{

    int nums[] = {1, 2, 3, 4, 5, 6};
    size_t count = sizeof(nums)/sizeof(nums[0]);

    const int scanTtl = 6;  // running total to scan to
    int * pos = find_if(&nums[0], &nums[0]+count, running_total(scanTtl));

    cout << "Elements Totaling " << scanTtl << " : ";
    copy(&nums[0], pos+1, ostream_iterator<int>(cout, ", "));

    return 0;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
//当运行总数>=findVal时，functor返回true
结构运行总计：公共一元函数
{
running_total（int findVal）：findVal_（findVal），runningTtl_（0）{}；
布尔运算符（）（int rhs）常量
{
runningTtl_u+=rhs；
if（runningTtl\u>=findVal\uux）
返回true；
其他的
返回false；
}
私人：
可变整数运行TTL；
常数int findVal_2;；
};
int main（）
{
int nums[]={1,2,3,4,5,6}；
size_t count=sizeof（nums）/sizeof（nums[0]）；
const int scanTtl=6；//正在运行要扫描的总计
int*pos=find_if（&nums[0]，&nums[0]+计数，运行_总计（scanTtl））；
cout从x中一个接一个地减去数字，直到达到0或更低

如您所愿，没有添加内容：）
这里有一个更通用的版本：

#include <iostream>
#include <algorithm>

// return an iterator _Last such that sum 
// of all elements in the range [_First, _Last)
// satisfies the predicate Func
template<class InIt,
class Ty,
class Fn> inline
InIt accumulate_if(InIt First, InIt Last, Ty Val, Fn Func)
{   
    for (; Func(Val) && First != Last; ++First)
        Val = Val + *First;
    return (First);
}

int main() {
    int num[] = {1, 2, 3, 4, 5, 6};
    int *last = accumulate_if(num, num + sizeof num / sizeof num[ 0 ], 
                              0, std::bind2nd(std::less<int>(), 6));
    std::copy(num, last, std::ostream_iterator<int>(std::cout, "\n"));
    return 0;
}

#包括
#包括
//返回一个迭代器_Last，使之和
//范围[_First，_Last]中所有元素的
//满足谓词Func
模板内联
InIt累计_if（InIt First，InIt Last，Ty Val，Fn Func）
{   
for（；Func（Val）&&First！=Last；++First）
Val=Val+*第一；
返回（第一）；
}
int main（）{
int num[]={1,2,3,4,5,6}；
int*last=accumulate\u如果（num，num+sizeof num/sizeof num[0]，
0，std:：bind2nd（std:：less（），6））；
std:：copy（num，last，std:：ostream_迭代器（std:：cout，“\n”）；
返回0；
}
希望这能奏效：

/* Returns an index i, given array valarray[0,1..n] and number x where i is an index to valarry such that sum over j of valarray[j] for j = 0 to i > x */
int getFirstSum(int *valarray, int n, int x)
{
   int i = 0;
   int sum = x;
   while(sum > x && i < n)
   {
      i++;
      sum -= valarray[i];
   }
   return i;
}

/*返回一个索引i，给定数组valarray[0,1..n]和数字x，其中i是valarry的索引，使得j=0到i>x的valarray[j]的j上的和*/
int getFirstSum（int*valarray，int n，int x）
{
int i=0；
整数和=x；
而（总和>x&&i
避免使用建议将find_if与有状态谓词结合使用的答案。有状态谓词是危险的，因为STL算法假定复制谓词是安全的。在这种情况下，如果复制谓词，则每个谓词都将具有不同的“运行总数”，并且不一定对所有值都起作用，或者按照正确的顺序

尤其要避免将其谓词的operator（）成员实现为const成员函数，但将其成员标记为可变的解决方案，因为这会让您误以为它不是有状态谓词，这是不好的

我建议使用一个简单循环的答案，或者使用累加器的答案，因为这是最正确的方法（即使代码看起来有点笨拙）

请注意，这些警告可能不适用于C数组，如果您不知道有状态谓词是解决问题的正确方法，那么您可能会在将来遇到危险的情况下使用不正确的解决方案

参考文献：C++编码标准：101条规则，准则和最佳实践，第87项< /P> 10的“正确”答案是1, 4, 5还是2, 3, 5，还是4, 6？还是1, 2, 3，4？（我有没有错过？）你说随机数，但是数组是有序的，这有关系吗？它可以包含[10，8，51,3.1,1]吗？在哪种情况下，10>6，那么10就是答案？hi trotts，具体生成的数组的顺序很重要，但正如你提到的情况一样，10是正确的答案，因为它是获得等于或大于6的和的唯一可能的方法。每当我想到函子，我就更加轻视Java（目前的Java程序员：（）发问者想要一个大于x的值，而不是等于x.-1：谓词函子不应该有非静态数据字段（），或者我缺少什么吗？嗯，如果
不能保证执行顺序（标准25.1.2）。虽然我同意您的版本适用于大多数实现，但如果
find_if
没有按顺序进行，则会引入错误。以gcc的并行
find_if
（）为例：它划分了范围