Question

假设我有一个由n个元素组成的数组。

1 2 3 4 5 6 ... n

我需要找到一种方法来使用C ++提取此数组中连续元素的总和。像这样：

1, 2, 3,...n, 1+2, 2+3, 3+4,...(n-1)+n, 1+2+3, 2+3+4,...(n-2)+(n-1)+n,...1+2+3...n

到目前为止，我发现我需要通过在每次运行中对一定数量的元素求和来迭代这个数组。我不确定是否可以实现我上面解释的算法。可能有更好的解决方案，但这是我能想到的最佳解决方案。

Answer 1

您可以使用std::transform执行此操作：

std::transform(
    v.begin(), v.end()-1,
    v.begin()+1,
    std::ostream_iterator<int>(std::cout, "\n"),
    std::plus<int>()
);

当然你不必使用ostream_iterator作为它的输出，你也可以使用另一个容器迭代器，或std::back_inserter用于容器或任何其他OutputIterator

引用

http://en.cppreference.com/w/cpp/algorithm/transform

http://en.cppreference.com/w/cpp/utility/functional/plus

http://en.cppreference.com/w/cpp/container/vector

编辑：

std::vector<int> v(100), t;
//this just populates v with 1,2,3...100
std::iota(v.begin(), v.end(), 1);

std::transform(
    v.begin(), v.end()-1, v.begin()+1,
    std::back_inserter(t),
    std::plus<int>()
);

std::transform(
    t.begin(), t.end()-1, v.begin()+2,                
    std::ostream_iterator<int>(std::cout, "\n"),
    std::plus<int>()
);

Answer 2

让我们用4个元素检查案例：

{1,3,4,5, // from original array
 4,7,9, // sum of 2 consecutive elements
 8,12, // sum of 3
 13} // sum of 4

正如您所看到的，N sum数组的每个部分的大小都比原始数组低（N-1）。所以你需要大小的目标数组：N +（N-1）+（N-2）+ ... 1 - 这是N *（1 + N）/ 2

int* createSumArray(int* arr, int size)
{
   int ti = 0; // target index
   int* ta = new int[size*(size+1)/2];
   for (int s = 1; s <= size; ++s) // how many elements to sum
   {
      for (int si = 0; si < size + 1 - s; ++si)
      {
          ta[ti] = 0;
          for (int i = si; i < si + s; ++i)
            ta[ti] += arr[i];
          ++ti;
      } 
   }
   return ta;
}

请参阅ideone

上的测试

Answer 3

我认为这段代码可以满足您的要求：

int main()
{
    int ptr=0,i,j,k;
    int Ar[]={1,2,3,4,5,6,7,8,9,10,11,12,13};
    int n=13;
    int *Res;
    Res=(int*)calloc(n*(n+1)/2,sizeof(int));
    for(i=1;i<=n;i++) //tells about how many element's sum we need
    for(j=i;j<=n;j++)
    {
        for(k=0;k<i;k++)
        {      
               Res[ptr]+=Ar[j-i+k];
        }
        ptr++;
    }
    for(int x=0;x<ptr;x++)
    cout<<Res[x]<<"\t";
    return 0;
}

Answer 4

这是怎么回事。给定5个整数的数组：5,7,3,9,4


    void DoMaths (void)
    {
         int       iArray [] = { 5, 7, 3, 9, 4 } ;
         int       iSize = 5 ;

         int       iGroup ;
         int       iIndex ;
         int       iPass ;
         int       iResults ;
         int       iStart ;
         int       iSum ;

    // Init
         iGroup   = 1 ;
         iResults = iSize ;
    // Repeat for each pass
         for (iPass = 0 ; iPass < iSize ; iPass ++)
         {
              printf ("\n") ;
              printf ("Pass %d : Group %d :\n", iPass, iGroup) ;
         // Repeat for each group of integers in a pass
              for (iStart = 0 ; iStart < iResults ; iStart ++)
              {
                   iSum = 0 ;
                   printf ("  %d [ ", iStart) ;
                   for (iIndex = iStart ; iIndex < (iStart + iGroup) ; iIndex ++)
                   {
                        printf ("%d ", iIndex) ;
                        iSum += iArray [iIndex] ;
                   }
                   printf ("] sum = %d \n", iSum) ;
              }
              iGroup ++ ;
              iResults -- ;
         }
         return ;
    }

这会产生以下结果......


    Pass 0 : Group 1 :
      0 [ 0 ] sum = 5
      1 [ 1 ] sum = 7
      2 [ 2 ] sum = 3
      3 [ 3 ] sum = 9
      4 [ 4 ] sum = 4

    Pass 1 : Group 2 :
      0 [ 0 1 ] sum = 12
      1 [ 1 2 ] sum = 10
      2 [ 2 3 ] sum = 12
      3 [ 3 4 ] sum = 13

    Pass 2 : Group 3 :
      0 [ 0 1 2 ] sum = 15
      1 [ 1 2 3 ] sum = 19
      2 [ 2 3 4 ] sum = 16

    Pass 3 : Group 4 :
      0 [ 0 1 2 3 ] sum = 24
      1 [ 1 2 3 4 ] sum = 23

    Pass 4 : Group 5 :
      0 [ 0 1 2 3 4 ] sum = 28

我希望这会有所帮助......

Answer 5

让我们调用原始数组A.

让我们调用k个连续元素B的和的数组。

让我们调用k + 1个连续元素C的和的数组。

每个数组的大小为n。

C的第一个k-2细胞是不相关的。

for(int i = k-1; i < n; i++)
    C[i] = A[i-1] + B[i];

将每个k的上述代码迭代到n，并在每次传递之后将结果数组连接到前一次迭代的结果。（确保检查角落情况）

Answer 6

看到它在ideone.com工作：

std::vector<std::vector<int> > sums(int array[], int size)
{
        std::vector<std::vector<int> > result(size - 1);
        //build the two element sums
        for(int *p = array; p - array < size - 1; ++p)
                result[0].push_back(std::accumulate(p, p + 2, 0));
        //build the rest of the sums
        for(int i = 1; i < size - 1; ++i)
                for(int j = 0; j < size - (i + 1); ++j)
                        result[i].push_back(result[i - 1][j] + array[i + j + 1]);
        return result;
}

这也应该使用先前计算的总和。

数组中连续元素的总和，C ++

6 个答案:

引用