C Sum of Array Program

Beginner
5 min read
Updated: Oct 2026
3 programs
Live preview
Definition

What Is the Sum of an Array?

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.

Remember
sum(arr) = arr[0] + arr[1] + ... + arr[n-1]

Example: [1, 2, 3, 4, 5]
  0 → 1 → 3 → 6 → 10 → 15

Empty array → 0
ArrayRunning totalSum
[1, 2, 3, 4, 5]1, 3, 6, 10, 1515
[10, -2, 7]10, 8, 1515
[](no steps)0
Approach

How to Find the Sum of an Array in C

Four clear steps — one pass is enough.

  1. Set total = 0.
  2. Visit every element with an index for loop.
  3. Add each value: total += arr[i].
  4. Return total after the loop ends.
MethodIdeaTimeBest for
Index for looptotal += arr[i]O(n)Interviews, clearest logic
Pointer loopWalk with *p++O(n)When teaching pointers
While loopSame accumulator, different controlO(n)Style preference

Pseudocode

Pseudocode
function SumArray(arr, n):
    total = 0
    for i from 0 to n - 1:
        total = total + arr[i]
    return total
Reference

Cheat Sheet

Keep these facts handy while writing the program.

TopicDetail
Starttotal = 0
Steptotal += arr[i]
Empty arraySum is 0 when n == 0
NegativesAllowed; they reduce the total
OrderDoes not matter for ordinary integers
Classic check[1, 2, 3, 4, 5] → 15
Try it

Live Preview

Enter integers separated by commas or spaces to see the running total and final sum.

Whole numbers only. An empty input sums to 0.

Result
Array: [1, 2, 3, 4, 5]
Running: 0 → 1 → 3 → 6 → 10 → 15
Sum = 15
Trace

Worked Walkthrough — [1, 2, 3, 4, 5]

Watch the accumulator grow after each addition.

Calculation
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 a for loop to add every element into an accumulator.

C
#include <stdio.h>

int sum_array(int arr[], int n)
{
    int total = 0;
    int i;

    for (i = 0; i < n; i++)
        total += arr[i];

    return total;
}

int main(void)
{
    int array[] = { 1, 2, 3, 4, 5 };
    int n = 5;

    printf("Sum of the array elements: %d\n", sum_array(array, n));
    return 0;
}

How It Works

  1. total starts at 0.
  2. The loop visits 1, 2, 3, 4, then 5.
  3. Each visit does total += arr[i].
  4. The running values are 1, 3, 6, 10, then 15.
  5. 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
#include <stdio.h>

int sum_array(int arr[], int n)
{
    int total = 0;
    int i;

    for (i = 0; i < n; i++)
        total += arr[i];

    return total;
}

int main(void)
{
    int n, i;
    int arr[100];

    printf("Enter number of elements: ");
    scanf("%d", &n);

    if (n < 0 || n > 100)
    {
        printf("n must be between 0 and 100.\n");
        return 1;
    }

    for (i = 0; i < n; i++)
    {
        printf("Enter element %d: ", i + 1);
        scanf("%d", &arr[i]);
    }

    printf("Sum of the array elements: %d\n", sum_array(arr, n));
    return 0;
}

How It Works

  1. Read the length n and reject an invalid size.
  2. Fill arr in a second loop with scanf.
  3. Call sum_array — input and summing stay separate.
  4. If n is 0, the loop never runs and the sum is 0.
  5. 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
#include <stdio.h>

int main(void)
{
    int arr[] = { 10, -2, 7 };
    int n = 3;
    int total = 0;
    int i;

    printf("Running total:\n");
    for (i = 0; i < n; i++)
    {
        total += arr[i];
        printf("  after %+d: %d\n", arr[i], total);
    }

    printf("Final sum: %d\n", total);
    return 0;
}

How It Works

  1. Start at 0, then add 10 → 10.
  2. Add -2 → 8 (no special case for negatives).
  3. Add 7 → 15.
  4. %+d shows a sign on each added value.
  5. Tracing the running total is a strong whiteboard habit.

Edge Cases & Pitfalls

Check these before calling the solution done.

Empty

Sum is 0

When n == 0, the loop never runs, 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.

Length

Pass n correctly

C arrays do not know their size — always pass n with the array.

Analysis

Time and Space Complexity

ProgramTimeExtra space
for loop sumO(n)O(1)
User-input build + sumO(n)O(n) for the array
Running-total traceO(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.
  • Loop: for (i = 0; i < n; i++) total += arr[i];
  • Empty: n == 0 → sum stays 0.
  • Test set: [1,2,3,4,5] → 15; [10,-2,7] → 15; [] → 0.

One line: start at zero, add every element once, return the total.

Frequently Asked Questions

Start with total = 0, then loop through the array and add each element with total += arr[i].
Zero is the additive identity. Starting there makes the final total equal the sum of all elements, including the empty-array case.
Yes. The same loop works; negatives reduce the running total.
Prefer a for loop in interviews to show the accumulator clearly. Both are O(n) and fine.
O(n) time and O(1) extra space for a single pass over n elements.

Next: Sum of Digits

Add the digits of a number with n % 10.

Sum of digits tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

13 people found this page helpful

C Strong Number Program C Sum of Digits Program