Nested_Integer.py

"""
#####From NC QQ group and mitbbs, Linkedin Second round phone interview
This is the interface that represents nested lists.  
You should not implement it, or speculate about its implementation.

```
public interface NestedInteger
{
    /** @return true if this NestedInteger holds a single integer, rather than a nested list */
    boolean isInteger();

    /** @return the single integer that this NestedInteger holds, if it holds a single integer
     * Return null if this NestedInteger holds a nested list */
    Integer getInteger();

    /** @return the nested list that this NestedInteger holds, if it holds a nested list
     * Return null if this NestedInteger holds a single integer */
    List<NestedInteger> getList();
}


/**
 * Given a nested list of integers, returns the sum of all integers in the list weighted by their depth
 * For example, given the list {{1,1},2,{1,1}} the function should return 10 (four 1's at depth 2, one 2 at depth 1)
 * Given the list {1,{4,{6}}} the function should return 27 (one 1 at depth 1, one 4 at depth 2, and one 6 at depth 3)
 */

// null || empty: 0
//  1*2
//
public int depthSum (List<NestedInteger> input)
```
"""

def depthSum(input):
    if isInteger(input):
        return getInteger(input)

    return get_depth_recur(input, 1)

def get_depth_recur(input, depth)
    if isInteger(input):
        return depth * getInteger(input)

    nested_list = getList(input)
    sum = 0
    for element in nested_list:
        sum += get_depth_recur(element, depth + 1)
        
    return sum