Allow One Function Call

Allow One Function Call - Problem

JavaScript Easy

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.

Requirements:

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

Input & Output

Example 1 — Basic Addition Function

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

› Output: [3, undefined]

💡 Note: First call: fn(1,2) executes and returns 1+2=3. Second call: fn(3,4) doesn't execute, returns undefined.

Example 2 — Single Call Only

$ Input: fn = (a,b,c) => a + b + c, calls = [[2,3,6]]

› Output: [11]

💡 Note: Only one call made: fn(2,3,6) = 2+3+6 = 11. Function executes normally on first call.

Example 3 — Multiple Blocked Calls

$ Input: fn = (a,b) => a * b, calls = [[5,7], [2,4], [1,3]]

› Output: [35, undefined, undefined]

💡 Note: First call: fn(5,7) = 5*7 = 35. Second and third calls return undefined as function already executed once.

Constraints

fn is a valid JavaScript function
fn can be called with 0 or more arguments
calls.length ≥ 1
0 ≤ calls[i].length ≤ 10

Visualization

Tap to expand

Asked in

M Meta 15 G Google 12

The key insight is using closure to maintain state between function calls. A boolean flag tracks whether the function has been executed. Best approach uses closure with flag: Time: O(1), Space: O(1).

Common Approaches

✓ Closure with Flag

⏱️ Time: O(1) Space: O(1)

Create a closure that maintains a boolean flag to remember whether the original function has been executed. On first call, execute fn and set flag. On subsequent calls, return undefined.

Memoization Pattern

⏱️ Time: O(1) Space: O(1)

Similar to closure approach but explicitly caches the result. Uses the memoization pattern where we store the computed result and a flag to indicate execution state.

Closure with Flag — Algorithm Steps

Create a boolean flag to track execution state
Return a new function that checks the flag
On first call: execute fn, set flag, return result
On subsequent calls: return undefined

Visualization

Tap to expand

Step-by-Step Walkthrough

First Call

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

Second Call

Flag is true, skip execution, return undefined

Result

Function only executes once

Code -

solution.c — C

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

typedef struct {
    bool called;
    int result_cache;
    char fn_name[20];
} OnceFunction;

OnceFunction* solution(const char* fn_name) {
    OnceFunction* once_fn = malloc(sizeof(OnceFunction));
    once_fn->called = false;
    strcpy(once_fn->fn_name, fn_name);
    return once_fn;
}

int* call_once(OnceFunction* once_fn, int* args, int arg_count) {
    static int result;
    if (!once_fn->called) {
        once_fn->called = true;
        if (strcmp(once_fn->fn_name, "add") == 0) {
            result = 0;
            for (int i = 0; i < arg_count; i++) {
                result += args[i];
            }
        } else if (strcmp(once_fn->fn_name, "multiply") == 0) {
            result = 1;
            for (int i = 0; i < arg_count; i++) {
                result *= args[i];
            }
        }
        return &result;
    }
    return NULL;
}

int main() {
    char fn_name[20] = "add";
    int test_calls[][2] = {{1, 2}, {3, 4}};
    
    OnceFunction* once_fn = solution(fn_name);
    
    printf("[");
    for (int i = 0; i < 2; i++) {
        int* result = call_once(once_fn, test_calls[i], 2);
        if (result) {
            printf("%d", *result);
        } else {
            printf("null");
        }
        if (i < 1) printf(",");
    }
    printf("]\n");
    
    free(once_fn);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call takes constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores one boolean flag in closure

✓ Linear Space

12.5K Views

Medium Frequency

~8 min Avg. Time

425 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

Closure with Flag — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler