Partial Function with Placeholders - Practice Coding Problems

Partial Function with Placeholders - Problem

JavaScript Easy

Create a powerful partial application function that transforms any function into one with pre-filled arguments! Your task is to implement a function that takes a base function fn and an array of arguments args (which may contain placeholder symbols "_"), and returns a new function partialFn.

When partialFn is called with restArgs, it should:

Replace each "_" placeholder in args with values from restArgs (in order)
Append any remaining restArgs to the end of the modified argument list
Call the original function fn with all these arguments

Example: If args = [1, "_", 3, "_"] and you call partialFn(5, 7, 9), the placeholders get filled: [1, 5, 3, 7] and the remaining 9 gets appended: [1, 5, 3, 7, 9]

Input & Output

basic_replacement.js — JavaScript

$ Input: fn = (a,b,c,d,e) => a+b+c+d+e, args = [1, '_', 3, '_'], restArgs = [5, 7, 9]

› Output: 25

💡 Note: The placeholders '_' are replaced with [5, 7] in order, creating [1, 5, 3, 7]. The remaining 9 is appended, giving [1, 5, 3, 7, 9]. Calling fn(1, 5, 3, 7, 9) returns 1+5+3+7+9 = 25.

no_placeholders.js — JavaScript

$ Input: fn = (a,b,c) => a*b*c, args = [2, 3, 4], restArgs = [5, 6]

› Output: 240

💡 Note: No placeholders to replace, so restArgs [5, 6] are appended to args [2, 3, 4], creating [2, 3, 4, 5, 6]. However, fn only uses first 3 parameters, so fn(2, 3, 4) = 2*3*4 = 24... wait, that would call fn(2,3,4,5,6) = 2*3*4 = 24. Actually it depends on function definition.

more_placeholders_than_args.js — JavaScript

$ Input: fn = (...args) => args.join('-'), args = ['_', '_', '_'], restArgs = ['a', 'b']

› Output: "a-b-_"

💡 Note: Only first 2 placeholders can be filled with ['a', 'b'], leaving the third placeholder '_' unchanged. Result is ['a', 'b', '_'], which joins to 'a-b-_'.

Constraints

fn is a valid JavaScript function
args is an array that may contain any values including placeholder "_"
restArgs provided to the returned partial function can be any number of arguments
1 ≤ args.length ≤ 10³
0 ≤ number of placeholders ≤ args.length
The returned partial function must work with any number of restArgs

Visualization

Tap to expand

Understanding the Visualization

Template Setup

Start with story template containing blanks '_' and a list of words to fill in

Sequential Filling

Go through template left-to-right, filling each blank with next available word

Append Extras

Add any remaining words to the end of the story

Execute Story

Read the complete story (call the function) with all words in place

Key Takeaway

🎯 Key Insight: Just like filling a Mad Libs template, we process placeholders sequentially in one pass, making this both intuitive and optimal with O(n) time complexity!

Asked in

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

The optimal solution uses a single-pass linear scan through the args array. As we iterate, we replace each "_" placeholder with the next available element from restArgs, then append any remaining elements. This achieves O(n) time complexity and is both memory-efficient and easy to understand.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Linear Scan (Optimal)	O(n)	O(n)	Single pass through args array, filling placeholders and tracking position simultaneously
Brute Force (Multiple Array Scans)	O(n²)	O(n)	Repeatedly scan the args array to find and replace each placeholder one by one

One-Pass Linear Scan (Optimal) — Algorithm Steps

Initialize result array as copy of args and restArgs index pointer
Iterate through result array once
When encountering a placeholder '_', replace with restArgs[index] and increment index
After the loop, append any remaining restArgs elements
Call the original function with the final argument array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with args=[1, '_', 3, '_'] and restArgs=[5, 7, 9], restIndex=0

Process Element 1

Copy 1 to result, restIndex stays 0

Process Placeholder

Replace '_' with restArgs[0]=5, increment restIndex to 1

Process Element 3

Copy 3 to result, restIndex stays 1

Process Placeholder

Replace '_' with restArgs[1]=7, increment restIndex to 2

Append Remaining

Add restArgs[2]=9 to result

Code -

solution.c — C

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

typedef struct {
    int (*fn)(int*, int);
    char** args;
    int argsLen;
} PartialFunc;

int callPartial(PartialFunc* pf, int* restArgs, int restLen) {
    char** result = malloc(sizeof(char*) * (pf->argsLen + restLen));
    int resultLen = 0;
    int restIndex = 0;
    
    // Single pass through args
    for (int i = 0; i < pf->argsLen; i++) {
        if (strcmp(pf->args[i], "_") == 0 && restIndex < restLen) {
            result[resultLen] = malloc(20);
            sprintf(result[resultLen], "%d", restArgs[restIndex]);
            restIndex++;
        } else {
            result[resultLen] = malloc(strlen(pf->args[i]) + 1);
            strcpy(result[resultLen], pf->args[i]);
        }
        resultLen++;
    }
    
    // Append remaining restArgs
    while (restIndex < restLen) {
        result[resultLen] = malloc(20);
        sprintf(result[resultLen], "%d", restArgs[restIndex]);
        resultLen++;
        restIndex++;
    }
    
    // Convert to int array
    int* finalArgs = malloc(sizeof(int) * resultLen);
    for (int i = 0; i < resultLen; i++) {
        finalArgs[i] = atoi(result[i]);
        free(result[i]);
    }
    free(result);
    
    int res = pf->fn(finalArgs, resultLen);
    free(finalArgs);
    return res;
}

// Example usage
int add(int* args, int len) {
    int sum = 0;
    for (int i = 0; i < len; i++) {
        sum += args[i];
    }
    return sum;
}

int main() {
    char* args[] = {"1", "_", "3", "_"};
    PartialFunc pf = {add, args, 4};
    int restArgs[] = {5, 7, 9};
    int result = callPartial(&pf, restArgs, 3);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the args array of length n, plus appending remaining elements

✓ Linear Growth

Space Complexity

O(n)

Need space for the result array which can be at most n + m elements (original args plus restArgs)

⚡ Linearithmic Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

One-Pass Linear Scan (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler