Design Neighbor Sum Service

Design Neighbor Sum Service - Problem

You are given a n x n 2D array grid containing distinct elements in the range [0, n² - 1].

Implement the NeighborSum class:

NeighborSum(int[][] grid) - initializes the object with the given grid
int adjacentSum(int value) - returns the sum of elements adjacent to value (top, left, right, bottom neighbors)
int diagonalSum(int value) - returns the sum of elements diagonal to value (top-left, top-right, bottom-left, bottom-right neighbors)

The neighbors are calculated based on the position of value in the grid. If a neighbor position is out of bounds, it is ignored.

Input & Output

Example 1 — Basic Grid Operations

$ Input: grid = [[3,1,2],[1,4,4],[5,5,4]], operations = [["adjacentSum", 4], ["diagonalSum", 4]]

› Output: [11, 14]

💡 Note: For value 4 at position (1,1): adjacent neighbors are 1+4+5+1=11, diagonal neighbors are 3+2+5+4=14.

Example 2 — Edge Position

$ Input: grid = [[1,2,0,3],[4,7,15,6],[8,9,10,11],[12,13,14,5]], operations = [["adjacentSum", 15]]

› Output: [23]

💡 Note: Value 15 is at position (1,2). Adjacent neighbors: 2+0+6+10=18. Wait, let me recalculate: 7+0+6+10=23.

Example 3 — Corner Position

$ Input: grid = [[1,2],[3,4]], operations = [["diagonalSum", 1]]

› Output: [4]

💡 Note: Value 1 is at corner (0,0). Only one diagonal neighbor: bottom-right has value 4.

Constraints

3 ≤ n ≤ 10
0 ≤ grid[i][j] ≤ n² - 1
All values in grid are distinct
1 ≤ operations.length ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The key insight is to preprocess the grid once and map each value to its position for O(1) lookup. Best approach uses hash map preprocessing to store value→position mapping. Time: O(n²) preprocessing + O(1) per query, Space: O(n²)

Common Approaches

✓ Brute Force - Search Every Time

⏱️ Time: O(n² × q) Space: O(1)

For each operation, iterate through the entire grid to find the target value's position, then check all 4 adjacent or 4 diagonal neighbors and sum valid ones.

Hash Map Preprocessing

⏱️ Time: O(n²) + O(q) Space: O(n²)

During initialization, create a hash map from value to position. For each query, look up position in O(1) time, then calculate neighbor sum by checking adjacent/diagonal cells.

Brute Force - Search Every Time — Algorithm Steps

Step 1: For each query, search entire grid to find value position
Step 2: Check all 4 adjacent/diagonal directions from that position
Step 3: Sum neighbors that are within grid bounds

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Grid

Scan entire n×n grid to find target value

Find Position

Locate row and column of target value

Check Neighbors

Sum valid adjacent or diagonal neighbors

Code -

solution.c — C

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

#define MAX_POINTS 1000

typedef struct {
    int points[MAX_POINTS][2];
    int count;
} DetectSquares;

DetectSquares* detectSquaresCreate() {
    DetectSquares* obj = (DetectSquares*)malloc(sizeof(DetectSquares));
    obj->count = 0;
    return obj;
}

void detectSquaresAdd(DetectSquares* obj, int* point) {
    obj->points[obj->count][0] = point[0];
    obj->points[obj->count][1] = point[1];
    obj->count++;
}

int compareInts(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int isSquare(int points[4][2]) {
    int xs[4], ys[4], uniqueXs[4], uniqueYs[4];
    int xCount = 0, yCount = 0;
    
    for (int i = 0; i < 4; i++) {
        xs[i] = points[i][0];
        ys[i] = points[i][1];
    }
    
    qsort(xs, 4, sizeof(int), compareInts);
    qsort(ys, 4, sizeof(int), compareInts);
    
    // Get unique x coordinates
    uniqueXs[xCount++] = xs[0];
    for (int i = 1; i < 4; i++) {
        if (xs[i] != xs[i-1]) {
            uniqueXs[xCount++] = xs[i];
        }
    }
    
    // Get unique y coordinates
    uniqueYs[yCount++] = ys[0];
    for (int i = 1; i < 4; i++) {
        if (ys[i] != ys[i-1]) {
            uniqueYs[yCount++] = ys[i];
        }
    }
    
    if (xCount != 2 || yCount != 2) return 0;
    if (uniqueXs[1] - uniqueXs[0] != uniqueYs[1] - uniqueYs[0]) return 0;
    if (uniqueXs[1] - uniqueXs[0] == 0) return 0;
    
    // Check if all 4 corners exist
    int expected[4][2] = {
        {uniqueXs[0], uniqueYs[0]},
        {uniqueXs[0], uniqueYs[1]},
        {uniqueXs[1], uniqueYs[0]},
        {uniqueXs[1], uniqueYs[1]}
    };
    
    for (int i = 0; i < 4; i++) {
        int found = 0;
        for (int j = 0; j < 4; j++) {
            if (expected[i][0] == points[j][0] && expected[i][1] == points[j][1]) {
                found = 1;
                break;
            }
        }
        if (!found) return 0;
    }
    
    return 1;
}

int detectSquaresCount(DetectSquares* obj, int* point) {
    int result = 0;
    int n = obj->count;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
                int allPoints[4][2] = {
                    {point[0], point[1]},
                    {obj->points[i][0], obj->points[i][1]},
                    {obj->points[j][0], obj->points[j][1]},
                    {obj->points[k][0], obj->points[k][1]}
                };
                if (isSquare(allPoints)) {
                    result++;
                }
            }
        }
    }
    
    return result;
}

int main() {
    printf("[1,0,1]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × q)

Search n² grid for each of q queries

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

342 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

Brute Force - Search Every Time — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler