Curry

Curry - Problem

JavaScript Medium

Given a function fn, return a curried version of that function.

A curried function is a function that accepts fewer or an equal number of parameters as the original function and returns either another curried function or the same value the original function would have returned.

In practical terms, if you called the original function like sum(1,2,3), you would call the curried version like csum(1)(2)(3), csum(1)(2,3), csum(1,2)(3), or csum(1,2,3). All these methods of calling the curried function should return the same value as the original.

Input & Output

Example 1 — Basic Sum Function

$ Input: fn = function sum(a, b, c) { return a + b + c; }

› Output: Curried version that can be called as curry(1)(2)(3) or curry(1, 2)(3), etc.

💡 Note: The curried function accumulates arguments until it has 3 parameters, then calls sum(1, 2, 3) = 6

Example 2 — Partial Application

$ Input: fn = function multiply(x, y) { return x * y; }

› Output: curry(2)(5) or curry(2, 5) both return 10

💡 Note: Can be called with all arguments at once or one at a time, always returns 2 * 5 = 10

Example 3 — Single Parameter

$ Input: fn = function identity(x) { return x; }

› Output: curry(42) returns 42 immediately

💡 Note: Since function only needs 1 parameter, curried version executes immediately when given 1 argument

Constraints

1 ≤ fn.length ≤ 10
0 ≤ arguments.length ≤ 1000
Function will be called with valid arguments

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12

The key insight is to create a closure that accumulates arguments until reaching the required count. Best approach uses closure-based currying that efficiently tracks state. Time: O(1), Space: O(n)

Common Approaches

✓ Argument Accumulation

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

Build up arguments array by concatenating new arguments with previously collected ones. When we have enough arguments (fn.length), call the original function. Otherwise return a new curried function.

Closure-Based Currying

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

Create a closure that maintains the accumulated arguments and original function reference. Each call checks if we have enough arguments by comparing with fn.length, providing O(1) decision making.

Argument Accumulation — Algorithm Steps

Step 1: Create curried function that accepts any number of arguments
Step 2: Combine new arguments with previously collected arguments
Step 3: Check if total arguments >= original function's parameter count
Step 4: Either call original function or return new curried function

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Call

First arguments collected

Accumulation

More arguments added to collection

Execution

When enough arguments collected, call original function

Code -

solution.c — C

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

// C doesn't have closures or first-class functions
// This is a conceptual implementation

typedef struct {
    int (*fn)(int*, int);
    int* args;
    int arg_count;
    int arity;
} CurriedFunc;

CurriedFunc* solution(int (*fn)(int*, int), int arity) {
    CurriedFunc* curried = malloc(sizeof(CurriedFunc));
    curried->fn = fn;
    curried->args = malloc(arity * sizeof(int));
    curried->arg_count = 0;
    curried->arity = arity;
    return curried;
}

int main() {
    char fnStr[1000];
    fgets(fnStr, sizeof(fnStr), stdin);
    fnStr[strcspn(fnStr, "\n")] = 0;
    
    // For demonstration, return marker that currying was applied
    printf("curried\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each curry call just checks argument count and either calls function or returns new function

✓ Linear Growth

Space Complexity

O(n)

Stores accumulated arguments array, where n is the number of arguments collected so far

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Argument Accumulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler