通过一次传递存储数组块的总和

假设我有一个数组

1,2,3,4,5,6,7,8,9,10,11,12

如果我的chunk size = 4

那么我希望有一个方法可以输出一个int数组int[] a =

a[0] = 1
a[1] = 3
a[2] = 6
a[3] = 10
a[4] = 14
a[5] = 18
a[6] = 22
a[7] = 26
a[8] = 30
a[9] = 34
a[10] = 38
a[11] = 42

注意a[n] = a[n] + a[n-1] + a[n-2] + a[n-3]，因为块大小是4，所以我对最后4项求和

我需要有方法without嵌套循环

 for(int i=0; i<12; i++)
 {
     for(int k = i; k>=0 ;k--)
     {
         // do sumation
         counter++;
         if(counter==4)
           break;
     }
 }

我不想有这样的东西…为了使代码更高效

块大小也可能改变，所以我不能这样做:

a[3] = a[0] + a[1] + a[2] + a[3]

编辑

我问这个问题的原因是因为我需要为我的数据结构类实现校验和滚动。我基本上是打开一个文件来阅读。然后我就有了一个字节数组。然后我将对文件的部分执行哈希函数。假设这个文件是100字节。我把它分成10个字节的块。我对每个块执行一个哈希函数，因此我得到10个哈希值。然后我需要将这些哈希值与另一个类似的文件进行比较。假设第二个文件有同样的100个字节，但增加了5个字节，所以它总共包含105个字节。因为这些额外的字节可能在文件的中间如果我对第一个文件执行相同的算法它将不起作用。希望我的解释正确。因为有些文件很大。在我的算法中使用嵌套循环是不高效的。

实际上滚动哈希函数是非常复杂的。它们大多数都是用c++编写的，我很难理解它们。这就是为什么我想创建自己的哈希函数，非常简单，只是为了演示校验和滚动是如何工作的…

编辑2

        int chunckSize = 4;
        int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12 }; // the bytes of the file
        int[] b = new int[a.Length]; // array where we will place the checksums
        int[] sum = new int[a.Length]; // array needed to avoid nested loop
        for (int i = 0; i < a.Length; i++)
        {
            int temp = 0;
            if (i == 0)
            {
                temp = 1;
            }
            sum[i] += a[i] + sum[i-1+temp];
            if (i < chunckSize)
            {
                b[i] = sum[i];
            }
            else
            {
                b[i] = sum[i] - sum[i - chunckSize];
            }
        }

这个算法的问题是，对于大文件，总和在某一点上将大于int。最大，因此它不会工作....

但至少知道它更有效。摆脱嵌套循环帮助很大!

3

根据编辑二，我已经算出来了。它不适用于大文件，而且校验和算法非常糟糕。但至少我认为它解释了我试图解释的哈希滚动…

    Part1(@"A:'fileA.txt");
    Part2(@"A:'fileB.txt", null);

…

    // split the file in chuncks and return the checksums of the chuncks
    private static UInt64[] Part1(string file)
    {
        UInt64[] hashes = new UInt64[(int)Math.Pow(2, 20)];
        var stream = File.OpenRead(file);

        int chunckSize = (int)Math.Pow(2, 22); // 10 => kilobite   20 => megabite  30 => gigabite etc..
        byte[] buffer = new byte[chunckSize];
        int bytesRead;    // how many bytes where read
        int counter = 0;  // counter
        while ( // while bytesRead > 0
                    (bytesRead =
                        (stream.Read(buffer, 0, buffer.Length)) // returns the number of bytes read or 0 if no bytes read
                    ) > 0)
        {                
            hashes[counter] = 0;
            for (int i = 0; i < bytesRead; i++)
            {
                hashes[counter] = hashes[counter] + buffer[i]; // simple algorithm not realistic to perform check sum of file                    
            }
            counter++;
        }// end while loop     
        return hashes;
    }

    // split the file in chuncks rolling it. In reallity this file will be on a different computer..       
    private static void Part2(string file, UInt64[] hash)
    {            
        UInt64[] hashes = new UInt64[(int)Math.Pow(2, 20)];
        var stream = File.OpenRead(file);
        int chunckSize = (int)Math.Pow(2, 22); // chunks must be as big as in pervious method
        byte[] buffer = new byte[chunckSize];
        int bytesRead;    // how many bytes where read
        int counter = 0;  // counter
        UInt64[] sum = new UInt64[(int)Math.Pow(2, 20)];
        while ( // while bytesRead > 0
                    (bytesRead =
                        (stream.Read(buffer, 0, buffer.Length)) // returns the number of bytes read or 0 if no bytes read
                    ) > 0)
        {
            for (int i = 0; i < bytesRead; i++)
            {
                int temp = 0;
                if (counter == 0)
                    temp = 1;
                sum[counter] += (UInt64)buffer[i] + sum[counter - 1 + temp];
                if (counter < chunckSize)
                {
                    hashes[counter] = (UInt64)sum[counter];
                }else
                {
                    hashes[counter] = (UInt64)sum[counter] - (UInt64)sum[counter - chunckSize];
                }
                counter++;                    
            }

        }// end while loop
        // mising to compare hashes arrays
    }