Convert Object to JSON String - Practice Coding Problems

Convert Object to JSON String - Problem

JavaScript Medium

Given a value, return a valid JSON string representation of that value. The value can be a string, number, array, object, boolean, or null.

The returned string should not include extra spaces and the order of keys should be the same as the order returned by Object.keys().

Important: You cannot use the built-in JSON.stringify method.

Input & Output

Example 1 — Basic String

$ Input: value = "hello"

› Output: "\"hello\""

💡 Note: String values need to be wrapped in quotes and escaped properly

Example 2 — Simple Array

$ Input: value = [1, 2, 3]

› Output: [1,2,3]

💡 Note: Array elements are converted recursively and joined with commas, no spaces

Example 3 — Object with Mixed Types

$ Input: value = {"name": "John", "age": 30, "active": true}

› Output: "{\"name\":\"John\",\"age\":30,\"active\":true}"

💡 Note: Object keys and values are converted recursively, maintaining key order

Constraints

The value can be any valid JavaScript data type
Objects will have at most 1000 keys
Arrays will have at most 1000 elements
Maximum nesting depth is 100 levels
String values will not exceed 10000 characters

Visualization

Tap to expand

Understanding the Visualization

Input

JavaScript value of any type (string, number, array, object, etc.)

Process

Apply JSON formatting rules recursively

Output

Valid JSON string representation

Key Takeaway

🎯 Key Insight: Recursion naturally mirrors the nested structure of JSON data

Asked in

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

The key insight is to use recursion to naturally handle nested structures. The recursive approach elegantly processes each data type and calls itself for nested objects and arrays. Time: O(n), Space: O(d) where d is nesting depth.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Approach	O(n)	O(d)	Use recursion to elegantly handle nested structures
Brute Force Type Checking	O(n)	O(1)	Use multiple if-else statements to handle each data type separately

Recursive Approach — Algorithm Steps

Step 1: Base cases for primitive types (null, boolean, number, string)
Step 2: Recursive cases for arrays and objects
Step 3: Proper string escaping and formatting

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

Handle primitive types directly

Recursive Case

Call solution() on nested elements

Combine

Build final JSON string from parts

Code -

solution.c — C

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

char* escapeString(const char* str) {
    int len = strlen(str);
    char* result = malloc(len * 2 + 3);
    int j = 0;
    
    for (int i = 0; i < len; i++) {
        if (str[i] == '\\') {
            result[j++] = '\\';
            result[j++] = '\\';
        } else if (str[i] == '"') {
            result[j++] = '\\';
            result[j++] = '"';
        } else if (str[i] == '\n') {
            result[j++] = '\\';
            result[j++] = 'n';
        } else if (str[i] == '\r') {
            result[j++] = '\\';
            result[j++] = 'r';
        } else if (str[i] == '\t') {
            result[j++] = '\\';
            result[j++] = 't';
        } else {
            result[j++] = str[i];
        }
    }
    result[j] = '\0';
    return result;
}

char* solution(const char* value) {
    char* result = malloc(2000);
    
    if (strcmp(value, "null") == 0) {
        strcpy(result, "null");
    } else if (strcmp(value, "true") == 0 || strcmp(value, "false") == 0) {
        strcpy(result, value);
    } else if ((value[0] >= '0' && value[0] <= '9') || value[0] == '-') {
        strcpy(result, value);
    } else {
        char* escaped = escapeString(value);
        sprintf(result, "\"%s\"", escaped);
        free(escaped);
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each value exactly once where n is total number of values in the structure

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth d equals maximum nesting level of the input

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Recursive Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler