Curry - Practice Coding Problems

Curry - Problem

JavaScript Medium

Currying is a fundamental concept in functional programming that transforms a function that takes multiple arguments into a series of functions that each take a single argument. Your task is to implement a curry function that takes any function fn and returns its curried version.

The curried function should be flexible - it can accept any number of arguments up to the original function's arity. Once it receives enough arguments, it executes the original function. If it receives fewer arguments, it returns another function waiting for the remaining arguments.

Example: If you have sum(a, b, c), the curried version allows: curriedSum(1)(2)(3), curriedSum(1, 2)(3), curriedSum(1)(2, 3), or curriedSum(1, 2, 3) - all producing the same result.

Input & Output

example_1.js — Basic Sum Function

$ Input: fn = (a, b, c) => a + b + c curriedFn = curry(fn) curriedFn(1)(2)(3)

› Output: 6

💡 Note: The curried function accepts one argument at a time. Each call returns a new function until all 3 arguments are provided, then executes the original sum.

example_2.js — Mixed Argument Grouping

$ Input: fn = (a, b, c) => a + b + c curriedFn = curry(fn) curriedFn(1, 2)(3)

› Output: 6

💡 Note: The curried function can accept multiple arguments in a single call. Here it takes 2 arguments first, then 1 more to complete the required 3.

example_3.js — All Arguments at Once

$ Input: fn = (a, b, c) => a + b + c curriedFn = curry(fn) curriedFn(1, 2, 3)

› Output: 6

💡 Note: When all arguments are provided in the first call, the curried function behaves exactly like the original function.

Visualization

Tap to expand

Understanding the Visualization

Capture Function

Take the original function and determine how many arguments it needs

Create Accumulator

Build a function that collects arguments from multiple calls

Check Threshold

When enough arguments are collected, execute the original function

Return Result

Either return the final result or another function waiting for more arguments

Key Takeaway

🎯 Key Insight: Currying transforms any multi-argument function into a chain of single-argument functions using closure to maintain state across calls.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call is constant time, just argument accumulation

✓ Linear Growth

Space Complexity

O(n)

Space used to store accumulated arguments in closure

⚡ Linearithmic Space

Constraints

1 ≤ fn.length ≤ 10 (function arity between 1 and 10)
fn is a valid JavaScript function
Arguments can be of any type (number, string, object, etc.)
The curried function should work with any argument distribution

Asked in

G Google 35 f Facebook 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses a recursive closure that accumulates arguments across multiple function calls. By leveraging fn.length to get the function's arity and using the spread operator to handle flexible argument passing, we create an elegant curried function that works with any argument distribution pattern.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Closure (Optimal)	O(1)	O(n)	Use recursive closure to accumulate arguments elegantly
Brute Force (Explicit Argument Tracking)	O(1)	O(n)	Manually track arguments with nested if-else statements

Recursive Closure (Optimal) — Algorithm Steps

Get the original function's arity using fn.length
Create a recursive curried function that accepts any number of arguments
Accumulate all arguments from current and previous calls
If total arguments >= arity, apply the original function
Otherwise, return the curried function with accumulated arguments

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Closure

Function captures arguments in its scope

Check Arity

Compare accumulated args with required count

Recurse or Execute

Either call original function or return new curried function

Code -

solution.c — C

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

// C implementation using function pointers and structs
// This is a simplified version as C doesn't have native closure support

typedef struct CurriedFunc {
    int (*original_fn)(int*, int);
    int* accumulated_args;
    int current_count;
    int target_arity;
} CurriedFunc;

int sum_function(int* args, int count) {
    int result = 0;
    for (int i = 0; i < count; i++) {
        result += args[i];
    }
    return result;
}

CurriedFunc* create_curried(int (*fn)(int*, int), int arity) {
    CurriedFunc* curried = malloc(sizeof(CurriedFunc));
    curried->original_fn = fn;
    curried->accumulated_args = malloc(sizeof(int) * arity);
    curried->current_count = 0;
    curried->target_arity = arity;
    return curried;
}

int apply_curried(CurriedFunc* curried, int arg) {
    curried->accumulated_args[curried->current_count] = arg;
    curried->current_count++;
    
    if (curried->current_count >= curried->target_arity) {
        int result = curried->original_fn(curried->accumulated_args, curried->current_count);
        return result;
    }
    
    return -1; // Indicates more arguments needed
}

void free_curried(CurriedFunc* curried) {
    free(curried->accumulated_args);
    free(curried);
}

int main() {
    CurriedFunc* curriedSum = create_curried(sum_function, 3);
    
    apply_curried(curriedSum, 1);
    apply_curried(curriedSum, 2);
    int result = apply_curried(curriedSum, 3);
    
    printf("Curried sum result: %d\n", result); // Should print 6
    
    free_curried(curriedSum);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call is constant time, just argument accumulation

✓ Linear Growth

Space Complexity

O(n)

Space used to store accumulated arguments in closure

⚡ Linearithmic Space

Constraints

1 ≤ fn.length ≤ 10 (function arity between 1 and 10)
fn is a valid JavaScript function
Arguments can be of any type (number, string, object, etc.)
The curried function should work with any argument distribution

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Closure (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler