Як підбити підсумок масиву цілих чисел у 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];
}

Це ж вдосконалення працює для підсумовування інших цілих типів даних, таких як короткий та sbyte. Для масивів непідписаних цілих типів даних, таких як uint, ushort та byte, використовуючи неподписаний довгий (ulong) для суми, уникає виключення переповнення.

Рішення for циклу також у багато разів швидше, ніж Linq .Sum ()

Щоб запустити ще швидше, пакет нугетів HPCsharp реалізує всі ці версії .Sum (), а також SIMD / SSE версії та багатоядерні паралельні, у багато разів більшу продуктивність.

Використання foreach було б коротшим кодом, але, ймовірно, робити точно такі ж кроки під час виконання після того, як оптимізація JIT розпізнає порівняння з Length у виразі, що контролює for-цикл.

В одному зі своїх додатків я використовував:

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

Вдосконалення щодо приємної багатоядерної паралельної програми Teodor Zoulias. Для кожного виконання:

    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. Вищевказана реалізація також може бути легко модифікована для підтримки інших типів даних з цілими числами і плаваючою комою, щоб робити підсумовування паралельно з використанням декількох ядер ЦП. Він використовується в пакеті нугетів 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