Recursive Sum of Array - Problem

Write a recursive function to calculate the sum of all elements in an array. You are not allowed to use loops (for, while, forEach, etc.).

The function should handle arrays containing integers (positive, negative, or zero). For an empty array, return 0.

Example:

Input: [1, 2, 3, 4, 5] → Output: 15
Input: [-1, -2, 3] → Output: 0
Input: [] → Output: 0

Input & Output

Example 1 — Basic Case

$ Input: arr = [3, 1, 4, 2]

› Output: 10

💡 Note: Sum: 3 + 1 + 4 + 2 = 10. Recursion breaks down as: 3 + sum([1,4,2]) = 3 + (1 + sum([4,2])) = 3 + 1 + (4 + sum([2])) = 3 + 1 + 4 + (2 + sum([])) = 3 + 1 + 4 + 2 + 0 = 10

Example 2 — Negative Numbers

$ Input: arr = [-1, -2, 3]

› Output: 0

💡 Note: Sum: (-1) + (-2) + 3 = 0. Recursion handles negative numbers normally.

Example 3 — Empty Array

$ Input: arr = []

› Output: 0

💡 Note: Base case: empty array returns 0 immediately, no recursive calls needed.

Constraints

0 ≤ arr.length ≤ 1000
-10⁶ ≤ arr[i] ≤ 10⁶
No loops allowed (must use recursion)

Visualization

Tap to expand

Asked in

M Microsoft 25 a Amazon 20 G Google 15

The key insight is to break down the sum into smaller subproblems: sum of array = first element + sum of remaining elements. The base case is an empty array (return 0). Best approach uses index-based recursion to avoid array copying. Time: O(n), Space: O(n)

Common Approaches

✓ Basic Recursion

⏱️ Time: O(n) Space: O(n)

Break down the problem by taking the first element and adding it to the recursive sum of the rest of the array. Base case returns 0 for empty arrays.

Index-Based Recursion

⏱️ Time: O(n) Space: O(n)

Pass the original array with a starting index parameter. Increment index in recursive calls instead of creating array slices, reducing space overhead.

Basic Recursion — Algorithm Steps

Step 1: Check if array is empty - return 0 (base case)
Step 2: Take first element of array
Step 3: Recursively sum the remaining elements
Step 4: Return first element + recursive sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Take First

Extract first element (3)

Recurse Rest

Sum remaining [1, 4, 2] recursively

Combine

Return 3 + 7 = 10

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* arr, int size) {
    if (size == 0) {
        return 0;
    }
    return arr[0] + solution(arr + 1, size - 1);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[100];
    int size = 0;
    
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", solution(arr, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Makes exactly n recursive calls, one for each array element

✓ Linear Growth

Space Complexity

O(n)

Recursion call stack depth is n, plus array slicing creates n new arrays

⚡ Linearithmic Space

31.2K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Recursive Sum of Array - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Basic Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler