Jak podsumować tablicę liczb całkowitych w C #

Czy istnieje lepszy krótszy sposób niż iterowanie po tablicy?

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

wyjaśnienie:

Lepszy podstawowy oznacza czystszy kod, ale wskazówki dotyczące poprawy wydajności są również mile widziane. (Jak już wspomniano: dzielenie dużych tablic).

To nie tak, że szukałem zabójczej poprawy wydajności - po prostu zastanawiałem się, czy ten rodzaj cukru syntaktycznego nie był już dostępny: „Jest String.Join - co do cholery z int []?”.

Pod warunkiem, że możesz używać .NET 3.5 (lub nowszego) i LINQ, wypróbuj

int sum = arr.Sum();

Tak jest. Z .NET 3.5:

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

Jeśli nie używasz .NET 3.5, możesz to zrobić:

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

Z LINQ:

arr.Sum()

To zależy od tego, jak lepiej zdefiniujesz. Jeśli chcesz, aby kod wyglądał bardziej czytelnie, możesz użyć .Sum (), jak wspomniano w innych odpowiedziach. Jeśli chcesz, aby operacja przebiegała szybko i masz dużą tablicę, możesz ją wykonać równolegle, dzieląc ją na sumy częściowe, a następnie zsumuj wyniki.

Alternatywą jest również użycie Aggregate()metody rozszerzenia.

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

Jeśli nie wolisz LINQ, lepiej jest użyć pętli foreach, aby uniknąć braku indeksu.

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

W przypadku bardzo dużych tablic może się opłacić wykonanie obliczeń przy użyciu więcej niż jednego procesora / rdzeni maszyny.

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

Jednym z problemów z powyższymi rozwiązaniami pętli for jest to, że dla następującej tablicy wejściowej ze wszystkimi dodatnimi wartościami suma wyników jest ujemna:

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

Suma wynosi -2147483648, ponieważ wynik dodatni jest zbyt duży dla typu danych int i powoduje przepełnienie do wartości ujemnej.

Dla tej samej tablicy wejściowej sugestie arr.Sum () powodują zgłoszenie wyjątku przepełnienia.

Bardziej niezawodnym rozwiązaniem jest użycie większego typu danych, takiego jak „long” w tym przypadku, dla „sumy” w następujący sposób:

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

To samo ulepszenie działa w przypadku sumowania innych typów danych całkowitych, takich jak short i sbyte. W przypadku tablic liczb całkowitych bez znaku, takich jak uint, ushort i bajt, użycie długości bez znaku (ulong) dla sumy pozwala uniknąć wyjątku przepełnienia.

Rozwiązanie pętli for jest również wielokrotnie szybsze niż Linq .Sum ()

Aby działać jeszcze szybciej, pakiet nuget HPCsharp implementuje wszystkie te wersje .Sum (), a także wersje SIMD / SSE i wielordzeniowe wersje równoległe, co zapewnia wielokrotnie wyższą wydajność.

Użycie foreach byłoby krótszym kodem, ale prawdopodobnie wykonaj dokładnie te same kroki w czasie wykonywania po tym, jak optymalizacja JIT rozpozna porównanie z długością w wyrażeniu sterującym pętli for.

W jednej z moich aplikacji użyłem:

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

Ulepszenie ładnej wielordzeniowej implementacji równoległej Theodora Zouliasa.

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

który działa dla typów danych całkowitych bez znaku, ponieważ C # obsługuje tylko Interlocked.Add () dla int i long. Powyższą implementację można również łatwo zmodyfikować, aby obsługiwała inne typy danych całkowitoliczbowych i zmiennoprzecinkowych, aby wykonywać sumowanie równolegle przy użyciu wielu rdzeni procesora. Jest używany w pakiecie nuget HPCsharp.

Wypróbuj ten kod:

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

Wynik to:

23