Convert JSON String to Object

Convert JSON String to Object - Problem

JavaScript Hard

Given a string str, return the parsed JSON object parsedStr. You may assume the str is a valid JSON string that only includes strings, numbers, arrays, objects, booleans, and null. The string will not include invisible characters and escape characters.

Please solve it without using the built-in JSON.parse method.

Input & Output

Example 1 — Simple Object

$ Input: str = "{\"name\":\"John\",\"age\":30}"

› Output: {"name":"John","age":30}

💡 Note: Parse JSON object with string and number values. The parser identifies the object structure and extracts key-value pairs.

Example 2 — Array with Mixed Types

$ Input: str = "[1,true,null,\"hello\"]"

› Output: [1,true,null,"hello"]

💡 Note: Parse JSON array containing different data types: number, boolean, null, and string.

Example 3 — Simple String

$ Input: str = "\"hello world\""

› Output: hello world

💡 Note: Parse a simple JSON string by removing the surrounding quotes.

Constraints

1 ≤ str.length ≤ 10⁴
str is a valid JSON string
str contains only printable ASCII characters
No escape sequences in strings

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 A Amazon 8 M Microsoft 6

Convert JSON string to object by implementing a custom parser. The recursive descent parser approach provides clean, maintainable code that naturally handles nested structures. Time: O(n), Space: O(n + d) where d is nesting depth.

Common Approaches

✓ Character-by-Character Parser

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

This approach iterates through each character of the JSON string, maintaining state to determine what type of value is being parsed (object, array, string, number, boolean, null). It uses a simple state machine to handle different contexts.

Recursive Descent Parser

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

This approach uses recursive descent parsing, where each JSON construct (object, array, string, number) has its own parsing function. This creates cleaner code that naturally handles nested structures.

Character-by-Character Parser — Algorithm Steps

Step 1: Initialize parsing position and determine the root type
Step 2: For each character, determine context (inside string, object, array, etc.)
Step 3: Build the appropriate data structure based on current context
Step 4: Handle nested structures by tracking brackets and braces

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Parsing

Begin at first character, determine root type

Parse Elements

Handle strings, numbers, objects, arrays based on context

Build Result

Construct final JavaScript object/array

Code -

solution.c — C

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

char* solution(const char* str) {
    // For this implementation, we'll return a simple string representation
    // This is a simplified version focusing on basic cases
    int len = strlen(str);
    char* result = malloc(len + 1);
    
    // Simple case: if it's a string, remove quotes
    if (str[0] == '"' && str[len-1] == '"') {
        strncpy(result, str + 1, len - 2);
        result[len - 2] = '\0';
        return result;
    }
    
    // For other cases, return as-is (simplified)
    strcpy(result, str);
    return result;
}

int main() {
    char str[10000];
    fgets(str, sizeof(str), stdin);
    str[strcspn(str, "\n")] = 0; // Remove newline
    
    char* result = solution(str);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string examining each character once

✓ Linear Growth

Space Complexity

O(n)

Call stack for nested structures plus result object storage

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Character-by-Character Parser — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler