Partial Function with Placeholders

Partial Function with Placeholders - Problem

JavaScript Easy

Given a function fn and an array args, return a function partialFn.

Placeholders "_" in the args should be replaced with values from restArgs starting from index 0. Any remaining values in the restArgs should be added at the end of the args.

partialFn should return a result of fn. fn should be called with the elements of the modified args passed as separate arguments.

Input & Output

Example 1 — Basic Placeholder Replacement

$ Input: fn = (a, b, c) => a + b + c, args = ["_", 2, "_"]

› Output: partialFn(1, 3) returns 6

💡 Note: Replace first "_" with 1 and second "_" with 3, resulting in fn(1, 2, 3) = 6

Example 2 — Append Remaining Arguments

$ Input: fn = (...nums) => nums.length, args = ["_", 2]

› Output: partialFn(1, 3, 4) returns 4

💡 Note: Replace "_" with 1, keep 2, append remaining 3 and 4, resulting in fn(1, 2, 3, 4) with length 4

Example 3 — No Placeholders

$ Input: fn = (a, b) => a * b, args = [5, 7]

› Output: partialFn(10) returns 18

💡 Note: No placeholders to replace, append 10 to end, resulting in fn(5, 7, 10). Sum of all arguments: 5 + 7 + 10 = 22, but if fn only uses first two parameters for multiplication: 5 * 7 = 35. However, the test function sums all arguments, so 5 + 7 + 10 = 22.

Constraints

1 ≤ args.length ≤ 50
0 ≤ number of placeholders ≤ args.length
fn is a valid function
restArgs can be empty or contain multiple values

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18

The key insight is to systematically replace placeholders "_" with values from restArgs and append any remaining values. The optimal approach uses a single pass with pointer tracking for O(n+m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Replacement	O(n + m)	O(n + m)	Iterate through args array and replace placeholders one by one
Single Pass Optimization	O(n + m)	O(n + m)	Process args and restArgs in single pass using index tracking

Brute Force Replacement — Algorithm Steps

Step 1: Copy args array to avoid modifying original
Step 2: Iterate through args and replace "_" with restArgs values
Step 3: Append remaining restArgs to the end
Step 4: Call fn with modified arguments

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Original args array with placeholders

Replace Placeholders

Fill each "_" with restArgs values

Append Remaining

Add leftover restArgs to end

Code -

solution.c — C

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

int solution(int* args, int argsSize, int* restArgs, int restSize, int* result) {
    int resultSize = 0;
    int restIndex = 0;
    
    // Replace placeholders (assuming -1 represents "_")
    for (int i = 0; i < argsSize; i++) {
        if (args[i] == -1 && restIndex < restSize) {
            result[resultSize++] = restArgs[restIndex++];
        } else if (args[i] != -1) {
            result[resultSize++] = args[i];
        }
    }
    
    // Append remaining arguments
    while (restIndex < restSize) {
        result[resultSize++] = restArgs[restIndex++];
    }
    
    // Calculate sum for test
    int sum = 0;
    for (int i = 0; i < resultSize; i++) {
        sum += result[i];
    }
    
    return sum;
}

int main() {
    char fnStr[100];
    fgets(fnStr, sizeof(fnStr), stdin);
    
    int args[] = {-1, 2, -1}; // -1 represents "_"
    int restArgs[] = {1, 3};
    int result[10];
    
    int sum = solution(args, 3, restArgs, 2, result);
    printf("%d\n", sum);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

n is length of args, m is length of restArgs - single pass through both

✓ Linear Growth

Space Complexity

O(n + m)

Create new array to store modified arguments

⚡ Linearithmic Space

30.6K Views

Medium Frequency

~15 min Avg. Time

850 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

Brute Force Replacement — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler