Config File Reader - Problem

You need to build a robust config file reader that can handle various error conditions gracefully.

Your task: Read key=value pairs from a config file and return a dictionary/map. The function should handle:

Missing file: Return empty dictionary
Malformed lines: Skip lines that don't follow key=value format
Missing keys: Skip empty keys or values
Whitespace: Trim spaces around keys and values

Input: A string representing the file path

Output: A dictionary/map of successfully parsed key-value pairs

Note: For this problem, file content is simulated - the filepath parameter contains the actual file content as a string with newlines.

Input & Output

Example 1 — Basic Config File

$ Input: filepath = "host=localhost\nport=8080\ndebug=true"

› Output: {"host":"localhost","port":"8080","debug":"true"}

💡 Note: Successfully parses three valid key=value pairs from the config content

Example 2 — With Malformed Lines

$ Input: filepath = "host=localhost\ninvalid line\nport=8080\n=empty_key\ndebug=true"

› Output: {"host":"localhost","port":"8080","debug":"true"}

💡 Note: Skips 'invalid line' (no =) and '=empty_key' (empty key), keeps only valid entries

Example 3 — Empty File

$ Input: filepath = ""

› Output: {}

💡 Note: Empty file content returns empty dictionary

Constraints

File content length ≤ 10⁴ characters
Maximum 100 key-value pairs
Key and value lengths ≤ 256 characters each

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 30 M Microsoft 20 f Meta 15

The key insight is to validate each line during parsing rather than attempting to fix malformed entries. The optimal approach uses single-pass parsing with error handling - check for '=' character, trim whitespace, validate non-empty keys/values, and skip invalid lines gracefully. Time: O(n), Space: O(k) where k is valid pairs.

Common Approaches

✓ Basic Line-by-Line Parsing

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

Read file content line by line and attempt to split each line on '=' character. No validation or error handling for malformed lines or missing values.

Robust Error-Handling Parser

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

Enhanced parsing with proper error handling, whitespace trimming, and validation of keys and values. Skips malformed lines instead of crashing.

Basic Line-by-Line Parsing — Algorithm Steps

Split file content into lines
For each line, split on '=' character
Add key-value pair to result dictionary
Return dictionary

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Content

Break file content into individual lines

Parse Lines

Split each line on '=' character

Store Pairs

Add key-value pairs to result dictionary

Code -

solution.c — C

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

#define MAX_LINE 1000
#define MAX_PAIRS 100

typedef struct {
    char key[256];
    char value[256];
} KeyValue;

typedef struct {
    KeyValue pairs[MAX_PAIRS];
    int count;
} ConfigMap;

ConfigMap solution(char* filepath) {
    ConfigMap result;
    result.count = 0;
    
    if (strlen(filepath) == 0) {
        return result;
    }
    
    char* line = strtok(filepath, "\n");
    
    while (line != NULL && result.count < MAX_PAIRS) {
        char* equals = strchr(line, '=');
        if (equals != NULL) {
            *equals = '\0';
            char* key = line;
            char* value = equals + 1;
            
            if (strlen(key) > 0 && strlen(value) > 0) {
                strcpy(result.pairs[result.count].key, key);
                strcpy(result.pairs[result.count].value, value);
                result.count++;
            }
        }
        line = strtok(NULL, "\n");
    }
    
    return result;
}

int main() {
    char filepath[MAX_LINE];
    fgets(filepath, sizeof(filepath), stdin);
    filepath[strcspn(filepath, "\n")] = 0;
    
    ConfigMap result = solution(filepath);
    
    printf("{");
    for (int i = 0; i < result.count; i++) {
        if (i > 0) printf(",");
        printf("\"%s\":\"%s\"", result.pairs[i].key, result.pairs[i].value);
    }
    printf("}\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n lines of file content

✓ Linear Growth

Space Complexity

O(k)

Storage for k valid key-value pairs in result dictionary

✓ 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

Config File Reader - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Basic Line-by-Line Parsing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler