The sum of an array is the result of adding every element once. This is the classic accumulator pattern: start at 0, then total += value for each item.
total = 0
+ 1 → total = 1
+ 2 → total = 3
+ 3 → total = 6
+ 4 → total = 10
+ 5 → total = 15
Sum = 15
Code
C# Programs
Start with a fixed array and a simple helper. Then read values from input, and finish by tracing a running total with negatives.
Example 1 — Sum of a Fixed Array
Use foreach to add every element into an accumulator.
C#
using System;
class Program
{
static int SumArray(int[] arr)
{
int total = 0;
foreach (int value in arr)
{
total += value;
}
return total;
}
static void Main()
{
int[] array = { 1, 2, 3, 4, 5 };
Console.WriteLine("Sum of the array elements: " + SumArray(array));
}
}
Output
Sum of the array elements: 15
How It Works
total starts at 0.
foreach visits 1, 2, 3, 4, then 5.
Each visit does total += value.
The running values are 1, 3, 6, 10, then 15.
Return the final total after the loop.
Example 2 — Sum with User Input
Read n, fill an array, then reuse the same summing helper.
C#
using System;
class Program
{
static int SumArray(int[] arr)
{
int total = 0;
foreach (int value in arr)
{
total += value;
}
return total;
}
static void Main()
{
Console.Write("Enter number of elements: ");
int n = int.Parse(Console.ReadLine());
if (n < 0)
{
throw new ArgumentException("n must be nonnegative.");
}
int[] arr = new int[n];
for (int i = 0; i < n; i++)
{
Console.Write("Enter element " + (i + 1) + ": ");
arr[i] = int.Parse(Console.ReadLine());
}
Console.WriteLine("Sum of the array elements: " + SumArray(arr));
}
}
Output
Enter number of elements: 5
Enter element 1: 1
Enter element 2: 2
Enter element 3: 3
Enter element 4: 4
Enter element 5: 5
Sum of the array elements: 15
How It Works
Read the length n and reject a negative size.
Allocate new int[n] and fill it in a second loop.
Call SumArray — input and summing stay separate.
If n is 0, the array is empty and the sum is 0.
Same helper as Example 1, so testing stays easy.
Example 3 — Running Total with Negatives
Print the accumulator after each step so negatives are easy to see.
C#
using System;
class Program
{
static void Main()
{
int[] arr = { 10, -2, 7 };
int total = 0;
Console.WriteLine("Running total:");
foreach (int value in arr)
{
total += value;
Console.WriteLine(" after {0:+0;-0}: {1}", value, total);
}
Console.WriteLine("Final sum: " + total);
}
}
Output
Running total:
after +10: 10
after -2: 8
after +7: 15
Final sum: 15
How It Works
Start at 0, then add 10 → 10.
Add -2 → 8 (no special case for negatives).
Add 7 → 15.
The format string shows a sign on each added value.
Tracing the running total is a strong whiteboard habit.
Edge Cases & Pitfalls
Check these before calling the solution done.
Empty
Sum is 0
An empty array never enters the loop, so the accumulator stays at 0.
Negatives
Just add them
Do not take absolute values unless the problem asks for that.
Overflow
Use a wider type if needed
Very large int arrays may need long for the accumulator.
Null
Guard null arrays
In real code, check for null before looping. Interviews often assume a valid array.
Analysis
Time and Space Complexity
Program
Time
Extra space
foreach / for loop
O(n)
O(1)
User-input build + sum
O(n)
O(n) for the array
Running-total trace
O(n)
O(1)
You must look at every element at least once, so O(n) is optimal for the general case.
Remember
Key Takeaways
Pattern: accumulator starts at 0, then adds each element once.
