Curry - Solution & Explanation

Problem Overview: The task asks you to convert a normal function into a curried version. Instead of passing all arguments at once, the returned function should accept arguments across multiple calls and only execute the original function when enough parameters have been collected.

Approach 1: Recursive Argument Collector (O(n) time, O(n) space)

The common solution uses a closure that keeps track of the arguments passed so far. Each call gathers new parameters and checks whether the total number of collected arguments is at least the original function's arity (fn.length). If enough arguments exist, execute fn(...args). Otherwise return another function that continues collecting arguments. Recursion naturally models the repeated chaining behavior (curried(a)(b)(c)). Time complexity is O(n) where n is the number of arguments eventually supplied, since each argument is processed once. Space complexity is O(n) due to stored arguments and closure scope.

This technique relies heavily on JavaScript closures and functional programming behavior. The closure preserves previously provided arguments between calls, which allows partial application without global state. If you are reviewing functional design patterns, this pattern closely relates to functional programming and recursion concepts.

Approach 2: Iterative Closure with Argument Buffer (O(n) time, O(n) space)

Another implementation keeps an argument buffer inside a closure rather than passing arguments recursively. Every time the returned function is called, append new parameters into an array. After appending, check whether the buffer length reaches fn.length. Once the required count is met, call the original function using the buffered arguments. The logic is iterative but still depends on closures to maintain state across invocations. Time complexity remains O(n) since each argument is appended once, and space complexity is also O(n) for storing the collected parameters.

Approach 3: Using Function.bind for Partial Application (O(n) time, O(n) space)

JavaScript's Function.bind can partially apply arguments to a function. You can repeatedly bind arguments until the total count satisfies the required arity. Each bind returns a new function with pre-filled parameters. When enough arguments accumulate, invoke the original function. Although elegant, this method creates multiple bound function instances, which can introduce additional overhead. Complexity still remains O(n) time and O(n) space due to argument accumulation.

Recommended for interviews: The recursive closure approach is the most expected answer. It directly demonstrates understanding of closures, argument spreading, and functional composition. Showing a simple brute-style argument collector proves you understand the problem, while the recursive curry implementation highlights deeper JavaScript knowledge and clean functional design.