"""Leetcode 339. Nested List Weight Sum
Easy

URL: https://leetcode.com/problems/nested-list-weight-sum/

Given a nested list of integers, return the sum of all integers in the list
weighted by their depth.

Each element is either an integer, or a list -- whose elements may also be
integers or other lists.

Example 1:
Input: [[1,1],2,[1,1]]
Output: 10 
Explanation: Four 1's at depth 2, one 2 at depth 1.

Example 2:
Input: [1,[4,[6]]]
Output: 27 
Explanation: One 1 at depth 1, one 4 at depth 2, and one 6 at depth 3;
1 + 4*2 + 6*3 = 27.
"""

# """
# This is the interface that allows for creating nested lists.
# You should not implement it, or speculate about its implementation
# """
#class NestedInteger(object):
#    def __init__(self, value=None):
#        """
#        If value is not specified, initializes an empty list.
#        Otherwise initializes a single integer equal to value.
#        """
#
#    def isInteger(self):
#        """
#        @return True if this NestedInteger holds a single integer, rather than a nested list.
#        :rtype bool
#        """
#
#    def add(self, elem):
#        """
#        Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
#        :rtype void
#        """
#
#    def setInteger(self, value):
#        """
#        Set this NestedInteger to hold a single integer equal to value.
#        :rtype void
#        """
#
#    def getInteger(self):
#        """
#        @return the single integer that this NestedInteger holds, if it holds a single integer
#        Return None if this NestedInteger holds a nested list
#        :rtype int
#        """
#
#    def getList(self):
#        """
#        @return the nested list that this NestedInteger holds, if it holds a nested list
#        Return None if this NestedInteger holds a single integer
#        :rtype List[NestedInteger]
#        """

class SolutionDFS(object):
    def _dfs(self, nestedList, depth):
        depth_sum = 0
        for e in nestedList():
            if e.isInteger:
                depth_sum += e.getInteger() * depth
            else:
                depth_sum += self._dfs(e.getList(), depth + 1)
        return depth_sum

    def depthSum(self, nestedList):
        """
        :type nestedList: List[NestedInteger]
        :rtype: int

        Time complexity: O(n), where n is the total elements.
        Space complexity: O(d), where d is the depth.
        """
        if not nestedList:
            return 0

        depth = 1
        return self._dfs(nestedList, depth)


def main():
    pass


if __name__ == '__main__':
    main()

@@ -1892,16 +1892,21 @@
 utionDFS
+Recur
 (object)
@@ -1926,26 +1926,20 @@
 s(self, 
-nestedList
+item
 , depth)
@@ -1952,69 +1952,15 @@
     
-depth_sum = 0%0A        for e in nestedList():%0A            if e
+if item
 .isI
@@ -1965,16 +1965,18 @@
 sInteger
+()
 :%0A      
@@ -1985,26 +1985,19 @@
     
- 
-   depth_sum += e
+return item
 .get
@@ -2014,24 +2014,25 @@
 * depth%0A
+%0A
         
     else
@@ -2027,22 +2027,62 @@
     
-    else:%0A    
+depth_sum = 0%0A        for neighbor in item.getList():%0A
     
@@ -2116,19 +2116,16 @@
 dfs(
-e.getList()
+neighbor
 , de
@@ -2468,56 +2468,139 @@
 epth
- = 1%0A        return self._dfs(nestedList,
+_sum = 0%0A        depth = 1%0A        for item in nestedList:%0A            depth_sum += self._dfs(item, depth)%0A        return
  depth
-)
+_sum
 %0A%0A%0Ad

Refactor to more intuitive dfs