Nested List Weight Sum II

class Solution {
public:
    int depthSumInverse(vector<NestedInteger>& nestedList) {
        int maxDepth = 0;
        function<void(vector<NestedInteger>&, int)> measure = [&](vector<NestedInteger>& list, int d) {
            maxDepth = max(maxDepth, d);
            for (auto& ni : list) if (!ni.isInteger()) measure(ni.getList(), d + 1);
        };
        measure(nestedList, 1);
        int sum = 0;
        function<void(vector<NestedInteger>&, int)> add = [&](vector<NestedInteger>& list, int d) {
            for (auto& ni : list) {
                if (ni.isInteger()) sum += ni.getInteger() * (maxDepth - d + 1);
                else add(ni.getList(), d + 1);
            }
        };
        add(nestedList, 1);
        return sum;
    }
};

// NestedInteger interface assumed: IsInteger() bool, GetInteger() int, GetList() []*NestedInteger.

func depthSumInverse(nestedList []*NestedInteger) int {
    maxDepth := 0
    var measure func(list []*NestedInteger, d int)
    measure = func(list []*NestedInteger, d int) {
        if d > maxDepth {
            maxDepth = d
        }
        for _, ni := range list {
            if !ni.IsInteger() {
                measure(ni.GetList(), d+1)
            }
        }
    }
    measure(nestedList, 1)
    sum := 0
    var add func(list []*NestedInteger, d int)
    add = func(list []*NestedInteger, d int) {
        for _, ni := range list {
            if ni.IsInteger() {
                sum += ni.GetInteger() * (maxDepth - d + 1)
            } else {
                add(ni.GetList(), d+1)
            }
        }
    }
    add(nestedList, 1)
    return sum
}

from typing import List

# class NestedInteger:
#     def isInteger(self) -> bool: ...
#     def getInteger(self) -> int: ...
#     def getList(self) -> List['NestedInteger']: ...

class Solution:
    def depthSumInverse(self, nestedList: List['NestedInteger']) -> int:
        max_depth = 0

        def measure(lst: List['NestedInteger'], d: int) -> None:
            nonlocal max_depth
            if d > max_depth:
                max_depth = d
            for ni in lst:
                if not ni.isInteger():
                    measure(ni.getList(), d + 1)

        measure(nestedList, 1)
        total = 0

        def add(lst: List['NestedInteger'], d: int) -> None:
            nonlocal total
            for ni in lst:
                if ni.isInteger():
                    total += ni.getInteger() * (max_depth - d + 1)
                else:
                    add(ni.getList(), d + 1)

        add(nestedList, 1)
        return total

// NestedInteger API: isInteger(), getInteger(), getList()

function depthSumInverse(nestedList) {
    let maxDepth = 0;
    const measure = (list, d) => {
        if (d > maxDepth) maxDepth = d;
        for (const ni of list) {
            if (!ni.isInteger()) measure(ni.getList(), d + 1);
        }
    };
    measure(nestedList, 1);
    let sum = 0;
    const add = (list, d) => {
        for (const ni of list) {
            if (ni.isInteger()) sum += ni.getInteger() * (maxDepth - d + 1);
            else add(ni.getList(), d + 1);
        }
    };
    add(nestedList, 1);
    return sum;
}

class Solution {
    private int maxDepth = 0;
    private int sum = 0;

    public int depthSumInverse(List<NestedInteger> nestedList) {
        measure(nestedList, 1);
        add(nestedList, 1);
        return sum;
    }

    private void measure(List<NestedInteger> list, int d) {
        if (d > maxDepth) maxDepth = d;
        for (NestedInteger ni : list) {
            if (!ni.isInteger()) measure(ni.getList(), d + 1);
        }
    }

    private void add(List<NestedInteger> list, int d) {
        for (NestedInteger ni : list) {
            if (ni.isInteger()) sum += ni.getInteger() * (maxDepth - d + 1);
            else add(ni.getList(), d + 1);
        }
    }
}

// NestedInteger API: isInteger(), getInteger(), getList()
interface NestedInteger {
    isInteger(): boolean;
    getInteger(): number;
    getList(): NestedInteger[];
}

function depthSumInverse(nestedList: NestedInteger[]): number {
    let maxDepth = 0;
    const measure = (list: NestedInteger[], d: number): void => {
        if (d > maxDepth) maxDepth = d;
        for (const ni of list) {
            if (!ni.isInteger()) measure(ni.getList(), d + 1);
        }
    };
    measure(nestedList, 1);
    let sum = 0;
    const add = (list: NestedInteger[], d: number): void => {
        for (const ni of list) {
            if (ni.isInteger()) sum += ni.getInteger() * (maxDepth - d + 1);
            else add(ni.getList(), d + 1);
        }
    };
    add(nestedList, 1);
    return sum;
}