Function Composition - Practice Coding Problems

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: 34

💡 Note: Composition applies right-to-left: double(addOne(square(4))) = double(addOne(16)) = double(17) = 34

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

Understanding the Visualization

Input

Array of functions and input value x

Compose

Apply functions right-to-left: f(g(h(x)))

Output

Return final result of composition

Key Takeaway

🎯 Key Insight: Functions compose right-to-left, creating a pipeline that transforms input through each function in reverse array order

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

Approach	Time	Space	Notes
✓ Functional Reduce Approach	O(n)	O(1)	Use reduce to compose functions elegantly
Iterative Application	O(n)	O(1)	Apply each function one by one from right to left

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[10];
    int count = 0;
    
    if (strstr(line, "identity")) functions[count++] = identity;
    if (strstr(line, "addOne")) functions[count++] = addOne;
    if (strstr(line, "square")) functions[count++] = square;
    if (strstr(line, "double")) functions[count++] = doubleFunc;
    
    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