Codestin Search App

Allow One Function Call - Problem

JavaScript Easy

Function Call Limiter: Create a function wrapper that ensures another function can only be called once.

Given a function fn, return a new function that behaves exactly like the original function on its first call, but returns undefined for all subsequent calls.

Key Requirements:
• First call: Return the same result as fn
• All subsequent calls: Return undefined
• The original function should never be executed more than once

This pattern is commonly used in JavaScript libraries to prevent accidental multiple initializations or expensive operations from running repeatedly.

Input & Output

basic_function.js — JavaScript

$ Input: fn = () => 5 calls = [[], [], []]

› Output: [5, undefined, undefined]

💡 Note: The first call executes the function and returns 5. All subsequent calls return undefined because the function has already been executed once.

function_with_arguments.js — JavaScript

$ Input: fn = (a, b) => a + b calls = [[2, 3], [1, 4], [10, 20]]

› Output: [5, undefined, undefined]

💡 Note: Only the first call with arguments (2, 3) executes, returning 5. Later calls with different arguments still return undefined.

side_effects.js — JavaScript

$ Input: fn = () => { console.log('executed'); return 42; } calls = [[], [], []]

› Output: [42, undefined, undefined] (console shows 'executed' only once)

💡 Note: The function with side effects (console.log) only executes once, proving that the original function is never called more than once.

Constraints

1 ≤ calls.length ≤ 10
0 ≤ calls[i].length ≤ 100
2 ≤ JSON.stringify(calls).length ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Setup Closure

Create wrapper function with private called flag

First Call

Flag is false, execute function, set flag to true, return result

Guard Check

Flag is true, skip execution, return undefined immediately

Key Takeaway

🎯 Key Insight: A single boolean flag in a closure is all we need to ensure a function only executes once, providing O(1) performance with minimal memory usage.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a closure with a boolean flag to track whether the function has been called. On the first call, execute the original function and set the flag. On subsequent calls, simply return undefined without executing the function. This achieves O(1) time and space complexity while ensuring the original function never runs more than once.

Common Approaches

Approach	Time	Space	Notes
✓ Boolean Flag (Optimal)	O(1)	O(1)	Use a single boolean flag to track if function has been called
Call History Array (Brute Force)	O(1)	O(n)	Keep an array of all function calls and check the length

Boolean Flag (Optimal) — Algorithm Steps

Create a boolean flag initialized to false (not called)
Return a wrapper function that checks the flag
On first call: execute function, set flag to true, return result
On subsequent calls: check flag is true, return undefined immediately
Use closure to maintain flag state between calls

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

called = false, ready for first execution

First Call

Set called = true, execute function, return result

Subsequent Calls

Check called = true, return undefined immediately

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

typedef struct {
    char* (*fn)(const char*);
    bool called;
    char* result;
} OnceWrapper;

char* call_once(OnceWrapper* wrapper, const char* input) {
    if (!wrapper->called) {
        wrapper->called = true;
        wrapper->result = wrapper->fn(input);
        return wrapper->result;
    }
    return NULL;
}

char* greet(const char* name) {
    char* result = malloc(100);
    snprintf(result, 100, "Hello, %s!", name);
    return result;
}

int main() {
    OnceWrapper wrapper = {greet, false, NULL};
    
    char* result1 = call_once(&wrapper, "Alice");
    if (result1) printf("%s\n", result1); // "Hello, Alice!"
    
    char* result2 = call_once(&wrapper, "Bob");
    if (result2) {
        printf("%s\n", result2);
    } else {
        printf("NULL\n"); // "NULL"
    }
    
    free(wrapper.result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Single boolean check per call, no loops or complex operations

✓ Linear Growth

Space Complexity

O(1)

Only stores one boolean flag regardless of number of calls

✓ Linear Space

52.3K Views

Medium Frequency

~12 min Avg. Time

2.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Boolean Flag (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler