How do you solve Allow One Function Call on LeetCode?

Allow One Function Call (LeetCode #2666) can be solved using Brute Force or Optimal Solution. The optimal approach is Optimal Solution with O(1) time complexity and O(1) space complexity. Key insight: The function should only execute once, so tracking the state is crucial.

What is the brute force solution for Allow One Function Call?

The brute force approach for Allow One Function Call is Brute Force, with O(1) time complexity and O(1) space complexity. The brute-force approach involves calling the function directly and checking if it has been called before. If it has, we return undefined; otherwise, we return the result of the function. The optimal Optimal Solution approach improves this to O(1).

What are the interview tips for Allow One Function Call?

Clearly explain your thought process and how you plan to manage state. Consider edge cases, such as calling the function with different arguments. Practice writing concise and clear code, as readability is important.

What are common mistakes when solving Allow One Function Call?

Not using a closure to maintain state, leading to incorrect results. Forgetting to return undefined after the first call.

#2666

Allow One Function Call

Easy

ClosureFunction Decorators

LeetCode ↗

Approaches

Brute ForceOptimal

Complexity Comparison

	Brute Force	Optimal Solution★
Time	O(1)	O(1)
Space	O(1)	O(1)

💡

Intuition

Time O(1)Space O(1)

The optimal solution is similar to the brute-force approach but emphasizes clarity and efficiency. We maintain a single flag to track if the function has been called, ensuring we only check this once.

⚙️

Algorithm

3 steps

1Step 1: Initialize a flag to track if the function has been called.
2Step 2: Define the wrapper function that checks the flag.
3Step 3: If the function has not been called, invoke the original function and set the flag; otherwise, return undefined.

solution.py9 lines

1def once(fn):
2    called = False
3    def wrapper(*args):
4        nonlocal called
5        if not called:
6            called = True
7            return fn(*args)
8        return None
9    return wrapper

ℹ

Complexity note: The time complexity remains O(1) as we only check a flag and call the function once. The space complexity is O(1) since we use a constant amount of space.

1The function should only execute once, so tracking the state is crucial.
2Using closures allows us to maintain state without exposing it outside the function.

Solutions and explanations are original Tejav content. Problem titles © LeetCode — use the LeetCode button above for the full problem statement.