Gemini vs Claude for Coding

Here is the Python function to achieve this. It uses recursion to traverse the nested JSON (represented as Python dictionaries and lists) and builds the flat dictionary.

def flatten_json(data, parent_key='', sep='.'):
    """
    Flattens a nested JSON object into a single-level dictionary.
    Handles dictionaries and lists/arrays.
    
    :param data: The JSON object (dict or list) to flatten.
    :param parent_key: The base string for the current recursive depth.
    :param sep: The separator to use between keys (default is dot '.').
    :return: A flat dictionary.
    """
    items = {}

    def walk(obj, current_key):
        # If the current object is a dictionary
        if isinstance(obj, dict):
            if not obj and current_key:  # Preserve empty dictionaries
                items[current_key] = obj
            for k, v in obj.items():
                # Append the dictionary key to the path
                new_key = f"{current_key}{sep}{k}" if current_key else str(k)
                walk(v, new_key)
                
        # If the current object is a list/array
        elif isinstance(obj, list):
            if not obj and current_key:  # Preserve empty lists
                items[current_key] = obj
            for i, v in enumerate(obj):
                # Append the list index to the path
                new_key = f"{current_key}{sep}{i}" if current_key else str(i)
                walk(v, new_key)
                
        # If it's a primitive value (string, int, float, bool, None)
        else:
            items[current_key] = obj

    walk(data, parent_key)
    return items

# ==========================================
# Example Usage:
# ==========================================
if __name__ == "__main__":
    nested_json = {
        "user": {
            "name": "Alice",
            "age": 30,
            "contact": {
                "email": "alice@example.com",
                "phones": ["123-456-7890", "987-654-3210"]
            }
        },
        "settings": [
            {"theme": "dark", "notifications": True},
            {"theme": "light", "notifications": False}
        ],
        "empty_data": [],
        "status": "active"
    }

    flat_json = flatten_json(nested_json)

    # Pretty print the result
    import json
    print(json.dumps(flat_json, indent=4))

Output of the example:

{
    "user.name": "Alice",
    "user.age": 30,
    "user.contact.email": "alice@example.com",
    "user.contact.phones.0": "123-456-7890",
    "user.contact.phones.1": "987-654-3210",
    "settings.0.theme": "dark",
    "settings.0.notifications": true,
    "settings.1.theme": "light",
    "settings.1.notifications": false,
    "empty_data": [],
    "status": "active"
}

How it works:

1. Helper Function (walk): A nested recursive function is used to keep track of the current_key path.
2. Dictionaries: Iterates through key-value pairs. It joins the existing path with the current key using a dot (.).
3. Lists: Uses enumerate to get the index (0, 1, 2, etc.) and the value. It joins the path with the index using a dot.
4. Primitives: Once it reaches an endpoint (a string, integer, boolean, or None), it finally assigns the value to the accumulated current_key in the items dictionary.
5. Empty structures: Handles edge cases where a list [] or dictionary {} is empty by keeping it in the final structure rather than letting it disappear.

Flatten Nested JSON to Dot-Notation Dictionary

def flatten_json(data, parent_key="", separator="."):
    """
    Flatten a nested JSON object into a single-level dictionary with dot-notation keys.
    
    Args:
        data: The nested JSON object (dict, list, or primitive value).
        parent_key: The base key string for building dot-notation paths.
        separator: The separator character between key segments (default: ".").
    
    Returns:
        A flattened dictionary with dot-notation keys.
    
    Examples:
        >>> flatten_json({"a": {"b": 1}})
        {'a.b': 1}
        
        >>> flatten_json({"a": [1, 2, 3]})
        {'a.0': 1, 'a.1': 2, 'a.2': 3}
    """
    items = {}

    if isinstance(data, dict):
        for key, value in data.items():
            # Build the new key path
            new_key = f"{parent_key}{separator}{key}" if parent_key else str(key)
            # Recursively flatten the value
            items.update(flatten_json(value, new_key, separator))

    elif isinstance(data, list):
        for index, value in enumerate(data):
            # Use index as part of the key path
            new_key = f"{parent_key}{separator}{index}" if parent_key else str(index)
            # Recursively flatten the value
            items.update(flatten_json(value, new_key, separator))

    else:
        # Base case: primitive value (int, float, str, bool, None)
        items[parent_key] = data

    return items


