Is Allow One Function Call easy or hard?

Allow One Function Call is classified as an Easy problem. The main concept is understanding closures or maintaining persistent state across function calls. Once you recognize that a single boolean flag is enough to control execution, the implementation becomes straightforward.

Allow One Function Call Python/Java solution

In Python or Java, create a wrapper function that stores a boolean variable indicating whether the function has already executed. The wrapper checks this variable before calling the original function. After the first execution, the variable is updated so later calls return undefined or the equivalent null behavior.

How to solve Allow One Function Call in O(1)?

Store a boolean variable such as `called` inside a closure. When the returned function runs, check the flag. If it is false, execute the original function with the provided arguments and set the flag to true. If it is already true, return undefined immediately. This guarantees constant time per call.

What is the best approach for Allow One Function Call?

The best approach uses a closure with a boolean flag that records whether the function has already been executed. The wrapper checks the flag, calls the original function once, and flips the flag to prevent future execution. This runs in O(1) time per call and uses O(1) extra space.

Is Allow One Function Call asked at Google/Amazon/Meta?

The exact problem may not always appear verbatim, but the concept is common in interviews. Variations involving function wrappers, memoization, and higher-order utilities frequently appear at companies like Google, Amazon, and Meta during JavaScript or system design style coding rounds.

What data structure is used in Allow One Function Call?

The problem does not require a complex data structure. It relies on a simple boolean flag stored in a closure or external variable. The key concept is state persistence across function calls rather than arrays, hash maps, or trees.

What is the time complexity of Allow One Function Call?

Each invocation performs a simple boolean check and possibly one function execution. That makes the time complexity O(1) per call. The wrapper also stores only a single flag variable, so the space complexity is O(1).

Description Solution Video 10:15

2666. Allow One Function Call

Easy86.6% acceptance2 companies

Given a function fn, return a new function that is identical to the original function except that it ensures fn is called at most once.

The first time the returned function is called, it should return the same result as fn.
Every subsequent time it is called, it should return undefined.

Example 1:

Input: fn = (a,b,c) => (a + b + c), calls = [[1,2,3],[2,3,6]]
Output: [{"calls":1,"value":6}]
Explanation:
const onceFn = once(fn);
onceFn(1, 2, 3); // 6
onceFn(2, 3, 6); // undefined, fn was not called

Example 2:

Input: fn = (a,b,c) => (a * b * c), calls = [[5,7,4],[2,3,6],[4,6,8]]
Output: [{"calls":1,"value":140}]
Explanation:
const onceFn = once(fn);
onceFn(5, 7, 4); // 140
onceFn(2, 3, 6); // undefined, fn was not called
onceFn(4, 6, 8); // undefined, fn was not called

Constraints:

calls is a valid JSON array
1 <= calls.length <= 10
1 <= calls[i].length <= 100
2 <= JSON.stringify(calls).length <= 1000

Asked at 2 companies

Yandex

Google

10:15

Still stuck?Read 3 approaches, or watch a walkthrough.

Open solution

LanguageLoading editor…

1/**
* @param {Function} fn
* @return {Function}
*/
5var once = function(fn) {
  
  return function(...args){
      
  }
10};

12/**
* let fn = (a,b,c) => (a + b + c)
* let onceFn = once(fn)
*
* onceFn(1,2,3); // 6
* onceFn(2,3,6); // returns undefined without calling fn
*/


Starter codeJavaScriptSpaces: 4

Examples

Case 1Case 2

Input

(a,b,c) => (a + b + c)
[[1,2,3],[2,3,6]]

Input

(a,b,c) => (a * b * c)
[[5,7,4],[2,3,6],[4,6,8]]

Your code is saved on this device.Solution