Function Composition

Function Composition - Problem

JavaScript Easy

Given an array of functions [f1, f2, f3, ..., fn], return a new function fn that is the function composition of the array of functions.

The function composition of [f(x), g(x), h(x)] is fn(x) = f(g(h(x))).

The function composition of an empty list of functions is the identity function f(x) = x.

You may assume each function in the array accepts one integer as input and returns one integer as output.

Input & Output

Example 1 — Multiple Functions

$ Input: functions = ["square", "addOne", "double"], x = 4

› Output: 81

💡 Note: Composition applies right-to-left: square(addOne(double(4))) = square(addOne(8)) = square(9) = 81

Example 2 — Single Function

$ Input: functions = ["double"], x = 5

› Output: 10

💡 Note: Single function: double(5) = 10

Example 3 — Empty Array

$ Input: functions = [], x = 42

› Output: 42

💡 Note: Empty function array returns identity function: f(x) = x, so result is 42

Constraints

0 ≤ functions.length ≤ 1000
-1000 ≤ x ≤ 1000
Each function accepts and returns integers

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20

The key insight is that function composition applies functions from right to left, like mathematical notation f(g(x)). Best approach uses iterative application or reduce for elegance. Time: O(n), Space: O(1)

Common Approaches

✓ Functional Reduce Approach

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

Leverage the reduce method to compose functions in a single expression, applying them from right to left through the natural flow of reduce.

Iterative Application

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

Start with the input value and apply each function sequentially from the end of the array to the beginning, storing intermediate results.

Functional Reduce Approach — Algorithm Steps

Use reduceRight to process functions from right to left
Each function receives the accumulated result
Return the final composed result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start reduce with input value x = 4

Compose

Functions applied right-to-left automatically

Result

Reduce returns final composed value

Code -

solution.c — C

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

typedef int (*Function)(int);

int identity(int x) { return x; }
int addOne(int x) { return x + 1; }
int square(int x) { return x * x; }
int doubleFunc(int x) { return x * 2; }

int solution(Function* functions, int count, int x) {
    int result = x;
    for (int i = count - 1; i >= 0; i--) {
        result = functions[i](result);
    }
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    int x;
    scanf("%d", &x);
    
    Function functions[1000];
    int count = 0;
    
    char* token = strtok(line, "[],\" \n");
    while (token != NULL) {
        if (strcmp(token, "identity") == 0) functions[count++] = identity;
        else if (strcmp(token, "addOne") == 0) functions[count++] = addOne;
        else if (strcmp(token, "square") == 0) functions[count++] = square;
        else if (strcmp(token, "double") == 0) functions[count++] = doubleFunc;
        token = strtok(NULL, "[],\" \n");
    }
    
    printf("%d\n", solution(functions, count, x));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n functions with reduce

✓ Linear Growth

Space Complexity

O(1)

Only accumulator variable needed

✓ Linear Space

33.2K Views

Medium Frequency

~15 min Avg. Time

850 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 Reduce Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler