Design Neighbor Sum Service - Practice Coding Problems

Design Neighbor Sum Service - Problem

Design a Neighbor Sum Service that efficiently calculates sums of adjacent and diagonal neighbors in a 2D grid.

You're given an n × n 2D grid containing distinct elements in the range [0, n² - 1]. Your task is to implement the NeighborSum class with the following methods:

• Constructor: NeighborSum(int[][] grid) - Initialize the object with the grid
• Adjacent Sum: int adjacentSum(int value) - Return sum of elements adjacent to value (top, bottom, left, right)
• Diagonal Sum: int diagonalSum(int value) - Return sum of elements diagonal to value (top-left, top-right, bottom-left, bottom-right)

Example: For a 3×3 grid with value 5 at position (1,1), adjacent neighbors would be the cells directly above, below, left, and right of position (1,1).

Input & Output

example_1.py — Basic 3x3 Grid

$ Input: grid = [[0,1,2],[3,4,5],[6,7,8]] neighborSum = NeighborSum(grid) neighborSum.adjacentSum(1) neighborSum.adjacentSum(4) neighborSum.diagonalSum(4) neighborSum.diagonalSum(8)

› Output: [null, 6, 16, 16, 4]

💡 Note: For adjacentSum(1): neighbors are 0 and 4, sum = 6. For adjacentSum(4): neighbors are 1,3,5,7, sum = 16. For diagonalSum(4): neighbors are 0,2,6,8, sum = 16. For diagonalSum(8): only neighbor is 4, sum = 4.

example_2.py — Edge Cases

$ Input: grid = [[1,2],[3,4]] neighborSum = NeighborSum(grid) neighborSum.adjacentSum(1) neighborSum.diagonalSum(1) neighborSum.adjacentSum(2) neighborSum.diagonalSum(4)

› Output: [null, 5, 4, 4, 1]

💡 Note: Corner and edge elements have fewer neighbors. For adjacentSum(1): neighbors are 2,3, sum = 5. For diagonalSum(1): only diagonal neighbor is 4, sum = 4.

example_3.py — Single Element

$ Input: grid = [[5]] neighborSum = NeighborSum(grid) neighborSum.adjacentSum(5) neighborSum.diagonalSum(5)

› Output: [null, 0, 0]

💡 Note: Single element grid has no neighbors, so both sums return 0.

Visualization

Tap to expand

Understanding the Visualization

Grid Setup

Each cell represents a house with a unique ID, positioned in a neighborhood grid

Neighbor Types

Adjacent neighbors share walls (up/down/left/right), diagonal neighbors are at corners

Precomputation

During setup, calculate and store neighbor sums for each house ID

Instant Queries

When an alert occurs, instantly return the precomputed neighbor sum

Key Takeaway

🎯 Key Insight: Precomputing neighbor sums during initialization enables instant O(1) query responses, making this approach perfect for systems requiring fast, repeated lookups.

Time & Space Complexity

Time Complexity

⏱️

O(n²) initialization, O(1) per query

Process each cell once during init, constant lookup for queries

⚠ Quadratic Growth

Space Complexity

O(n²)

Two hash maps storing sums for all n² elements

⚠ Quadratic Space

Constraints

3 ≤ n ≤ 10
0 ≤ grid[i][j] ≤ n² - 1
All grid[i][j] are distinct
1 ≤ value ≤ n² - 1
At most 2 × 10⁴ calls will be made to adjacentSum and diagonalSum

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 f Meta 6

The optimal solution uses hash map precomputation during initialization to achieve O(1) query time. By calculating and storing all neighbor sums upfront, we trade O(n²) space for instant responses to adjacentSum() and diagonalSum() queries, making it perfect for applications with many queries.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map with Precomputed Sums (Optimal)	O(n²) initialization, O(1) per query	O(n²)	Precompute neighbor sums during initialization for O(1) queries
Brute Force (Search Every Query)	O(n²) per query	O(1)	Search for the value in the grid and calculate neighbors for each query

Hash Map with Precomputed Sums (Optimal) — Algorithm Steps

During initialization, iterate through each cell in the grid
For each cell, calculate its adjacent sum and diagonal sum
Store these precomputed sums in hash maps with the cell value as key
For queries, simply lookup the precomputed sum from the hash map

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Hash Maps

Create two hash maps for adjacent and diagonal sums

Process Each Cell

For each grid cell, calculate both sum types

Store Results

Map cell values to their precomputed sums

O(1) Query

Answer queries with instant hash map lookups

Code -

solution.c — C

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

typedef struct {
    int* adjacentSums;
    int* diagonalSums;
    int maxValue;
} NeighborSum;

NeighborSum* neighborSumCreate(int** grid, int gridSize, int* gridColSize) {
    NeighborSum* obj = (NeighborSum*)malloc(sizeof(NeighborSum));
    int n = gridSize;
    obj->maxValue = n * n;
    obj->adjacentSums = (int*)calloc(obj->maxValue, sizeof(int));
    obj->diagonalSums = (int*)calloc(obj->maxValue, sizeof(int));
    
    // Precompute all sums during initialization
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int value = grid[i][j];
            
            // Calculate adjacent sum
            int adjSum = 0;
            int adjDirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
            for (int d = 0; d < 4; d++) {
                int ni = i + adjDirs[d][0], nj = j + adjDirs[d][1];
                if (ni >= 0 && ni < n && nj >= 0 && nj < n) {
                    adjSum += grid[ni][nj];
                }
            }
            
            // Calculate diagonal sum
            int diagSum = 0;
            int diagDirs[4][2] = {{-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
            for (int d = 0; d < 4; d++) {
                int ni = i + diagDirs[d][0], nj = j + diagDirs[d][1];
                if (ni >= 0 && ni < n && nj >= 0 && nj < n) {
                    diagSum += grid[ni][nj];
                }
            }
            
            obj->adjacentSums[value] = adjSum;
            obj->diagonalSums[value] = diagSum;
        }
    }
    
    return obj;
}

int neighborSumAdjacentSum(NeighborSum* obj, int value) {
    return (value >= 0 && value < obj->maxValue) ? obj->adjacentSums[value] : 0;
}

int neighborSumDiagonalSum(NeighborSum* obj, int value) {
    return (value >= 0 && value < obj->maxValue) ? obj->diagonalSums[value] : 0;
}

void neighborSumFree(NeighborSum* obj) {
    free(obj->adjacentSums);
    free(obj->diagonalSums);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n²) initialization, O(1) per query

Process each cell once during init, constant lookup for queries

⚠ Quadratic Growth

Space Complexity

O(n²)

Two hash maps storing sums for all n² elements

⚠ Quadratic Space

Constraints

3 ≤ n ≤ 10
0 ≤ grid[i][j] ≤ n² - 1
All grid[i][j] are distinct
1 ≤ value ≤ n² - 1
At most 2 × 10⁴ calls will be made to adjacentSum and diagonalSum

23.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Map with Precomputed Sums (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler