Come riassumere una matrice di numeri interi in C #

Esiste un modo più breve migliore dell'iterazione sull'array?

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

una precisazione:

Primaria migliore significa codice più pulito, ma sono ben accetti anche suggerimenti sul miglioramento delle prestazioni. (Come già accennato: divisione di grandi array).

Non è che stavo cercando un miglioramento delle prestazioni killer - Mi chiedevo solo se questo tipo di zucchero sintattico non fosse già disponibile: "C'è String.Join - che diamine int []?".

A condizione che sia possibile utilizzare .NET 3.5 (o più recente) e LINQ, provare

int sum = arr.Sum();

Si C'è. Con .NET 3.5:

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

Se non stai usando .NET 3.5 puoi farlo:

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

Con LINQ:

arr.Sum()

Dipende da come definisci meglio. Se vuoi che il codice appaia più pulito, puoi usare .Sum () come menzionato in altre risposte. Se si desidera che l'operazione venga eseguita rapidamente e si dispone di un ampio array, è possibile renderlo parallelo suddividendolo in somme secondarie e quindi sommare i risultati.

Un'alternativa anche per usare il Aggregate()metodo dell'estensione.

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

Se non si preferisce LINQ, è preferibile utilizzare il ciclo foreach per evitare di uscire dall'indice.

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

Per array estremamente grandi può essere necessario eseguire il calcolo utilizzando più di un processore / core della macchina.

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

Un problema con le soluzioni del ciclo for sopra è che per il seguente array di input con tutti i valori positivi, il risultato della somma è negativo:

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

La somma è -2147483648, poiché il risultato positivo è troppo grande per il tipo di dati int e supera un valore negativo.

Per lo stesso array di input, i suggerimenti arr.Sum () causano la generazione di un'eccezione di overflow.

Una soluzione più robusta consiste nell'utilizzare un tipo di dati più grande, ad esempio "lungo" in questo caso, per la "somma" come segue:

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

Lo stesso miglioramento funziona per la somma di altri tipi di dati interi, come short e sbyte. Per array di tipi di dati interi senza segno come uint, ushort e byte, l'utilizzo di un lungo senza segno (ulong) per la somma evita l'eccezione di overflow.

La soluzione del ciclo for è anche molte volte più veloce di Linq .Sum ()

Per funzionare ancora più velocemente, il pacchetto HPCsharp nuget implementa tutte queste versioni .Sum () così come le versioni SIMD / SSE e parallele multi-core, per prestazioni molte volte più veloci.

L'utilizzo di foreach sarebbe un codice più breve, ma probabilmente eseguire esattamente gli stessi passaggi in fase di esecuzione dopo che l'ottimizzazione JIT ha riconosciuto il confronto con Length nell'espressione di controllo del ciclo for.

In una delle mie app ho usato:

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

Un miglioramento della simpatica implementazione parallela multi-core di Theodor Zoulias.ForEach:

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

che funziona per i tipi di dati interi senza segno, poiché C # supporta solo Interlocked.Add () per int e long. L'implementazione di cui sopra può anche essere facilmente modificata per supportare altri tipi di dati interi e in virgola mobile per eseguire la somma in parallelo utilizzando più core della CPU. Viene utilizzato nel pacchetto nuget HPCsharp.

Prova questo codice:

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

Il risultato è:

23