Array Reduce Transformation | #2626 | LeetCode Solution

Problem : Array Reduce Transformation | #2626 | LeetCode

Given an integer array `nums` and a reducer function `fn`, and an initial value `init`, return a reduced array.

A reduced array is created by applying the following operation: 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 final value of `val` is returned.

If the length of the array is `0`, it should return `nit`.

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

Example 1:

Input: nums = [1,2,3,4]

fn = function sum(accum, curr) { return accum + curr; }

init = 0

Output: 10

Explanation:

initially, the value is init=0.

(0) + nums[0] = 1

(1) + nums[1] = 3

(3) + nums[2] = 6

(6) + nums[3] = 10

The final answer is 10.

Example 2:

Input: 

nums = [1,2,3,4]

fn = function sum(accum, curr) { return accum + curr * curr; }

init = 100

Output: 130

Explanation:

initially, the value is init=100.

(100) + nums[0]^2 = 101

(101) + nums[1]^2 = 105

(105) + nums[2]^2 = 114

(114) + nums[3]^2 = 130

The final answer is 130.

Example 3:

Input: 

nums = []

fn = function sum(accum, curr) { return 0; }

init = 25

Output: 25

Explanation: For empty arrays, the answer is always init.

Solution:

     /**

     * @param {number[]} nums

     * @param {Function} fn

     * @param {number} init

     * @return {number}

     */

    var reduce = function (nums, fn, init) {

        var val = init;

        for (let i = 0; i < nums.length; i++) {

            val = fn(val, nums[i])

        }

        return val

    };

Explanation:

Let's break down the code step by step:

1. The code defines a function called `reduce`, which is similar in concept to JavaScript's built-in `Array.prototype.reduce` method. It takes three parameters:

   - `nums`: An array of numbers.

   - `fn`: A function that will be used to reduce the array.

   - `init`: An initial value that serves as the starting point for the reduction.

2. Inside the `reduce` function, a variable `value` is declared and initialised with the value of `init`. This variable will be used to accumulate the result of the reduction operation.

3. The function enters a `for` loop that iterates through each element of the input array `nums`. The loop is controlled by the variable `i`, which starts at 0 and goes up to the length of the array.

4. Inside the loop, the `fn` function is called with two arguments: the current value of `val` (which starts as `init`) and the current element of the array `nums[i]`. The purpose of this call is to allow the `fn` function to operate on the current value and element and return a new value that will become the updated value of `val`.

   - `val = fn(val, nums[i])`: This line assigns the result of `fn(val, nums[i])` back to `val`, effectively updating `val` with the result of the function call.

5. The loop continues to iterate through the array, and the `fn` function is applied iteratively to each element in the array, updating the `val` variable in each iteration.

6. After the loop has processed all elements in the input array `nums`, the `val` variable contains the result of the reduction operation.

7. Finally, the `val` variable, which now holds the reduced value, is returned as the result of the `reduce` function.

In summary, the `reduce` function takes an array, a reduction function (`fn`), and an initial value (`init`). It iterates through the array, applying the reduction function to each element and accumulating the result in the `val` variable. The final `val` value represents the result of reducing the array according to the logic defined in the `fn` function.