根据最小和查找数组的元素

Question

我用 C++ 编写了一个循环来给我 6 个随机数并将它们存储在一个数组中。 我想做的是对数组的元素求和，直到得到一个大于数字“x”的值，但我想这样做而不需要添加所有元素。 目标是找到第一个总和等于 x 值的元素。

例如，数组是 [1,2,3,4,5,6] 和 x = 6，所以我要寻找的是元素 [1,2,3]。

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

Answer 1

编写一个进行加法运算的函子。

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

Answer 2

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

如果是这样，我不知道如何在没有自己的循环的情况下做到这一点：

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

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

Answer 3

避免建议将 find_if 与有状态谓词一起使用的答案。 有状态谓词很危险，因为 STL 算法假定复制谓词是安全的。 在这种情况下，如果对谓词进行副本，则每个副本将具有不同的“运行总计”，并且不一定会作用于所有值或按正确的顺序。

特别要避免将其谓词的operator()成员实现为const成员函数但将其成员标记为可变的解决方案，因为这会欺骗您认为它不是有状态谓词，这是不好的。

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

请注意警告可能不适用于 C 数组和 find_if；我只是不想让您知道有状态谓词是解决您的问题的正确方法，因为您最终可能会在将来危险的情况下使用该错误的解决方案

。 ：C++ 编码标准：101 条规则、指南和最佳实践，第 87 项

Answer 4

这是一个稍微更通用的版本：

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

Answer 5

将 x 中的数字一一减去，直到达到 0 或更低。

没有添加，如你所愿：）

Answer 6

希望这能起作用：

/* 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;
}

Answer 7

会是这样的：

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

Answer 8

好吧，我会使用向量

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 需要运算符+和运算符< 被定义为。

Answer 9

您可以将 std::find_if() 与一个维护运行总计的函子一起使用，并且只有当您找到使您处于或超过顶部的元素时，才从函子返回 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;
}