Nested List Weight Sum

Nested List Weight Sum - Problem

You are given a nested list of integers nestedList. Each element is either an integer or a list whose elements may also be integers or other lists.

The depth of an integer is the number of lists that it is inside of. For example, the nested list [1,[2,2],[[3],2],1] has each integer's value set to its depth.

Return the sum of each integer in nestedList multiplied by its depth.

Input & Output

Example 1 — Basic Nested Structure

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

› Output: 10

💡 Note: Four 1's at depth 2, one 2 at depth 1: 1×2 + 1×2 + 2×1 + 1×2 + 1×2 = 2+2+2+2+2 = 10

Example 2 — Deeper Nesting

$ Input: nestedList = [1,[4,[6]]]

› Output: 27

💡 Note: 1 at depth 1, 4 at depth 2, 6 at depth 3: 1×1 + 4×2 + 6×3 = 1 + 8 + 18 = 27

Example 3 — Single Level

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

› Output: 6

💡 Note: All integers at depth 1: 1×1 + 2×1 + 3×1 = 1 + 2 + 3 = 6

Constraints

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

Visualization

Tap to expand

Asked in

Li LinkedIn 15 G Google 8 f Facebook 6 a Amazon 4

The key insight is to track depth while traversing the nested structure. Use DFS with depth parameter - multiply each integer by its depth and sum all results. Best approach is recursive DFS. Time: O(n), Space: O(d)

Common Approaches

✓ Breadth-First Search

⏱️ Time: O(n) Space: O(n)

Use BFS with a queue to process elements level by level. Store (element, depth) pairs in queue and process all elements at current depth before moving to next depth.

Brute Force Recursive

⏱️ Time: O(n) Space: O(d)

Traverse the nested structure recursively, manually tracking depth at each level. For each integer found, multiply by current depth and add to sum.

Optimized DFS

⏱️ Time: O(n) Space: O(d)

Use DFS with a helper function that takes current depth as parameter. Process each element once, accumulating the weighted sum efficiently.

Breadth-First Search — Algorithm Steps

Initialize queue with (nestedList, 1)
While queue not empty, dequeue (item, depth)
If integer: add item × depth to sum
If list: add each element with depth + 1 to queue

Visualization

Tap to expand

Step-by-Step Walkthrough

Queue Init

Add all root elements with depth=1 to queue

Process

Dequeue element: if integer add to sum, if list add children with depth+1

Continue

Repeat until queue empty, processing each depth level

Code -

solution.c — C

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

typedef struct NestedItem {
    int isInteger;
    int value;
    struct NestedItem** items;
    int size;
} NestedItem;

typedef struct QueueNode {
    NestedItem* item;
    int depth;
    struct QueueNode* next;
} QueueNode;

typedef struct Queue {
    QueueNode* front;
    QueueNode* rear;
} Queue;

Queue* createQueue() {
    Queue* q = malloc(sizeof(Queue));
    q->front = q->rear = NULL;
    return q;
}

void enqueue(Queue* q, NestedItem* item, int depth) {
    QueueNode* node = malloc(sizeof(QueueNode));
    node->item = item;
    node->depth = depth;
    node->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = node;
    } else {
        q->rear->next = node;
        q->rear = node;
    }
}

QueueNode* dequeue(Queue* q) {
    if (q->front == NULL) return NULL;
    
    QueueNode* node = q->front;
    q->front = q->front->next;
    if (q->front == NULL) q->rear = NULL;
    
    return node;
}

int isEmpty(Queue* q) {
    return q->front == NULL;
}

int solution(NestedItem** nestedList, int size) {
    Queue* q = createQueue();
    
    for (int i = 0; i < size; i++) {
        enqueue(q, nestedList[i], 1);
    }
    
    int total = 0;
    while (!isEmpty(q)) {
        QueueNode* node = dequeue(q);
        
        if (node->item->isInteger) {
            total += node->item->value * node->depth;
        } else {
            for (int i = 0; i < node->item->size; i++) {
                enqueue(q, node->item->items[i], node->depth + 1);
            }
        }
        
        free(node);
    }
    
    return total;
}

NestedItem* createInteger(int value) {
    NestedItem* item = malloc(sizeof(NestedItem));
    item->isInteger = 1;
    item->value = value;
    item->items = NULL;
    item->size = 0;
    return item;
}

NestedItem* createList() {
    NestedItem* item = malloc(sizeof(NestedItem));
    item->isInteger = 0;
    item->value = 0;
    item->items = malloc(100 * sizeof(NestedItem*));
    item->size = 0;
    return item;
}

NestedItem* parseNestedItem(const char* s, int* pos);

NestedItem* parseNestedList(const char* s, int* pos) {
    NestedItem* list = createList();
    (*pos)++; // skip '['
    
    while (s[*pos] && s[*pos] != ']') {
        if (s[*pos] == ' ' || s[*pos] == ',') {
            (*pos)++;
            continue;
        }
        list->items[list->size++] = parseNestedItem(s, pos);
    }
    (*pos)++; // skip ']'
    return list;
}

NestedItem* parseNestedItem(const char* s, int* pos) {
    if (s[*pos] == '[') {
        return parseNestedList(s, pos);
    } else {
        int start = *pos;
        if (s[*pos] == '-') (*pos)++;
        while (s[*pos] && isdigit(s[*pos])) (*pos)++;
        
        char temp[20];
        int len = *pos - start;
        strncpy(temp, s + start, len);
        temp[len] = '\0';
        return createInteger(atoi(temp));
    }
}

NestedItem** parseInput(const char* s, int* size) {
    NestedItem** result = malloc(100 * sizeof(NestedItem*));
    *size = 0;
    int pos = 1; // skip first '['
    
    while (s[pos] && s[pos] != ']') {
        if (s[pos] == ' ' || s[pos] == ',') {
            pos++;
            continue;
        }
        result[(*size)++] = parseNestedItem(s, &pos);
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int size;
    NestedItem** nestedList = parseInput(line, &size);
    
    int result = solution(nestedList, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each element exactly once using queue

✓ Linear Growth

Space Complexity

O(n)

Queue can hold up to n elements in worst case

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Breadth-First Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler