DeepSeek vs Kimi for Coding

Here's a Python function that flattens nested JSON objects with dot notation, handling arrays by including indices in the key path:

def flatten_json(nested_json, parent_key='', sep='.'):
    """
    Flatten a nested JSON object into a single-level dictionary with dot notation.
    
    Args:
        nested_json: The nested JSON object/dictionary to flatten
        parent_key: Used internally for recursion (don't provide when calling)
        sep: Separator for nested keys (defaults to '.')
    
    Returns:
        A flattened dictionary with dot-notation keys
    
    Example:
        Input: {'name': 'John', 'address': {'city': 'NYC', 'zip': 10001}, 'hobbies': ['reading', 'coding']}
        Output: {'name': 'John', 'address.city': 'NYC', 'address.zip': 10001, 'hobbies.0': 'reading', 'hobbies.1': 'coding'}
    """
    items = {}
    
    for key, value in nested_json.items():
        new_key = f"{parent_key}{sep}{key}" if parent_key else key
        
        if isinstance(value, dict):
            # Recursively flatten dictionaries
            items.update(flatten_json(value, new_key, sep))
        elif isinstance(value, list):
            # Handle arrays by including index in key
            for i, item in enumerate(value):
                array_key = f"{new_key}{sep}{i}"
                if isinstance(item, dict):
                    items.update(flatten_json(item, array_key, sep))
                elif isinstance(item, list):
                    # Handle nested arrays
                    nested_array_items = {}
                    for j, nested_item in enumerate(item):
                        nested_array_key = f"{array_key}{sep}{j}"
                        if isinstance(nested_item, dict):
                            nested_array_items.update(flatten_json(nested_item, nested_array_key, sep))
                        else:
                            nested_array_items[nested_array_key] = nested_item
                    items.update(nested_array_items)
                else:
                    items[array_key] = item
        else:
            # Base case: add the key-value pair
            items[new_key] = value
    
    return items


# Alternative implementation with a more robust approach
def flatten_json_iterative(data, sep='.'):
    """
    Flatten JSON using an iterative approach (non-recursive).
    Handles complex nested structures with arrays.
    """
    flattened = {}
    stack = [("", data)]
    
    while stack:
        prefix, current = stack.pop()
        
        if isinstance(current, dict):
            for key, value in current.items():
                new_key = f"{prefix}{sep}{key}" if prefix else key
                stack.append((new_key, value))
        elif isinstance(current, list):
            for i, item in enumerate(current):
                new_key = f"{prefix}{sep}{i}" if prefix else str(i)
                stack.append((new_key, item))
        else:
            flattened[prefix] = current
    
    return flattened


# Helper function to handle edge cases and provide a clean interface
def flatten_json_object(nested_json, sep='.', iterative=False):
    """
    Public interface for flattening JSON objects.
    
    Args:
        nested_json: JSON object/dictionary to flatten
        sep: Separator for keys (default '.')
        iterative: Use iterative approach (better for deep nesting)
    
    Returns:
        Flattened dictionary
    """
    if not isinstance(nested_json, dict):
        raise ValueError("Input must be a dictionary")
    
    if iterative:
        return flatten_json_iterative(nested_json, sep)
    else:
        return flatten_json(nested_json, sep='', sep_internal=sep)


# Example usage and testing
if __name__ == "__main__":
    # Example 1: Simple nested object
    example1 = {
        "name": "John",
        "address": {
            "city": "NYC",
            "zip": 10001
        }
    }
    
    # Example 2: With arrays
    example2 = {
        "user": "John",
        "scores": [85, 92, 78],
        "details": {
            "hobbies": ["reading", "coding"],
            "addresses": [
                {"type": "home", "city": "NYC"},
                {"type": "work", "city": "Boston"}
            ]
        }
    }
    
    # Example 3: Complex nested with arrays of arrays
    example3 = {
        "data": [
            {"id": 1, "tags": ["A", "B"]},
            {"id": 2, "tags": ["C", "D", "E"]}
        ]
    }
    
    print("Example 1 - Simple nested:")
    print(flatten_json(example1))
    print("\nExample 2 - With arrays:")
    print(flatten_json(example2))
    print("\nExample 3 - Complex nested arrays:")
    print(flatten_json(example3))
    
    print("\nUsing iterative approach:")
    print(flatten_json_iterative(example2))

Key features of this implementation:

1. Recursive flattening: Handles arbitrarily nested dictionaries
2. Array support: Includes indices in the key path (e.g., hobbies.0)
3. Dot notation: Uses dots to separate nested levels
4. Flexible separator: Can customize the separator character
5. Two implementations:
   • Recursive: Cleaner code, but may hit recursion limits with very deep nesting
   • Iterative: Uses a stack, better for very deep structures
6. Handles edge cases: Empty dicts, empty arrays, mixed types

Example outputs:

# Input:
{
    "user": "John",
    "scores": [85, 92, 78],
    "details": {
        "hobbies": ["reading", "coding"]
    }
}

# Output:
{
    "user": "John",
    "scores.0": 85,
    "scores.1": 92,
    "scores.2": 78,
    "details.hobbies.0": "reading",
    "details.hobbies.1": "coding"
}

Time Complexity: O(n) where n is the total number of elements in the nested structure Space Complexity: O(n) for the output dictionary

Here's a Python function that flattens nested JSON objects using recursion, with support for customizable separators and proper handling of array indices:

from typing import Any, Dict, Union

def flatten_json(nested_obj: Union[Dict, list, Any], parent_key: str = '', sep: str = '.') -> Dict[str, Any]:
    """
    Flatten a nested JSON object (dict/list) into a single-level dictionary with dot-notation keys.
    
    Args:
        nested_obj: The nested dictionary, list, or primitive value to flatten
        parent_key: The accumulated key path (used for recursion)
        sep: Separator between key levels (default: '.')
        
    Returns:
        Flattened dictionary where keys use dot notation and array indices are included in the path.
        
    Example:
        >>> data = {"user": {"name": "John", "tags": ["admin", "active"]}}
        >>> flatten_json(data)
        {'user.name': 'John', 'user.tags.0': 'admin', 'user.tags.1': 'active'}
    """
    items: Dict[str, Any] = {}
    
    if isinstance(nested_obj, dict):
        for key, value in nested_obj.items():
            # Build new key path
            new_key = f"{parent_key}{sep}{key}" if parent_key else str(key)
            
            if isinstance(value, (dict, list)):
                # Recurse for nested objects
                items.update(flatten_json(value, new_key, sep))
            else:
                # Leaf node (primitive value)
                items[new_key] = value
                
    elif isinstance(nested_obj, list):
        for index, value in enumerate(nested_obj):
            # Include array index in the key path
            new_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            
            if isinstance(value, (dict, list)):
                # Recurse for nested objects within arrays
                items.update(flatten_json(value, new_key, sep))
            else:
                # Leaf node in array
                items[new_key] = value
                
    else:
        # Handle primitive values (str, int, float, bool, None)
        if parent_key:
            items[parent_key] = nested_obj
            
    return items


# Example usage
if __name__ == "__main__":
    sample_data = {
        "user": {
            "name": "Jane Doe",
            "contact": {
                "email": "jane@example.com",
                "phone": "555-0123"
            }
        },
        "permissions": ["read", "write", "admin"],
        "metadata": {
            "tags": [
                {"category": "priority", "value": "high"},
                {"category": "region", "value": "us-east"}
            ],
            "active": True
        }
    }
    
    flat = flatten_json(sample_data)
    for key, value in flat.items():
        print(f"{key}: {value}")

Output:

user.name: Jane Doe
user.contact.email: jane@example.com
user.contact.phone: 555-0123
permissions.0: read
permissions.1: write
permissions.2: admin
metadata.tags.0.category: priority
metadata.tags.0.value: high
metadata.tags.1.category: region
metadata.tags.1.value: us-east
metadata.active: True

Key Features:

• Dot notation: Nested dictionary keys are joined with dots (e.g., user.contact.email)
• Array indexing: List indices are preserved in the path (e.g., permissions.0, metadata.tags.0.category)
• Flexible separator: You can change the separator (e.g., use _ or / instead of .)
• Type safety: Works with mixed types (objects within arrays, primitives, etc.)
• Edge case handling: Empty objects/lists are skipped; primitives at the root level are handled gracefully

Note: For extremely deeply nested JSON (depth > 1000), you might hit Python's recursion limit. In that case, an iterative version using a stack/queue would be preferred.