CSV Parser - Problem

Parse CSV (Comma-Separated Values) data while handling advanced formatting rules. Your parser must correctly handle:

Quoted fields - Text enclosed in double quotes
Commas within quotes - Commas inside quoted fields don't separate columns
Escaped quotes - Double quotes within quoted fields are escaped as ""
Newlines within fields - Line breaks inside quoted fields are preserved

Return a 2D array where each sub-array represents a row of parsed fields.

Input & Output

Example 1 — Basic Quoted Fields

$ Input: csvData = "Name,Age,City\nJohn,25,NYC\n"Alice,30",Boston"

› Output: [["Name","Age","City"],["John","25","NYC"],["Alice,30","Boston"]]

💡 Note: First two rows are simple comma-separated values. Third row has a quoted field "Alice,30" where the comma is preserved within the quotes.

Example 2 — Escaped Quotes

$ Input: csvData = "Product,Description\n""Premium"",""High quality"""

› Output: [["Product","Description"],["Premium","High quality"]]

💡 Note: The field contains escaped quotes ("") which become single quotes in the output. ""Premium"" becomes "Premium".

Example 3 — Newlines in Fields

$ Input: csvData = "Name,Bio\n"John","Software\nDeveloper""

› Output: [["Name","Bio"],["John","Software\nDeveloper"]]

💡 Note: The quoted field preserves the newline character within it, so the bio field contains a line break.

Constraints

1 ≤ csvData.length ≤ 10⁴
csvData contains valid CSV format
Quoted fields properly closed
Escaped quotes use "" format

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 28

The key insight is to use a state machine that tracks whether we're inside or outside quoted fields. The optimal approach processes each character once, maintaining quote state and handling escapes properly. Time: O(n), Space: O(n)

Common Approaches

✓ Character-by-Character with Backtracking

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

Split the CSV data by commas initially, then scan through the results to find fields that start or end with quotes and merge them back together with their neighbors until properly matched.

State Machine Parser

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

Process each character once while maintaining state about whether we're currently inside or outside quoted fields, handling escapes and newlines properly.

Character-by-Character with Backtracking — Algorithm Steps

Split input by commas into initial fields
Scan for fields starting with quotes
Merge consecutive fields until closing quote found
Handle escaped quotes by checking for double quotes

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Split

Split by every comma, breaking quoted fields incorrectly

Identify Quotes

Find fields that start or end with quotes

Merge Back

Combine consecutive fields until quotes are matched

Code -

solution.c — C

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

char*** solution(char* csvData, int* rowCount, int** colCounts) {
    char*** result = malloc(100 * sizeof(char**));
    *rowCount = 0;
    *colCounts = malloc(100 * sizeof(int));
    
    char* line = strtok(csvData, "\n");
    
    while (line != NULL) {
        if (strlen(line) == 0) {
            line = strtok(NULL, "\n");
            continue;
        }
        
        char** fields = malloc(100 * sizeof(char*));
        int fieldCount = 0;
        
        char* field = strtok(line, ",");
        while (field != NULL) {
            fields[fieldCount] = malloc(1000 * sizeof(char));
            strcpy(fields[fieldCount], field);
            fieldCount++;
            field = strtok(NULL, ",");
        }
        
        char** mergedFields = malloc(100 * sizeof(char*));
        int mergedCount = 0;
        int i = 0;
        
        while (i < fieldCount) {
            char* currentField = malloc(2000 * sizeof(char));
            strcpy(currentField, fields[i]);
            
            if (currentField[0] == '"') {
                while (i < fieldCount - 1 && currentField[strlen(currentField) - 1] != '"') {
                    i++;
                    strcat(currentField, ",");
                    strcat(currentField, fields[i]);
                }
                
                if (currentField[0] == '"' && currentField[strlen(currentField) - 1] == '"') {
                    memmove(currentField, currentField + 1, strlen(currentField));
                    currentField[strlen(currentField) - 1] = '\0';
                    
                    char* pos = strstr(currentField, "\"\"");
                    while (pos != NULL) {
                        memmove(pos, pos + 1, strlen(pos));
                        pos = strstr(pos + 1, "\"\"");
                    }
                }
            }
            
            mergedFields[mergedCount] = currentField;
            mergedCount++;
            i++;
        }
        
        result[*rowCount] = mergedFields;
        (*colCounts)[*rowCount] = mergedCount;
        (*rowCount)++;
        
        for (int j = 0; j < fieldCount; j++) {
            free(fields[j]);
        }
        free(fields);
        
        line = strtok(NULL, "\n");
    }
    
    return result;
}

int main() {
    char csvData[10000];
    fgets(csvData, sizeof(csvData), stdin);
    csvData[strcspn(csvData, "\n")] = 0;
    
    int rowCount;
    int* colCounts;
    char*** result = solution(csvData, &rowCount, &colCounts);
    
    printf("[");
    for (int i = 0; i < rowCount; i++) {
        printf("[");
        for (int j = 0; j < colCounts[i]; j++) {
            printf("\"%s\"", result[i][j]);
            if (j < colCounts[i] - 1) printf(",");
        }
        printf("]");
        if (i < rowCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

May need to scan and merge fields multiple times, especially for long quoted sections

✓ Linear Growth

Space Complexity

O(n)

Stores intermediate split results plus final parsed data

⚡ Linearithmic Space

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

CSV Parser - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Character-by-Character with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler