Higher-Order Function Demo - Problem

Create a function that takes an array and a callback function, applying the callback to each element and returning a new array with the transformed results.

The callback function will be passed as a string representation that you need to evaluate. Common callback operations include:

x => x * 2 (double each element)
x => x + 1 (add 1 to each element)
x => x * x (square each element)

Your function should iterate through the array, apply the callback to each element, and return the new transformed array.

Input & Output

Example 1 — Double Each Element

$ Input: arr = [2, 4, 6], callback = "x => x * 2"

› Output: [4, 8, 12]

💡 Note: Apply doubling function to each element: 2*2=4, 4*2=8, 6*2=12

Example 2 — Add One to Each

$ Input: arr = [1, 3, 5], callback = "x => x + 1"

› Output: [2, 4, 6]

💡 Note: Apply increment function to each element: 1+1=2, 3+1=4, 5+1=6

Example 3 — Square Each Element

$ Input: arr = [2, 3, 4], callback = "x => x * x"

› Output: [4, 9, 16]

💡 Note: Apply squaring function to each element: 2²=4, 3²=9, 4²=16

Constraints

1 ≤ arr.length ≤ 1000
-1000 ≤ arr[i] ≤ 1000
callback is a valid function string

Visualization

Tap to expand

Asked in

G Google 25 f Meta 20 a Amazon 18 M Microsoft 15

The key insight is to parse the callback string once to create a reusable function, then apply it to each array element. The optimized approach parses the callback once (O(m)) then applies the function n times, giving O(n + m) time complexity compared to the brute force O(n × m). Best approach: Function Creation Once - Time: O(n + m), Space: O(n)

Common Approaches

✓ Brute Force - String Evaluation Per Element

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

For each element in the array, substitute the element value into the callback string and evaluate the expression. This means parsing and evaluating the callback string repeatedly for every element.

Optimized - Function Creation Once

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

Parse the callback string once at the beginning to create a reusable function, then apply this function to each element. This avoids repeated string parsing and evaluation overhead.

Brute Force - String Evaluation Per Element — Algorithm Steps

Iterate through each element in the array
Replace 'x' in callback string with current element value
Evaluate the resulting expression
Add result to output array

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse String

Extract operation from callback string for each element

Substitute Value

Replace 'x' with current element value

Evaluate

Calculate result and add to output array

Code -

solution.c — C

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

int evaluateExpression(int x, char* callback) {
    char expr[256];
    strcpy(expr, callback);
    
    // Handle arrow function format
    char* arrow = strstr(expr, "=>");
    if (arrow) {
        strcpy(expr, arrow + 2);
        // Remove leading spaces
        while (*expr == ' ') expr++;
    }
    
    // Simple evaluation for x*2, x+1, x*x patterns
    if (strstr(expr, "x * 2") || strstr(expr, "x*2")) {
        return x * 2;
    } else if (strstr(expr, "x + 1") || strstr(expr, "x+1")) {
        return x + 1;
    } else if (strstr(expr, "x * x") || strstr(expr, "x*x")) {
        return x * x;
    }
    return x;
}

int* solution(int* arr, int arrSize, char* callback, int* returnSize) {
    int* result = (int*)malloc(arrSize * sizeof(int));
    *returnSize = arrSize;
    
    for (int i = 0; i < arrSize; i++) {
        result[i] = evaluateExpression(arr[i], callback);
    }
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array manually
    int arr[100];
    int arrSize = 0;
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token) {
            arr[arrSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    char callback[256];
    fgets(callback, sizeof(callback), stdin);
    callback[strcspn(callback, "\n")] = 0;
    
    int returnSize;
    int* result = solution(arr, arrSize, callback, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n iterations × m characters to parse callback string each time

✓ Linear Growth

Space Complexity

O(n)

New array to store n transformed results

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Higher-Order Function Demo - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - String Evaluation Per Element — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler