Thêm các phần tử của một mảng

Question

Tôi có một mảng mười phần tử của các số nguyên. Tôi muốn tổng hợp các phần tử theo nhóm, ví dụ: tôi muốn thêm giá trị ở phần tử 0 với giá trị ở phần tử 1, sau đó với giá trị ở phần tử 2, rồi 3, v.v ... đến phần tử 9, sau đó thêm giá trị tại phần tử 1 với giá trị là 2,3, đến 9 cho đến khi mỗi nhóm của 2 giá trị được thêm vào với nhau và được lưu trữ trong một biến. Sau đó tôi muốn lặp lại quá trình với các nhóm 3, các nhóm 4, 5, tất cả các cách thức thông qua đến nhóm 10. Mỗi tổng số kết quả được lưu trữ trong một biến riêng biệt. Như vậy đến nay cách duy nhất tôi có thể tìm ra cách để làm điều đó là như sau: -

int i = 0; 
int p = 1; 
int q = 2; 
int r = 3; 

while (i < NumArray.Length - 3) 
{ 
    while (p < NumArray.Length - 2) 
    { 
     while (q < NumArray.Length-1) 
     { 
      while (r < NumArray.Length) 
      { 
       foursRet += NumArray[i] + NumArray[p] + NumArray[q]+ NumArray[r]; 
       r++; 
      } 
      q++; 
      r = q + 1; 
     } 
     p++; 
     q = p + 1; 
     r = q + 1; 
    } 
    i++; 
    p = i + 1; 
    q = i + 2; 
    r = i + 3; 
} 

Trên đây là một ví dụ về nhóm tổng hợp của 4. tôi đã tự hỏi nếu có ai có thể loại, đủ để cho tôi một ít tiết kiệm và tao nhã hơn để đạt được những gì tôi muốn. Cảm ơn nhiều.

Answer 1

Bởi vì tất cả những gì là tốt hơn với LINQ *:

using System; // Output is below 
using System.Linq; 
using System.Diagnostics; 

namespace ConsoleApplication1 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var inputArray = Enumerable.Range(0, 10).ToArray(); 

      var grouped = 
       from Buckets in Enumerable.Range(1, inputArray.Length) 
       from IndexInBucket in Enumerable.Range(0, inputArray.Length/Buckets) 
       let StartPosInOriginalArray = IndexInBucket * Buckets 
       select new 
       { 
        BucketSize = Buckets, 
        BucketIndex = StartPosInOriginalArray, 
        Sum = inputArray.Skip(StartPosInOriginalArray).Take(Buckets).Sum() 
       }; 

      foreach (var group in grouped) 
      { 
       Debug.Print(group.ToString()); 
      } 

      Console.ReadKey(); 
     } 
    } 
} // SCROLL FOR OUTPUT 

{ BucketSize = 1, BucketIndex = 0, Sum = 1 } 
{ BucketSize = 1, BucketIndex = 1, Sum = 2 } 
{ BucketSize = 1, BucketIndex = 2, Sum = 3 } 
{ BucketSize = 1, BucketIndex = 3, Sum = 4 } 
{ BucketSize = 1, BucketIndex = 4, Sum = 5 } 
{ BucketSize = 1, BucketIndex = 5, Sum = 6 } 
{ BucketSize = 1, BucketIndex = 6, Sum = 7 } 
{ BucketSize = 1, BucketIndex = 7, Sum = 8 } 
{ BucketSize = 1, BucketIndex = 8, Sum = 9 } 
{ BucketSize = 1, BucketIndex = 9, Sum = 10 } 
{ BucketSize = 2, BucketIndex = 0, Sum = 3 } 
{ BucketSize = 2, BucketIndex = 2, Sum = 7 } 
{ BucketSize = 2, BucketIndex = 4, Sum = 11 } 
{ BucketSize = 2, BucketIndex = 6, Sum = 15 } 
{ BucketSize = 2, BucketIndex = 8, Sum = 19 } 
{ BucketSize = 3, BucketIndex = 0, Sum = 6 } 
{ BucketSize = 3, BucketIndex = 3, Sum = 15 } 
{ BucketSize = 3, BucketIndex = 6, Sum = 24 } 
{ BucketSize = 4, BucketIndex = 0, Sum = 10 } 
{ BucketSize = 4, BucketIndex = 4, Sum = 26 } 
{ BucketSize = 5, BucketIndex = 0, Sum = 15 } 
{ BucketSize = 5, BucketIndex = 5, Sum = 40 } 
{ BucketSize = 6, BucketIndex = 0, Sum = 21 } 
{ BucketSize = 7, BucketIndex = 0, Sum = 28 } 
{ BucketSize = 8, BucketIndex = 0, Sum = 36 } 
{ BucketSize = 9, BucketIndex = 0, Sum = 45 } 
{ BucketSize = 10, BucketIndex = 0, Sum = 55 } 

---

^{* Không phải mọi thứ là tốt hơn với LINQ}

Answer 2

Nếu tôi hiểu bạn một cách chính xác bạn có một mảng các số với chiều dài n. Bạn muốn chọn tất cả các kết hợp của số m từ số này. Sau đó, bạn muốn tổng hợp tất cả các kết hợp này và cuối cùng tính tổng của các khoản tiền này.

Ví dụ cho n = 6 số bạn có thể chọn m = 4 yếu tố trong 15 cách khác nhau (các con số là chỉ số trong mảng các số):

 
0 1 2 3 
0 1 2 4 
0 1 3 4 
0 2 3 4 
1 2 3 4 
0 1 2 5 
0 1 3 5 
0 2 3 5 
1 2 3 5 
0 1 4 5 
0 2 4 5 
1 2 4 5 
0 3 4 5 
1 3 4 5 
2 3 4 5 

Nếu n < 32 (không quá 31 con số trong mảng của bạn), bạn có thể tạo ra các chỉ số một cách hiệu quả bằng cách sử dụng số học 32 bit. Các chức năng sau đây được dựa trên Gosper's hack:

IEnumerable<UInt32> GetIndexBits(Int32 m, Int32 n) { 
    unchecked { 
    var i = (UInt32) (1 << m) - 1; 
    var max = (UInt32) (1 << n);; 
    while (i < max) { 
     yield return i; 
     var u = (UInt32) (i & -i); 
     var v = u + i; 
     i = v + (((v^i)/u) >> 2); 
    } 
    } 
} 

Với m = 4 và n = 6 chức năng này sẽ tạo ra những con số (hiển thị dưới dạng nhị phân):

 
001111 
010111 
011011 
011101 
011110 
100111 
101011 
101101 
101110 
110011 
110101 
110110 
111001 
111010 
111100 

Sau đó bạn có thể tạo ra số tiền sử dụng LINQ:

var m = 4; 
var numbers = new[] { 1, 2, 3, 4, 5, 6 }; 
var sum = GetIndexBits(4, numbers.Length) 
    .Select(
    bits => Enumerable 
     .Range(0, numbers.Length) 
     .Where(i => ((1 << i) & bits) != 0) 
) 
    .Select(indices => indices.Sum(i => numbers[i])) 
    .Sum(); 

Với đầu vào được cung cấp, tổng số sẽ là 210, kết quả tương tự là foursRet trong th e câu hỏi khi NumArray chứa các số từ 1 đến 6.