Apply Transform Over Each Element in Array

Apply Transform Over Each Element in Array - Problem

JavaScript Easy

Given an integer array arr and a transformation function fn, return a new array with the transformation applied to each element.

The returned array should be created such that returnedArray[i] = fn(arr[i], i), where the function receives both the element value and its index as parameters.

Important: You must implement this without using the built-in Array.map() method.

Example: If arr = [1, 2, 3] and fn = (x, i) => x + i, then the result should be [1+0, 2+1, 3+2] = [1, 3, 5].

Input & Output

example_1.js — Basic Addition

$ Input: arr = [1, 2, 3], fn = (x, i) => x + i

› Output: [1, 3, 5]

💡 Note: For each element, we add its value to its index: arr[0]=1+0=1, arr[1]=2+1=3, arr[2]=3+2=5

example_2.js — Multiplication

$ Input: arr = [10, 20, 30], fn = (x, i) => x * 2

› Output: [20, 40, 60]

💡 Note: Each element is doubled (index is ignored in this function): 10*2=20, 20*2=40, 30*2=60

example_3.js — Edge Case

$ Input: arr = [5], fn = (x, i) => x * i

› Output: [0]

💡 Note: Single element at index 0: 5 * 0 = 0. This demonstrates how index can significantly affect the result

Constraints

0 ≤ arr.length ≤ 1000
-10⁹ ≤ arr[i] ≤ 10⁹
fn returns an integer
The transformation function fn is always provided and valid

Visualization

Tap to expand

Understanding the Visualization

Input Conveyor

Products arrive on the input belt, each with a position number

Transformation Station

Worker applies fn(product, position) to transform each item

Output Collection

Transformed products are placed on the output belt in order

Final Result

Complete transformed array is ready for delivery

Key Takeaway

🎯 Key Insight: Array transformation is a linear operation that requires exactly one pass through the input data, making it inherently O(n) in both time and space complexity.

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 42 f Meta 35

The optimal solution uses a simple for loop to iterate through the input array once, applying the transformation function fn(arr[i], i) to each element and building the result array. This achieves O(n) time complexity and O(n) space complexity, which is optimal since we must visit every element and create a new array of the same size.

Common Approaches

Approach	Time	Space	Notes
✓ Basic For Loop Approach	O(n)	O(n)	Iterate through array with traditional for loop and build result array

Basic For Loop Approach — Algorithm Steps

Create a new empty array to store results
Use a for loop to iterate from index 0 to array length - 1
For each element, call fn(arr[i], i) and store the result
Add the transformed element to the result array
Return the completed result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty result array and start at index 0

Transform

Apply fn(arr[i], i) to current element

Store

Add transformed value to result array

Continue

Move to next index and repeat until done

Code -

solution.c — C

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

typedef int (*TransformFunc)(int value, int index);

int* mapArray(int* arr, int length, TransformFunc fn, int* resultLength) {
    /** Apply transformation function to each element in array */
    int* result = (int*)malloc(length * sizeof(int));
    if (result == NULL) return NULL;
    
    for (int i = 0; i < length; i++) {
        result[i] = fn(arr[i], i);
    }
    
    *resultLength = length;
    return result;
}

int addIndex(int value, int index) {
    return value + index;
}

int doubleValue(int value, int index) {
    return value * 2;
}

int main() {
    // Test case 1
    int arr1[] = {1, 2, 3};
    int length1 = 3;
    int resultLength1;
    
    int* result1 = mapArray(arr1, length1, addIndex, &resultLength1);
    
    printf("[%d, %d, %d]\n", result1[0], result1[1], result1[2]); // [1, 3, 5]
    
    free(result1);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element exactly once, where n is the length of the input array

✓ Linear Growth

Space Complexity

O(n)

We create a new array of the same size as the input array to store results

⚡ Linearithmic Space

52.0K Views

High Frequency

~12 min Avg. Time

2.2K 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

Basic For Loop Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler