Array Reduce Transformation - Practice Coding Problems

Array Reduce Transformation - Problem

JavaScript Easy

🎯 The Challenge: Build Your Own Array Reduce

Imagine you're a data scientist who needs to aggregate information from a dataset step by step. You have an array of numbers, a reducer function that defines how to combine two values, and an initial value to start with.

Your task is to implement the reduce operation - a fundamental functional programming concept that processes each array element sequentially, accumulating results along the way.

📝 What you need to do:

Start with the init value as your accumulator
For each element in nums, call fn(accumulator, currentElement)
Update the accumulator with the result
Return the final accumulated value

Special case: If the array is empty, simply return the initial value.

Note: You cannot use the built-in Array.reduce() method - implement it from scratch!

Input & Output

example_1.py — Sum Array Elements

$ Input: nums = [1, 2, 3, 4], fn = sum, init = 0

› Output: 10

💡 Note: Starting with 0: 0+1=1, 1+2=3, 3+3=6, 6+4=10. The final accumulated sum is 10.

example_2.py — Product of Array Elements

$ Input: nums = [1, 2, 3, 4], fn = multiply, init = 1

› Output: 24

💡 Note: Starting with 1: 1×1=1, 1×2=2, 2×3=6, 6×4=24. The final accumulated product is 24.

example_3.py — Empty Array

$ Input: nums = [], fn = sum, init = 42

› Output: 42

💡 Note: Since the array is empty, no operations are performed and we return the initial value 42.

Constraints

0 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000
Cannot use built-in Array.reduce() method
Function fn is a valid reducer function
init can be any integer value

Visualization

Tap to expand

Understanding the Visualization

Raw Material

Start with initial value as the base product

Station 1

First worker adds component 1 using reducer function

Station 2

Second worker enhances the product with component 2

Final Product

Continue until all components are added

Key Takeaway

🎯 Key Insight: The reduce operation transforms an array into a single value by maintaining state (accumulator) that evolves through each step, making it perfect for aggregation tasks like sum, product, max, or even complex data transformations.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses a simple iterative approach with O(n) time complexity. Initialize an accumulator with the init value, then iterate through each array element, applying the reducer function and updating the accumulator. This directly implements the reduce operation without any built-in methods.

Common Approaches

Approach	Time	Space	Notes
✓ Simple Iterative Approach	O(n)	O(1)	Use a basic loop to iterate through array elements and accumulate results

Simple Iterative Approach — Algorithm Steps

Initialize accumulator with the init value
Iterate through each element in the array
Apply reducer function: accumulator = fn(accumulator, currentElement)
Return final accumulator value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with init value as accumulator

First Element

Apply fn(accumulator, nums[0])

Continue

Keep applying fn with each element

Final Result

Return accumulated value

Code -

solution.c — C

#include <stdio.h>

typedef int (*ReducerFunc)(int, int);

int sum_reducer(int acc, int val) {
    return acc + val;
}

int multiply_reducer(int acc, int val) {
    return acc * val;
}

int reduce_array(int nums[], int length, ReducerFunc fn, int init) {
    int accumulator = init;
    for (int i = 0; i < length; i++) {
        accumulator = fn(accumulator, nums[i]);
    }
    return accumulator;
}

int main() {
    int arr1[] = {1, 2, 3, 4};
    int arr2[] = {};
    
    printf("%d\n", reduce_array(arr1, 4, sum_reducer, 0)); // 10
    printf("%d\n", reduce_array(arr1, 4, multiply_reducer, 1)); // 24
    printf("%d\n", reduce_array(arr2, 0, sum_reducer, 25)); // 25
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element in the array exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the accumulator

✓ Linear Space

28.4K Views

High Frequency

~8 min Avg. Time

892 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

🎯 The Challenge: Build Your Own Array Reduce

📝 What you need to do:

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Simple Iterative Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler