Apply Transform Over Each Element in Array

Apply Transform Over Each Element in Array - Problem

JavaScript Easy

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

The returned array should be created such that returnedArray[i] = fn(arr[i], i).

Please solve it without the built-in Array.map method.

Input & Output

Example 1 — Add One to Each Element

$ Input: arr = [1,2,3], fn = function plusone(n) { return n + 1; }

› Output: [2,3,4]

💡 Note: Apply fn to each element: fn(1,0)=2, fn(2,1)=3, fn(3,2)=4

Example 2 — Add Index to Element

$ Input: arr = [1,2,3], fn = function plusI(n, i) { return n + i; }

› Output: [1,3,5]

💡 Note: Add index to each element: fn(1,0)=1+0=1, fn(2,1)=2+1=3, fn(3,2)=3+2=5

Example 3 — Constant Function

$ Input: arr = [10,20,30], fn = function constant() { return 42; }

› Output: [42,42,42]

💡 Note: Function returns constant: fn(10,0)=42, fn(20,1)=42, fn(30,2)=42

Constraints

0 ≤ arr.length ≤ 1000
-10⁹ ≤ arr[i] ≤ 10⁹
fn returns an integer

Visualization

Tap to expand

Asked in

G Google 25 F Facebook 20 A Amazon 15

Brief HTML summary: The key insight is to iterate through the array and apply the transformation function to each element with its index. Best approach is iterative transformation using a single pass. Time: O(n), Space: O(n)

Common Approaches

✓ Iterative Transformation

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

Create a new array and iterate through the original array, applying the transformation function to each element along with its index. Store the result in the corresponding position of the new array.

Pre-allocated Array

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

Instead of dynamically growing the result array, pre-allocate it with the same size as input array. This avoids potential memory reallocations during the transformation process.

Iterative Transformation — Algorithm Steps

Step 1: Create a new empty array with same length
Step 2: Loop through each element with its index
Step 3: Apply fn(element, index) and store result

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Array

Original array with elements and indices

Apply Function

Transform each element using fn(element, index)

Result Array

New array with transformed values

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

bool* solution(int* nums, int numsSize, int* l, int lSize, int* r, int rSize, int* returnSize) {
    bool* result = (bool*)malloc(lSize * sizeof(bool));
    *returnSize = lSize;
    
    for (int i = 0; i < lSize; i++) {
        // Extract subarray
        int subarraySize = r[i] - l[i] + 1;
        int* subarray = (int*)malloc(subarraySize * sizeof(int));
        for (int j = 0; j < subarraySize; j++) {
            subarray[j] = nums[l[i] + j];
        }
        
        // Sort the subarray
        qsort(subarray, subarraySize, sizeof(int), compare);
        
        // Check if it forms arithmetic sequence
        if (subarraySize <= 1) {
            result[i] = true;
        } else {
            bool isArithmetic = true;
            int diff = subarray[1] - subarray[0];
            
            for (int j = 2; j < subarraySize; j++) {
                if (subarray[j] - subarray[j-1] != diff) {
                    isArithmetic = false;
                    break;
                }
            }
            
            result[i] = isArithmetic;
        }
        
        free(subarray);
    }
    
    return result;
}

int* parseArray(char* str, int* size) {
    *size = 0;
    if (strlen(str) <= 2) return NULL;
    
    // Count commas to estimate size
    int count = 1;
    for (int i = 0; str[i]; i++) {
        if (str[i] == ',') count++;
    }
    
    int* arr = (int*)malloc(count * sizeof(int));
    char* token = strtok(str + 1, ",]"); // Skip '['
    
    while (token != NULL) {
        arr[(*size)++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    return arr;
}

int main() {
    char line[10000];
    
    // Read nums array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int numsSize;
    int* nums = parseArray(line, &numsSize);
    
    // Read l array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int lSize;
    int* l = parseArray(line, &lSize);
    
    // Read r array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int rSize;
    int* r = parseArray(line, &rSize);
    
    int returnSize;
    bool* result = solution(nums, numsSize, l, lSize, r, rSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%s", result[i] ? "true" : "false");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(nums);
    free(l);
    free(r);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array of n elements

✓ Linear Growth

Space Complexity

O(n)

New array to store n transformed elements

⚡ Linearithmic Space

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

Iterative Transformation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler