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.
1import java.util.concurrent.atomic.
This Java approach uses an AtomicBoolean to track if the function has been called. This provides a thread-safe way to implement the 'once' behavior for multi-threaded environments.
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.