def unflatten_json(data, separator="."):
    """
    Reverse operation: convert a flat dot-notation dictionary back to a nested structure.
    
    Args:
        data: A flat dictionary with dot-notation keys.
        separator: The separator character used in keys (default: ".").
    
    Returns:
        A nested dictionary/list structure.
    """
    result = {}

    for flat_key, value in data.items():
        parts = flat_key.split(separator)
        target = result

        for i, part in enumerate(parts[:-1]):
            next_part = parts[i + 1]

            # Determine if next level should be a list or dict
            if next_part.isdigit():
                target = target.setdefault(part, [])
                # Extend list if necessary
                index = int(parts[i + 1])
                while len(target) <= index:
                    target.append(None)
                # Move deeper, initializing if needed
                if i + 2 < len(parts):
                    next_next = parts[i + 2]
                    if target[index] is None:
                        target[index] = [] if next_next.isdigit() else {}
                    target = target[index]
            else:
                if part.isdigit():
                    part = int(part)
                next_container = [] if next_part.isdigit() else {}
                if isinstance(target, list):
                    while len(target) <= part:
                        target.append(None)
                    if target[part] is None:
                        target[part] = next_container
                    target = target[part]
                else:
                    target = target.setdefault(part, next_container)

        # Set the final value
        last_key = parts[-1]
        if isinstance(target, list):
            index = int(last_key)
            while len(target) <= index:
                target.append(None)
            target[index] = value
        else:
            target[last_key] = value

    return result

---

Usage Examples

if __name__ == "__main__":
    import json

    # ── Example 1: Simple nesting ──────────────────────────────────────────
    simple = {
        "name": "Alice",
        "address": {
            "city": "Wonderland",
            "zip": "12345"
        }
    }
    print("Example 1 – Simple nesting:")
    print(json.dumps(flatten_json(simple), indent=2))
    # {
    #   "name": "Alice",
    #   "address.city": "Wonderland",
    #   "address.zip": "12345"
    # }

    # ── Example 2: Arrays ──────────────────────────────────────────────────
    with_arrays = {
        "scores": [95, 87, 92],
        "tags": ["python", "json"]
    }
    print("\nExample 2 – Arrays:")
    print(json.dumps(flatten_json(with_arrays), indent=2))
    # {
    #   "scores.0": 95,
    #   "scores.1": 87,
    #   "scores.2": 92,
    #   "tags.0": "python",
    #   "tags.1": "json"
    # }

    # ── Example 3: Deeply nested + mixed types ─────────────────────────────
    complex_data = {
        "user": {
            "id": 42,
            "profile": {
                "name": "Bob",
                "hobbies": ["reading", "coding"],
                "address": {
                    "city": "Techville",
                    "coordinates": {"lat": 37.7749, "lon": -122.4194}
                }
            },
            "active": True,
            "score": None
        },
        "meta": [{"key": "version", "value": "1.0"}]
    }
    print("\nExample 3 – Deeply nested + mixed types:")
    flat = flatten_json(complex_data)
    print(json.dumps(flat, indent=2))
    # {
    #   "user.id": 42,
    #   "user.profile.name": "Bob",
    #   "user.profile.hobbies.0": "reading",
    #   "user.profile.hobbies.1": "coding",
    #   "user.profile.address.city": "Techville",
    #   "user.profile.address.coordinates.lat": 37.7749,
    #   "user.profile.address.coordinates.lon": -122.4194,
    #   "user.active": true,
    #   "user.score": null,
    #   "meta.0.key": "version",
    #   "meta.0.value": "1.0"
    # }

    # ── Example 4: Custom separator ────────────────────────────────────────
    print("\nExample 4 – Custom separator '/':")
    print(json.dumps(flatten_json(simple, separator="/"), indent=2))
    # {
    #   "name": "Alice",
    #   "address/city": "Wonderland",
    #   "address/zip": "12345"
    # }

    # ── Example 5: Round-trip (flatten → unflatten) ────────────────────────
    print("\nExample 5 – Round-trip verification:")
    restored = unflatten_json(flat)
    assert restored == complex_data, "Round-trip failed!"
    print("Round-trip successful ✓")
    print(json.dumps(restored, indent=2))

---

Key Design Decisions

Concern	Approach
Arrays	Index becomes a path segment (e.g., list.0, list.1)
Primitives	int, float, str, bool, None are all stored as-is
Empty containers	Empty {} and [] produce no keys (intentional — no data to store)
Custom separator	Configurable; useful when keys may contain .
Recursion	Clean recursive approach; each call handles one level
Reverse operation	unflatten_json restores the original structure for round-trip use