Sponsored
Sponsored
This approach leverages closures to keep track of whether the original function has been called. A closure allows the function to maintain state across calls, which in this case is whether the function should execute or return undefined.
Time Complexity: O(1) for each call, Space Complexity: O(1), as no additional data structures are used.
1def once(fn):
2This Python solution utilizes an inner function with nonlocal keyword to maintain the state of called and result. On first call, the result is computed and stored, while subsequent calls return None.
In this approach, use an external flag variable to keep track of whether the function has already been executed. This approach is more language-specific where closure support is limited.
Time Complexity: O(1) per call, Space Complexity: O(1) for state flag.
1#include <iostream>
2#include <functional>
3
4class Once {
5public:
6 Once(std::function<int(int, int, int)> fn) : fn(fn), called(false) {}
7
8 int operator()(int a, int b, int c) {
9 if (!called) {
10 called = true;
11 result = fn(a, b, c);
12 return result;
13 }
14 return -1; // Undefined equivalent
15 }
16
17private:
18 std::function<int(int, int, int)> fn;
19 bool called;
20 int result;
21};
22
23int main() {
24 Once onceFn([](int a, int b, int c){ return a + b + c; });
25 std::cout << onceFn(1, 2, 3) << std::endl; // Outputs the result
26 std::cout << onceFn(2, 3, 4) << std::endl; // Outputs undefined equivalent
27 return 0;
28}
29This C++ solution uses a class to manage the function call state. The class Once stores a flag called to track whether the function has been executed, ensuring it runs only once and returns an undefined equivalent on further calls.