Compact Object - Practice Coding Problems

Compact Object - Problem

JavaScript Medium

Compact Object Challenge

Imagine you have a messy JSON object or array filled with unnecessary falsy values that are cluttering your data structure. Your mission is to clean it up by creating a compact version!

Given an object or array obj, return a compact object where all keys containing falsy values have been removed. This cleaning process should work recursively on nested objects and arrays too.

What counts as falsy? Any value where Boolean(value) returns false:
• false, 0, -0, 0n, "", null, undefined, NaN

Important: Arrays are treated as objects where indices are keys. The input is guaranteed to be valid JSON (output of JSON.parse).

Input & Output

example_1.py — Basic Object Cleaning

$ Input: {"a": null, "b": ["x", 0, false, 1], "c": {"d": "", "e": "hello"}}

› Output: {"b": ["x", 1], "c": {"e": "hello"}}

💡 Note: Removes 'a' (null), filters array 'b' to remove 0 and false, removes 'd' from nested object 'c' due to empty string

example_2.py — Array Compaction

$ Input: [null, 0, 5, "", true, false, NaN]

› Output: [5, true]

💡 Note: Keeps only truthy values: 5 and true. Removes null, 0, empty string, false, and NaN

example_3.py — Nested Structure Edge Case

$ Input: {"a": {"b": null}, "c": [0, false, ""], "d": {}}

› Output: {}

💡 Note: All nested structures become empty after cleaning, so the entire object becomes empty. Object 'a' becomes {}, array 'c' becomes [], and 'd' is already {}

Constraints

The input obj is a valid JSON object (output of JSON.parse)
Object keys are always strings
Values can be: objects, arrays, strings, numbers, booleans, or null
Maximum nesting depth: 100 levels
Maximum number of properties: 10⁴

Visualization

Tap to expand

Understanding the Visualization

Start at Top Level

Begin examining the main filing cabinet

Open Each Drawer

For each drawer (object key/array index), examine contents

Recursive Deep Clean

If drawer contains sub-drawers, clean those first

Remove Junk

Discard empty folders, blank documents, corrupted files

Final Assembly

Keep only useful items in a clean, organized structure

Key Takeaway

🎯 Key Insight: Recursive cleaning ensures that even deeply nested structures are properly compacted, and empty containers created during the process are removed for a truly clean result.

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 35 f Meta 28

The optimal solution uses recursive traversal to deeply clean nested structures. For each container (object/array), we recursively clean all children first, then filter out falsy values. This ensures that empty containers created after cleaning are also removed, resulting in a truly compact object in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simple Iteration)	O(n)	O(n)	Iterate through all properties and copy non-falsy values to new object
Recursive Deep Cleaning (Optimal)	O(n)	O(d)	Recursively traverse and clean all nested structures in a single pass

Brute Force (Simple Iteration) — Algorithm Steps

Check if input is an array or object
Create a new container of the same type
Iterate through all properties/indices
Copy only truthy values to the new container
Return the new container

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Type

Determine if input is array or object

Create Container

Initialize new array or object

Filter Values

Copy only truthy values (misses nested structures)

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

cJSON* compactObject(cJSON* obj) {
    if (cJSON_IsArray(obj)) {
        cJSON* result = cJSON_CreateArray();
        cJSON* item = NULL;
        cJSON_ArrayForEach(item, obj) {
            if (!cJSON_IsFalse(item) && !cJSON_IsNull(item) && 
                !(cJSON_IsString(item) && strlen(cJSON_GetStringValue(item)) == 0) &&
                !(cJSON_IsNumber(item) && cJSON_GetNumberValue(item) == 0)) {
                cJSON_AddItemToArray(result, cJSON_Duplicate(item, 1));
            }
        }
        return result;
    } else if (cJSON_IsObject(obj)) {
        cJSON* result = cJSON_CreateObject();
        cJSON* item = NULL;
        cJSON_ArrayForEach(item, obj) {
            if (!cJSON_IsFalse(item) && !cJSON_IsNull(item) && 
                !(cJSON_IsString(item) && strlen(cJSON_GetStringValue(item)) == 0) &&
                !(cJSON_IsNumber(item) && cJSON_GetNumberValue(item) == 0)) {
                cJSON_AddItemToObject(result, item->string, cJSON_Duplicate(item, 1));
            }
        }
        return result;
    }
    return cJSON_Duplicate(obj, 1);
}

int main() {
    char buffer[10000];
    fgets(buffer, sizeof(buffer), stdin);
    cJSON* json = cJSON_Parse(buffer);
    cJSON* result = compactObject(json);
    char* output = cJSON_Print(result);
    printf("%s\n", output);
    free(output);
    cJSON_Delete(json);
    cJSON_Delete(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each property once, where n is the number of properties

✓ Linear Growth

Space Complexity

O(n)

We create a new object/array with up to n properties

⚡ Linearithmic Space

89.4K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force (Simple Iteration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler