Allow One Function Call - Practice Coding Problems

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

Understanding the Visualization

Input

Original function fn and array of call arguments

Process

Create wrapper function with execution state tracking

Output

First call returns fn result, subsequent calls return undefined

Key Takeaway

🎯 Key Insight: Closure provides persistent state to track function execution across calls

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

Approach	Time	Space	Notes
✓ Closure with Flag	O(1)	O(1)	Use closure to track if function was already called
Memoization Pattern	O(1)	O(1)	Cache result on first call, return cached value or undefined

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