C # 'da bir tamsayı dizisi nasıl toplanır

Dizi üzerinde yinelemekten daha kısa bir yol var mı ?

int[] arr = new int[] { 1, 2, 3 };
int sum = 0;
for (int i = 0; i < arr.Length; i++)
{
    sum += arr[i];
}

açıklama:

Daha iyi birincil, daha temiz kod anlamına gelir, ancak performans iyileştirme ipuçları da memnuniyetle karşılanır. (Daha önce bahsedildiği gibi: büyük dizileri bölmek).

Öldürücü performans iyileştirmesi aradığımdan değil - sadece bu tür bir sözdizimsel şekeri zaten mevcut olup olmadığını merak ettim : "String.Join var - int [] ne halt ediyor?".

NET 3.5 (veya daha yenisi) ve LINQ kullanabilmeniz koşuluyla, deneyin

int sum = arr.Sum();

Evet var. .NET 3.5 ile:

int sum = arr.Sum();
Console.WriteLine(sum);

.NET 3.5 kullanmıyorsanız, bunu yapabilirsiniz:

int sum = 0;
Array.ForEach(arr, delegate(int i) { sum += i; });
Console.WriteLine(sum);

LINQ ile:

arr.Sum()

Nasıl daha iyi tanımladığına bağlı. Kodun daha temiz görünmesini istiyorsanız, diğer yanıtlarda belirtildiği gibi .Sum () kullanabilirsiniz. İşlemin hızlı çalışmasını istiyorsanız ve büyük bir diziniz varsa, onu alt toplamlara bölerek paralel hale getirebilir ve ardından sonuçları toplayabilirsiniz.

Bir alternatif de Aggregate()uzantı yöntemini kullanmaktır .

var sum = arr.Aggregate((temp, x) => temp+x);

LINQ'yu tercih etmiyorsanız, indeks dışı kalmamak için foreach döngüsünü kullanmak daha iyidir.

int[] arr = new int[] { 1, 2, 3 };
int sum = 0;
foreach (var item in arr)
{
   sum += item;
}

Çok büyük diziler için, hesaplamayı makinenin birden fazla işlemcisi / çekirdeği kullanarak gerçekleştirmek faydalı olabilir.

long sum = 0;
var options = new ParallelOptions()
    { MaxDegreeOfParallelism = Environment.ProcessorCount };
Parallel.ForEach(Partitioner.Create(0, arr.Length), options, range =>
{
    long localSum = 0;
    for (int i = range.Item1; i < range.Item2; i++)
    {
        localSum += arr[i];
    }
    Interlocked.Add(ref sum, localSum);
});

Yukarıdaki for döngüsü çözümleriyle ilgili bir sorun, tüm pozitif değerlere sahip aşağıdaki giriş dizisi için toplam sonucun negatif olmasıdır:

int[] arr = new int[] { Int32.MaxValue, 1 };
int sum = 0;
for (int i = 0; i < arr.Length; i++)
{
    sum += arr[i];
}
Console.WriteLine(sum);

Pozitif sonuç int veri türü için çok büyük olduğundan ve negatif bir değere taştığından, toplam -2147483648'dir.

Aynı girdi dizisi için arr.Sum () önerileri, bir taşma istisnasının atılmasına neden olur.

Daha sağlam bir çözüm, aşağıdaki gibi "toplam" için "uzun" gibi daha büyük bir veri türü kullanmaktır:

int[] arr = new int[] { Int32.MaxValue, 1 };
long sum = 0;
for (int i = 0; i < arr.Length; i++)
{
    sum += arr[i];
}

Aynı iyileştirme, kısa ve sbyte gibi diğer tamsayı veri türlerinin toplamı için de işe yarar. Uint, ushort ve bayt gibi işaretsiz tamsayı veri türlerinin dizileri için, toplam için işaretsiz uzun (ulong) kullanmak taşma istisnasını önler.

Ayrıca for döngüsü çözümü, Linq .Sum () 'dan birçok kez daha hızlıdır.

Daha da hızlı çalıştırmak için, HPCsharp nuget paketi, tüm bu .Sum () sürümlerinin yanı sıra SIMD / SSE sürümlerini ve çok çekirdekli paralel sürümleri birçok kez daha hızlı performans için uygular.

Foreach'i kullanmak daha kısa bir kod olurdu, ancak muhtemelen JIT optimizasyonu for-loop kontrol ifadesinde Length ile karşılaştırmayı tanıdıktan sonra çalışma zamanında tam olarak aynı adımları uygulayın.

Kullandığım uygulamalarımdan birinde:

public class ClassBlock
{
    public int[] p;
    public int Sum
    {
        get { int s = 0;  Array.ForEach(p, delegate (int i) { s += i; }); return s; }
    }
}

Theodor Zoulias'ın güzel çok çekirdekli Parallel.ForEach uygulamasında bir gelişme:

    public static ulong SumToUlongPar(this uint[] arrayToSum, int startIndex, int length, int degreeOfParallelism = 0)
    {
        var concurrentSums = new ConcurrentBag<ulong>();

        int maxDegreeOfPar = degreeOfParallelism <= 0 ? Environment.ProcessorCount : degreeOfParallelism;
        var options = new ParallelOptions() { MaxDegreeOfParallelism = maxDegreeOfPar };

        Parallel.ForEach(Partitioner.Create(startIndex, startIndex + length), options, range =>
        {
            ulong localSum = 0;
            for (int i = range.Item1; i < range.Item2; i++)
                localSum += arrayToSum[i];
            concurrentSums.Add(localSum);
        });

        ulong sum = 0;
        var sumsArray = concurrentSums.ToArray();
        for (int i = 0; i < sumsArray.Length; i++)
            sum += sumsArray[i];

        return sum;
    }

C # yalnızca int ve long için Interlocked.Add () 'yi desteklediğinden, işaretsiz tamsayı veri türleri için çalışır. Yukarıdaki uygulama, CPU'nun birden çok çekirdeğini kullanarak paralel olarak toplama yapmak için diğer tamsayı ve kayan noktalı veri türlerini desteklemek için kolayca değiştirilebilir. HPCsharp nuget paketinde kullanılır.

Bu kodu deneyin:

using System;

namespace Array
{
    class Program
    {
        static void Main()
        {
            int[] number = new int[] {5, 5, 6, 7};

            int sum = 0;
            for (int i = 0; i <number.Length; i++)
            {
                sum += number[i];
            }
            Console.WriteLine(sum);
        }
    }
} 

Sonuç:

23