Array Reduce Transformation

Array Reduce Transformation - Problem

JavaScript Easy

Given an integer array nums, a reducer function fn, and an initial value init, return the final result obtained by executing the fn function on each element of the array, sequentially, passing in the return value from the calculation on the preceding element.

This result is achieved through the following operations: val = fn(init, nums[0]), val = fn(val, nums[1]), val = fn(val, nums[2]), ... until every element in the array has been processed. The ultimate value of val is then returned.

If the length of the array is 0, the function should return init.

Note: Please solve it without using the built-in Array.reduce method.

Input & Output

Example 1 — Sum Reduction

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

› Output: 10

💡 Note: Step by step: 0+1=1, 1+2=3, 3+3=6, 6+4=10. Final result is 10.

Example 2 — Multiplication

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

› Output: 24

💡 Note: Step by step: 1*1=1, 1*2=2, 2*3=6, 6*4=24. Final result is 24.

Example 3 — Empty Array

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

› Output: 42

💡 Note: Empty array returns the initial value unchanged: 42.

Constraints

0 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000
-1000 ≤ init ≤ 1000

Visualization

Tap to expand

Asked in

M Meta 25 G Google 30 a Amazon 20

The key insight is to iterate through the array while maintaining an accumulator that gets updated by applying the reducer function to the current accumulator and each array element. Best approach is iterative accumulation with Time: O(n), Space: O(1).

Common Approaches

✓ Functional Composition

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

Same algorithm but organized with better separation of concerns and more functional programming style.

Iterative Accumulation

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

Start with the initial value and apply the reducer function to each array element in order, accumulating the result.

Functional Composition — Algorithm Steps

Create helper function for applying reducer
Handle empty array case explicitly
Use functional approach for iteration

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Check empty array, prepare reducer function

Compose

Apply reducer with functional composition

Result

Return accumulated result

Code -

solution.c — C

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

int sum_fn(int a, int b) { return a + b; }
int mult_fn(int a, int b) { return a * b; }
int subtract_fn(int a, int b) { return a - b; }

int applyReducer(int acc, int* elements, int size, int (*fn)(int, int)) {
    int result = acc;
    for (int i = 0; i < size; i++) {
        result = fn(result, elements[i]);
    }
    return result;
}

int solution(int* nums, int size, int (*fn)(int, int), int init) {
    if (size == 0) {
        return init;
    }
    
    return applyReducer(init, nums, size, fn);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[100];
    int size = 0;
    char* token = strtok(line, "[],");
    while (token != NULL) {
        int num = atoi(token);
        nums[size++] = num;
        token = strtok(NULL, "[],");
    }
    
    char fnStr[20];
    scanf("%s", fnStr);
    
    int init;
    scanf("%d", &init);
    
    // Select function
    int (*fn)(int, int);
    if (strcmp(fnStr, "sum") == 0) {
        fn = sum_fn;
    } else if (strcmp(fnStr, "mult") == 0) {
        fn = mult_fn;
    } else {
        fn = subtract_fn;
    }
    
    printf("%d\n", solution(nums, size, fn, init));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Still single pass through array elements

✓ Linear Growth

Space Complexity

O(1)

Only accumulator variable needed

✓ Linear Space

22.3K Views

Medium Frequency

~10 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Functional Composition — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler