Deep Object Filter - Practice Coding Problems

Deep Object Filter - Problem

Database Medium

Deep Object Filter Challenge

Imagine you're building a data cleaning system that needs to intelligently filter complex nested data structures. You're given an object or array obj and a filter function fn, and your task is to create a deep filtering mechanism that not only removes unwanted elements but also cleans up the structure.

The deepFilter function should:
• Apply the filter function fn to each value in the nested structure
• Remove properties/elements where fn returns false
• Clean up empty objects and arrays that remain after filtering
• Return undefined if the entire structure becomes empty

This is like having a smart vacuum cleaner that not only removes dirt but also tidies up empty containers afterwards! The challenge lies in handling deeply nested structures while maintaining the original data types and relationships.

Input & Output

basic_filtering.py — Python

$ Input: obj = {"a": 1, "b": {"c": 2, "d": 4}, "e": [3, 5]} fn = lambda x: x > 2

› Output: {"b": {"d": 4}, "e": [3, 5]}

💡 Note: Values 1 and 2 are filtered out. The nested object 'b' keeps only 'd': 4, and array 'e' keeps both 3 and 5.

empty_cleanup.py — Python

$ Input: obj = {"a": 1, "b": {"c": 1}, "d": [1, 1]} fn = lambda x: x > 5

› Output: undefined

💡 Note: All values fail the filter (x > 5). After removing them, all containers become empty and are cleaned up, resulting in undefined.

nested_arrays.py — Python

$ Input: obj = [1, [2, [3, 4]], {"x": 5}] fn = lambda x: x % 2 == 0

› Output: [[2, [4]], {}]

💡 Note: Only even numbers pass the filter. The nested structure is preserved, but the object becomes empty and is cleaned up to {}.

Constraints

1 ≤ total number of elements ≤ 10⁴
Maximum nesting depth ≤ 100
Values can be primitives (number, string, boolean) or nested objects/arrays
Filter function will always return a boolean value
Objects can have string keys only

Visualization

Tap to expand

Understanding the Visualization

Enter Section

Start at the library entrance and systematically visit each section

Check Books

At each shelf, examine individual books using your criteria

Filter Content

Remove books that don't meet the criteria (outdated, damaged, etc.)

Clean Shelves

As you finish each shelf, remove it if it's completely empty

Clean Sections

When exiting a section, remove it if all its shelves were removed

Final Result

The library is now clean with only relevant books and no empty containers

Key Takeaway

🎯 Key Insight: Recursion naturally provides the backtracking needed to clean up empty containers as we return from deeper levels, making the solution both elegant and efficient.

Asked in

f Meta 45 G Google 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a single recursive traversal to filter values and clean up empty containers simultaneously. By leveraging recursion's natural backtracking, we can efficiently process nested structures in O(n) time with O(d) space complexity, where d is the maximum nesting depth.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Passes)	O(n²)	O(n)	Apply filter multiple times until no more changes occur
Single Pass Recursion (Optimal)	O(n)	O(d)	Recursive approach that filters and cleans in one traversal

Brute Force (Multiple Passes) — Algorithm Steps

Apply filter function to all leaf values
Remove empty objects and arrays
Repeat until no changes occur
Return undefined if final result is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Apply filter function to all leaf values

Clean Empty

Remove empty objects and arrays

Repeat

Continue until no changes occur

Code -

solution.c — C

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

typedef enum {
    TYPE_INT,
    TYPE_STRING,
    TYPE_OBJECT,
    TYPE_ARRAY
} ValueType;

typedef struct Value {
    ValueType type;
    union {
        int intVal;
        char* stringVal;
        struct Object* objectVal;
        struct Array* arrayVal;
    } data;
} Value;

typedef struct KeyValue {
    char* key;
    Value* value;
    struct KeyValue* next;
} KeyValue;

typedef struct Object {
    KeyValue* pairs;
    int count;
} Object;

typedef struct Array {
    Value** items;
    int count;
    int capacity;
} Array;

Value* deepFilter(Value* obj, bool (*fn)(Value*)) {
    Value* prev = NULL;
    Value* current = copyValue(obj);
    
    while (!valuesEqual(prev, current)) {
        if (prev) freeValue(prev);
        prev = copyValue(current);
        
        Value* filtered = applyFilter(current, fn);
        freeValue(current);
        current = removeEmpty(filtered);
    }
    
    if (prev) freeValue(prev);
    return current;
}

Value* applyFilter(Value* data, bool (*fn)(Value*)) {
    if (!data) return NULL;
    
    switch (data->type) {
        case TYPE_OBJECT: {
            Object* newObj = createObject();
            KeyValue* pair = data->data.objectVal->pairs;
            while (pair) {
                Value* value = pair->value;
                if (value->type == TYPE_OBJECT || value->type == TYPE_ARRAY) {
                    Value* filtered = applyFilter(value, fn);
                    if (filtered) {
                        addToObject(newObj, pair->key, filtered);
                    }
                } else if (fn(value)) {
                    addToObject(newObj, pair->key, copyValue(value));
                }
                pair = pair->next;
            }
            Value* result = malloc(sizeof(Value));
            result->type = TYPE_OBJECT;
            result->data.objectVal = newObj;
            return result;
        }
        case TYPE_ARRAY: {
            Array* newArr = createArray();
            for (int i = 0; i < data->data.arrayVal->count; i++) {
                Value* item = data->data.arrayVal->items[i];
                if (item->type == TYPE_OBJECT || item->type == TYPE_ARRAY) {
                    Value* filtered = applyFilter(item, fn);
                    if (filtered) {
                        addToArray(newArr, filtered);
                    }
                } else if (fn(item)) {
                    addToArray(newArr, copyValue(item));
                }
            }
            Value* result = malloc(sizeof(Value));
            result->type = TYPE_ARRAY;
            result->data.arrayVal = newArr;
            return result;
        }
        default:
            return copyValue(data);
    }
}

Value* removeEmpty(Value* data) {
    if (!data) return NULL;
    
    switch (data->type) {
        case TYPE_OBJECT: {
            Object* newObj = createObject();
            KeyValue* pair = data->data.objectVal->pairs;
            while (pair) {
                Value* cleaned = removeEmpty(pair->value);
                if (cleaned && !isEmpty(cleaned)) {
                    addToObject(newObj, pair->key, cleaned);
                }
                pair = pair->next;
            }
            if (newObj->count == 0) {
                freeObject(newObj);
                return NULL;
            }
            Value* result = malloc(sizeof(Value));
            result->type = TYPE_OBJECT;
            result->data.objectVal = newObj;
            return result;
        }
        case TYPE_ARRAY: {
            Array* newArr = createArray();
            for (int i = 0; i < data->data.arrayVal->count; i++) {
                Value* cleaned = removeEmpty(data->data.arrayVal->items[i]);
                if (cleaned && !isEmpty(cleaned)) {
                    addToArray(newArr, cleaned);
                }
            }
            if (newArr->count == 0) {
                freeArray(newArr);
                return NULL;
            }
            Value* result = malloc(sizeof(Value));
            result->type = TYPE_ARRAY;
            result->data.arrayVal = newArr;
            return result;
        }
        default:
            return copyValue(data);
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, need multiple passes through all n elements

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store intermediate filtered versions

⚡ Linearithmic Space

67.2K Views

High Frequency

~25 min Avg. Time

1.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 (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler