Pipeline Processor - Problem

Create a higher-order function called pipeline that takes multiple transformation functions as arguments and returns a new function. This returned function should apply all the transformations in sequence to an input value.

Function Signature:

pipeline(transform1, transform2, ..., transformN) → returns a function

The returned function should take an input and pass it through each transformation function in order, where the output of one function becomes the input of the next.

Example Usage:

const processor = pipeline(trim, lowercase, removeSpaces);
const result = processor(" Hello World "); → "helloworld"

Input & Output

Example 1 — Basic Text Processing

$ Input: input = " Hello World ", transforms = ["trim", "lowercase", "removeSpaces"]

› Output: "helloworld"

💡 Note: Step by step: trim(" Hello World ") → "Hello World" → lowercase("Hello World") → "hello world" → removeSpaces("hello world") → "helloworld"

Example 2 — Uppercase and Reverse

$ Input: input = "hello", transforms = ["uppercase", "reverse"]

› Output: "OLLEH"

💡 Note: First uppercase("hello") → "HELLO", then reverse("HELLO") → "OLLEH"

Example 3 — Single Transform

$ Input: input = " spaces ", transforms = ["trim"]

› Output: "spaces"

💡 Note: Only one transformation applied: trim removes leading and trailing whitespace

Constraints

1 ≤ input.length ≤ 1000
1 ≤ transforms.length ≤ 10
Available transforms: trim, lowercase, uppercase, removeSpaces, reverse

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to use function composition to create reusable transformation pipelines. The optimal approach uses reduce or similar techniques to compose functions into a single executable pipeline that can transform data in one pass. Time: O(n), Space: O(1).

Common Approaches

✓ Function Composition with Reduce

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

Create a pipeline by using reduce to compose all transformation functions into a single executable function that can be reused multiple times.

Manual Function Chaining

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

For each input, manually call each transformation function one by one, passing the result of each function as input to the next function.

Function Composition with Reduce — Algorithm Steps

Create a function that takes transformation functions as parameters
Use reduce to compose all functions left-to-right
Return the composed function
Apply the pipeline to input data

Visualization

Tap to expand

Step-by-Step Walkthrough

Define Functions

Create individual transformation functions

Compose Pipeline

Use reduce to combine functions

Apply Pipeline

Run composed function on input

Get Result

Pipeline returns final transformed string

Code -

solution.c — C

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

typedef char* (*TransformFunc)(char*);

char* trim(char *str) {
    static char result[1000];
    strcpy(result, str);
    int start = 0, end = strlen(result) - 1;
    while (result[start] == ' ' || result[start] == '\t' || result[start] == '\n') start++;
    while (end >= 0 && (result[end] == ' ' || result[end] == '\t' || result[end] == '\n')) end--;
    int len = end - start + 1;
    memmove(result, result + start, len);
    result[len] = '\0';
    return result;
}

char* lowercase(char *str) {
    static char result[1000];
    strcpy(result, str);
    for (int i = 0; result[i]; i++) {
        result[i] = tolower(result[i]);
    }
    return result;
}

char* removeSpaces(char *str) {
    static char result[1000];
    strcpy(result, str);
    int i = 0, j = 0;
    while (result[i]) {
        if (result[i] != ' ') {
            result[j++] = result[i];
        }
        i++;
    }
    result[j] = '\0';
    return result;
}

char* uppercase(char *str) {
    static char result[1000];
    strcpy(result, str);
    for (int i = 0; result[i]; i++) {
        result[i] = toupper(result[i]);
    }
    return result;
}

char* reverse(char *str) {
    static char result[1000];
    strcpy(result, str);
    int len = strlen(result);
    for (int i = 0; i < len / 2; i++) {
        char temp = result[i];
        result[i] = result[len - 1 - i];
        result[len - 1 - i] = temp;
    }
    return result;
}

char* solution(char *inputStr, char transforms[][20], int transformCount) {
    static char result[1000];
    strcpy(result, inputStr);
    
    // Apply transformations in sequence (function composition)
    for (int i = 0; i < transformCount; i++) {
        if (strcmp(transforms[i], "trim") == 0) {
            strcpy(result, trim(result));
        } else if (strcmp(transforms[i], "lowercase") == 0) {
            strcpy(result, lowercase(result));
        } else if (strcmp(transforms[i], "removeSpaces") == 0) {
            strcpy(result, removeSpaces(result));
        } else if (strcmp(transforms[i], "uppercase") == 0) {
            strcpy(result, uppercase(result));
        } else if (strcmp(transforms[i], "reverse") == 0) {
            strcpy(result, reverse(result));
        }
    }
    
    return result;
}

int main() {
    char inputStr[1000];
    fgets(inputStr, sizeof(inputStr), stdin);
    inputStr[strcspn(inputStr, "\n")] = 0;
    
    char transformsJson[1000];
    fgets(transformsJson, sizeof(transformsJson), stdin);
    transformsJson[strcspn(transformsJson, "\n")] = 0;
    
    // Parse JSON array manually
    char transforms[10][20];
    int transformCount = 0;
    char *token = strtok(transformsJson + 1, ",]"); // Skip [
    
    while (token != NULL && transformCount < 10) {
        // Remove quotes and spaces
        while (*token == ' ' || *token == '"') token++;
        char *end = token + strlen(token) - 1;
        while (end > token && (*end == ' ' || *end == '"')) end--;
        *(end + 1) = '\0';
        
        strcpy(transforms[transformCount], token);
        transformCount++;
        token = strtok(NULL, ",]");
    }
    
    char *result = solution(inputStr, transforms, transformCount);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Still need to call each of the n transformation functions once

✓ Linear Growth

Space Complexity

O(1)

Only stores the composed function and intermediate results

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Pipeline Processor - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Function Composition with Reduce — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler