Builder Pattern Config - Problem

Implement a Configuration Builder using the Builder Pattern with a fluent API. The builder should create complex configuration objects with various optional parameters.

Your task is to create a ConfigBuilder class that allows method chaining to set different configuration options. The builder should support setting server host, port, database name, connection timeout, retry attempts, and enable/disable SSL.

Implement the following methods:

setHost(host) - Set server host
setPort(port) - Set server port
setDatabase(dbName) - Set database name
setTimeout(seconds) - Set connection timeout
setRetries(count) - Set retry attempts
enableSSL() - Enable SSL connection
build() - Create final configuration object

The final configuration should be returned as a formatted string containing all set values.

Input & Output

Example 1 — Basic Configuration

$ Input: operations = [["setHost", "localhost"], ["setPort", 8080], ["build"]]

› Output: Config(host=localhost, port=8080)

💡 Note: Builder sets host to localhost, port to 8080, then builds the configuration string

Example 2 — Full Configuration

$ Input: operations = [["setHost", "server.com"], ["setPort", 3306], ["setDatabase", "mydb"], ["setTimeout", 30], ["enableSSL"], ["build"]]

› Output: Config(host=server.com, port=3306, database=mydb, timeout=30, ssl=true)

💡 Note: Builder chains multiple method calls to create a comprehensive configuration

Example 3 — Minimal Configuration

$ Input: operations = [["setDatabase", "testdb"], ["build"]]

› Output: Config(database=testdb)

💡 Note: Builder with only database parameter set, demonstrating optional parameter handling

Constraints

1 ≤ operations.length ≤ 10
Each operation is either a setter method with parameter or build()
String parameters have length ≤ 100
Integer parameters are in range [1, 10000]

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8 f Meta 6

The Builder Pattern solves the problem of creating complex objects with many optional parameters. The key insight is that each method returns the builder instance, enabling fluent method chaining. Best approach uses dedicated ConfigBuilder class with chained methods. Time: O(n), Space: O(1)

Common Approaches

✓ Builder Pattern Implementation

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

The builder pattern creates a separate builder class that accumulates configuration state through method chaining. Each method returns the builder instance, enabling fluent syntax.

Multiple Constructors

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

The naive approach would be to create multiple constructors with different parameter combinations. This quickly becomes unwieldy as the number of optional parameters grows exponentially.

Builder Pattern Implementation — Algorithm Steps

Create ConfigBuilder class with internal state
Each setter method modifies state and returns 'this'
Build method creates final configuration object
Chain methods fluently: builder.setHost().setPort().build()

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Builder

Initialize empty ConfigBuilder with default values

Chain Operations

Execute method calls in sequence, each returning builder

Build Result

Generate final configuration string from accumulated state

Code -

solution.c — C

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

typedef struct {
    char host[100];
    char database[100];
    int port;
    int timeout;
    int retries;
    int ssl;
} ConfigBuilder;

void initConfigBuilder(ConfigBuilder* builder) {
    memset(builder, 0, sizeof(ConfigBuilder));
    builder->port = -1;
    builder->timeout = -1;
    builder->retries = -1;
}

void setHost(ConfigBuilder* builder, const char* host) {
    strcpy(builder->host, host);
}

void setPort(ConfigBuilder* builder, int port) {
    builder->port = port;
}

void setDatabase(ConfigBuilder* builder, const char* database) {
    strcpy(builder->database, database);
}

void setTimeout(ConfigBuilder* builder, int timeout) {
    builder->timeout = timeout;
}

void setRetries(ConfigBuilder* builder, int retries) {
    builder->retries = retries;
}

void enableSSL(ConfigBuilder* builder) {
    builder->ssl = 1;
}

char* build(ConfigBuilder* builder) {
    static char result[500];
    char parts[400] = "";
    int first = 1;
    
    if (strlen(builder->host) > 0) {
        if (!first) strcat(parts, ", ");
        strcat(parts, "host=");
        strcat(parts, builder->host);
        first = 0;
    }
    if (builder->port != -1) {
        if (!first) strcat(parts, ", ");
        char temp[20];
        sprintf(temp, "port=%d", builder->port);
        strcat(parts, temp);
        first = 0;
    }
    if (strlen(builder->database) > 0) {
        if (!first) strcat(parts, ", ");
        strcat(parts, "database=");
        strcat(parts, builder->database);
        first = 0;
    }
    if (builder->timeout != -1) {
        if (!first) strcat(parts, ", ");
        char temp[20];
        sprintf(temp, "timeout=%d", builder->timeout);
        strcat(parts, temp);
        first = 0;
    }
    if (builder->retries != -1) {
        if (!first) strcat(parts, ", ");
        char temp[20];
        sprintf(temp, "retries=%d", builder->retries);
        strcat(parts, temp);
        first = 0;
    }
    if (builder->ssl) {
        if (!first) strcat(parts, ", ");
        strcat(parts, "ssl=true");
        first = 0;
    }
    
    sprintf(result, "Config(%s)", parts);
    return result;
}

char* solution() {
    ConfigBuilder builder;
    initConfigBuilder(&builder);
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char* ptr = line;
    while ((ptr = strstr(ptr, "[")) != NULL) {
        ptr++;
        if (strncmp(ptr, "\"setHost\"", 9) == 0) {
            char* valueStart = strstr(ptr, ",");
            if (valueStart) {
                valueStart += 2;
                char* valueEnd = strstr(valueStart, "\"");
                if (valueEnd) {
                    char host[100];
                    strncpy(host, valueStart, valueEnd - valueStart);
                    host[valueEnd - valueStart] = 0;
                    setHost(&builder, host);
                }
            }
        } else if (strncmp(ptr, "\"setPort\"", 9) == 0) {
            char* valueStart = strstr(ptr, ",");
            if (valueStart) {
                setPort(&builder, atoi(valueStart + 1));
            }
        } else if (strncmp(ptr, "\"setDatabase\"", 13) == 0) {
            char* valueStart = strstr(ptr, ",");
            if (valueStart) {
                valueStart += 2;
                char* valueEnd = strstr(valueStart, "\"");
                if (valueEnd) {
                    char database[100];
                    strncpy(database, valueStart, valueEnd - valueStart);
                    database[valueEnd - valueStart] = 0;
                    setDatabase(&builder, database);
                }
            }
        } else if (strncmp(ptr, "\"setTimeout\"", 12) == 0) {
            char* valueStart = strstr(ptr, ",");
            if (valueStart) {
                setTimeout(&builder, atoi(valueStart + 1));
            }
        } else if (strncmp(ptr, "\"setRetries\"", 12) == 0) {
            char* valueStart = strstr(ptr, ",");
            if (valueStart) {
                setRetries(&builder, atoi(valueStart + 1));
            }
        } else if (strncmp(ptr, "\"enableSSL\"", 11) == 0) {
            enableSSL(&builder);
        } else if (strncmp(ptr, "\"build\"", 7) == 0) {
            return build(&builder);
        }
        
        ptr = strstr(ptr, "]");
        if (!ptr) break;
    }
    
    return build(&builder);
}

int main() {
    printf("%s\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear time to process n operations

✓ Linear Growth

Space Complexity

O(1)

Single builder instance stores configuration state

✓ Linear Space

32.1K Views

Medium Frequency

~25 min Avg. Time

892 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

Builder Pattern Config - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Builder Pattern Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler