Function Composition - Practice Coding Problems

Function Composition - Problem

JavaScript Easy

Function Composition Challenge

In functional programming, function composition is a powerful concept where you combine multiple functions into a single function. Given an array of functions [f1, f2, f3, ..., fn], your task is to create a new function that represents the composition of all these functions.

🎯 The Goal: Return a composed function that applies all input functions from right to left. For example, if you have functions [f(x), g(x), h(x)], the composed function should work like f(g(h(x))) - first apply h, then g, then f.

⚠️ Special Case: If the array is empty, return the identity function that simply returns its input unchanged: f(x) = x.

Each function in the array accepts one integer and returns one integer. Your composed function should do the same!

Input & Output

basic_composition.js — JavaScript

$ Input: functions = [x => x * 2, x => x + 1, x => x * x], x = 4

› Output: 34

💡 Note: The composition works as: multiply_by_2(add_one(square(4))) = multiply_by_2(add_one(16)) = multiply_by_2(17) = 34

single_function.js — JavaScript

$ Input: functions = [x => x + 1], x = 5

› Output: 6

💡 Note: With only one function, composition simply applies that function: add_one(5) = 6

empty_array.js — JavaScript

$ Input: functions = [], x = 42

› Output: 42

💡 Note: Empty array returns the identity function, so the input is returned unchanged: identity(42) = 42

Visualization

Tap to expand

Understanding the Visualization

Input enters pipeline

Value 4 enters the composition pipeline

First transformation

Rightmost function (square) transforms 4 → 16

Second transformation

Middle function (add_one) transforms 16 → 17

Final transformation

Leftmost function (multiply_by_2) transforms 17 → 34

Key Takeaway

🎯 Key Insight: Function composition follows mathematical convention - read from right to left, creating elegant pipelines of transformations

Time & Space Complexity

Time Complexity

⏱️

O(n)

Still need to process each function once during composition and once during execution

✓ Linear Growth

Space Complexity

O(n)

Creates nested function closures, but this is typically optimized by JavaScript engines

⚡ Linearithmic Space

Constraints

0 ≤ functions.length ≤ 1000
All functions accept and return a single integer
-1000 ≤ x ≤ 1000 (input to composed function)
Functions are applied right-to-left (mathematical composition order)
Empty function array should return identity function f(x) = x

Asked in

G Google 15 f Meta 12 N Netflix 8 A Airbnb 6

The optimal solution uses functional composition with reduce/fold operations to elegantly combine functions. Key insight: apply functions from right-to-left to match mathematical notation f(g(h(x))). Handle edge case of empty array by returning identity function.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative Application (Right to Left)	O(n)	O(1)	Apply each function one by one from right to left, storing intermediate results
Functional Reduce Approach (Optimal)	O(n)	O(n)	Use reduce/fold to elegantly compose functions in a single expression

Iterative Application (Right to Left) — Algorithm Steps

Return identity function if array is empty
Start with the input value as the initial result
Iterate through functions from right to left (reverse order)
Apply each function to the current result
Return the final result after all functions are applied

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with input

Begin with input value x = 4

Apply rightmost function

Apply square: 4 * 4 = 16

Apply middle function

Apply add_one: 16 + 1 = 17

Apply leftmost function

Apply multiply_by_two: 17 * 2 = 34

Code -

solution.c — C

#include <stdio.h>

// Function pointer type
typedef int (*IntFunction)(int);

// Sample functions
int multiply_by_two(int x) { return x * 2; }
int add_one(int x) { return x + 1; }
int square(int x) { return x * x; }

// Compose function that returns result for given input
int compose_and_apply(IntFunction* functions, int count, int x) {
    int result = x;
    // Apply functions from right to left
    for (int i = count - 1; i >= 0; i--) {
        result = functions[i](result);
    }
    return result;
}

int main() {
    IntFunction functions[] = {multiply_by_two, add_one, square};
    int result = compose_and_apply(functions, 3, 4);
    printf("%d\n", result); // Should output 100
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We need to apply each of the n functions exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the result variable

✓ Linear Space

Constraints

0 ≤ functions.length ≤ 1000
All functions accept and return a single integer
-1000 ≤ x ≤ 1000 (input to composed function)
Functions are applied right-to-left (mathematical composition order)
Empty function array should return identity function f(x) = x

67.2K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Iterative Application (Right to Left) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler