Как суммировать массив целых чисел в C #

Есть ли более короткий способ, чем повторение массива?

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

пояснение:

Лучшее первичное означает более чистый код, но также приветствуются намеки на повышение производительности. (Как уже упоминалось: разбиение больших массивов).

Не то чтобы я искал убийственного улучшения производительности - я просто подумал, не существует ли еще такого синтаксического сахара : «Есть String.Join - какого черта насчет int []?».

При условии, что вы можете использовать .NET 3.5 (или новее) и LINQ, попробуйте

int sum = arr.Sum();

Да, есть. С .NET 3.5:

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

Если вы не используете .NET 3.5, вы можете сделать это:

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

С LINQ:

arr.Sum()

Это зависит от того, как вы определитесь лучше. Если вы хотите, чтобы код выглядел чище, вы можете использовать .Sum (), как указано в других ответах. Если вы хотите, чтобы операция выполнялась быстро и у вас есть большой массив, вы можете сделать его параллельным, разбив его на промежуточные суммы, а затем суммируя результаты.

Альтернативой также является использование Aggregate()метода расширения.

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

Если вы не предпочитаете LINQ, лучше использовать цикл foreach, чтобы избежать выхода из индекса.

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

Для очень больших массивов может потребоваться выполнение вычислений с использованием более чем одного процессора / ядра машины.

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

Одна из проблем с решениями цикла for выше заключается в том, что для следующего входного массива со всеми положительными значениями результат суммы отрицательный:

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

Сумма равна -2147483648, поскольку положительный результат слишком велик для типа данных int и принимает отрицательное значение.

Для того же входного массива предложения arr.Sum () вызывают исключение переполнения.

Более надежным решением является использование более крупного типа данных, такого как «длинный» в данном случае, для «суммы» следующим образом:

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

То же улучшение работает для суммирования других целочисленных типов данных, таких как short и sbyte. Для массивов беззнаковых целочисленных типов данных, таких как uint, ushort и byte, использование unsigned long (ulong) для суммы позволяет избежать исключения переполнения.

Решение цикла for также во много раз быстрее, чем Linq .Sum ()

Чтобы работать еще быстрее, пакет HPCsharp nuget реализует все эти версии .Sum (), а также версии SIMD / SSE и многоядерные параллельные версии, что во много раз увеличивает производительность.

Использование foreach было бы более коротким кодом, но, вероятно, выполняло бы точно такие же шаги во время выполнения после того, как оптимизация JIT распознает сравнение с длиной в управляющем выражении цикла for.

В одном из своих приложений я использовал:

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

Улучшение красивой многоядерной реализации Parallel.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;
    }

который работает для целочисленных типов данных без знака, поскольку C # поддерживает только Interlocked.Add () для int и long. Вышеупомянутая реализация также может быть легко изменена для поддержки других типов данных с целыми числами и с плавающей запятой для параллельного суммирования с использованием нескольких ядер ЦП. Он используется в пакете nuget HPCsharp.

Попробуйте этот код:

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

Результат:

23