找到的阵列的基于最小总和的元素

StackOverflow https://stackoverflow.com/questions/853007

  •  21-08-2019
  •  | 
  •  

题

我已经写在C环++给我6张随机数，并将它们存储在数组中。  我想要做的就是总结数组中的元素，直到我得到的值大于一个数字，“×”更大，但我想这样做，而不必添加的所有元素。的目标是找到所述第一元件，其总和x的值。

例如，阵列是[1,2,3,4,5,6]，和x = 6，所以我要寻找这样的元件[1,2,3]。

我已经看过了标准库，并使用由“valarray的” SUM函数都试过，但是这只是给所有元素的总和。关于如何成功编码任何想法，将不胜感激。

有帮助吗？

解决方案

写算符，做加法。

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

其他提示

我假设你只是想数组中的第一X元素，直到它们的和达到或超过阈值（问题是有点模糊那里）。

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

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

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

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

特别是避免了实现它的谓词的操作者（）成员作为const成员函数但是它的标记成员可变，因为这是欺骗你以为它是不是一个有状态的谓词，这是不好的溶液中。

我建议使用简单的循环，以找到答案的答案中的任意一个，或使用蓄能器的答案，因为这是做的（即使代码看起来有点笨拙的最正确的方法。

请注意的警告可能并不适用于C数组和find_if;我只是不想让你学的是状态谓词是解决你的问题，因为你可能最终使用的情况下不正确的解决方案，它在未来的危险正确的方式。

参考：C ++编码标准：101条规则，准则，和最佳实践，项目87

下面是一个稍微更宽泛的版本：

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

减去 X 的数字逐个，直到达到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;
}

会是这样的：

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

好了，我会用一个矢量

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公司将需要操作者+和操作员<被定义。

您可以与保持运行的总仿函数一起使用std :: find_if（），只有真正returtn从当你发现你置身于或过顶元素的仿函数。

例如：

#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;
}
许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top