Codestin Search App

Nested List Weight Sum - Problem

Imagine you have a nested list where each element can be either an integer or another list containing more integers and lists. Your task is to calculate a weighted sum where each integer is multiplied by its depth (how many levels deep it is nested).

The depth starts at 1 for the outermost level. For example, in [1,[2,2],[[3],2],1]:

The integers 1 (first and last) are at depth 1
The integers 2,2 and the second 2 are at depth 2
The integer 3 is at depth 3

So the weighted sum would be: 1×1 + 2×2 + 2×2 + 3×3 + 2×2 + 1×1 = 1 + 4 + 4 + 9 + 4 + 1 = 23

Goal: Return the sum of each integer multiplied by its depth.

Input & Output

example_1.py — Simple nested list

$ Input: nestedList = [1,[2,2],[[3],2],1]

› Output: 23

💡 Note: 1×1 + 2×2 + 2×2 + 3×3 + 2×2 + 1×1 = 1 + 4 + 4 + 9 + 4 + 1 = 23. The first and last 1 are at depth 1, the three 2's are at depth 2, and the 3 is at depth 3.

example_2.py — Deeper nesting

$ Input: nestedList = [[1,1],2,[1,1]]

› Output: 10

💡 Note: 1×2 + 1×2 + 2×1 + 1×2 + 1×2 = 2 + 2 + 2 + 2 + 2 = 10. The four 1's are at depth 2 (inside nested lists), and the 2 is at depth 1.

example_3.py — Single level

$ Input: nestedList = [1,2,3,4,5]

› Output: 15

💡 Note: 1×1 + 2×1 + 3×1 + 4×1 + 5×1 = 1 + 2 + 3 + 4 + 5 = 15. All integers are at depth 1 since there's no nesting.

Constraints

1 ≤ nestedList.length ≤ 50
The values of the integers in the nested list are in the range [-100, 100]
The maximum depth of any integer is less than or equal to 50

Visualization

Tap to expand

Understanding the Visualization

Enter Building

Start at ground floor (depth 1) with the main list

Explore Each Room

For integers, collect value × floor; for nested lists, go deeper

Go Deeper

When entering nested lists, go up one floor (increment depth)

Collect Total

Sum all collected values from all floors

Key Takeaway

🎯 Key Insight: DFS allows us to calculate the weighted sum in one pass by tracking depth as we traverse, making it the most efficient solution with O(n) time and O(d) space complexity.

Asked in

in LinkedIn 45 G Google 38 a Amazon 32 f Facebook 28 ⊞ Microsoft 22

The optimal solution uses Depth-First Search (DFS) to traverse the nested structure in a single pass. By tracking the current depth as we recursively explore each level, we can calculate each integer's contribution to the weighted sum immediately. This approach has O(n) time complexity and O(d) space complexity where d is the maximum depth.

Common Approaches

Approach	Time	Space	Notes
✓ Depth-First Search (DFS)	O(n)	O(d)	Use DFS to traverse and calculate weighted sum in one pass

Depth-First Search (DFS) — Algorithm Steps

Create a recursive DFS function that takes current list and depth
For each element in the list, check if it's an integer or nested list
If integer: add (value × current_depth) to running sum
If nested list: recursively call DFS with depth + 1
Return the total weighted sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin DFS at depth 1 with [1,[2,2],[[3],2],1]

Process Elements

For each element: if integer, multiply by depth; if list, recurse deeper

Accumulate Sum

Add up all weighted values: 1×1 + 2×2 + 2×2 + 3×3 + 2×2 + 1×1 = 23

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// C implementation would require custom data structures
int dfs() {
    printf("C implementation requires complex nested structure parsing\n");
    return 0;
}

int depthSum() {
    return dfs();
}

int main() {
    printf("%d\n", depthSum());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element exactly once during the DFS traversal

✓ Linear Growth

Space Complexity

O(d)

Only the recursion stack space, where d is the maximum depth of nesting

✓ Linear Space

78.5K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Depth-First Search (DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler