Find the Grid of Region Average - Practice Coding Problems

Find the Grid of Region Average - Problem

Array Matrix Medium

You're given an m x n grayscale image represented as a 2D grid where each cell contains a pixel intensity value between 0 and 255. Your task is to identify smooth regions within the image and calculate regional averages.

A region is defined as any 3 x 3 subgrid where adjacent pixels (sharing an edge) have intensity differences ≤ threshold. Think of this as finding areas where the image transitions are smooth enough to be considered uniform.

Key Rules:

Each pixel can belong to multiple overlapping regions
For pixels in multiple regions: average the floor values of each region's average
For pixels in no regions: keep original intensity value
Always use floor division for final results

Return the processed image where each pixel shows its regional average intensity.

Input & Output

example_1.py — Basic Valid Region

$ Input: image = [[5,6,7,10],[8,9,10,10],[11,12,13,10]], threshold = 3

› Output: [[9,9,9,10],[9,9,9,10],[9,9,9,10]]

💡 Note: The 3x3 region in the top-left corner has all adjacent pixels differing by ≤ 3, so all pixels in this region get the average value floor(81/9) = 9. The rightmost column pixels don't belong to any valid region, so they keep their original values.

example_2.py — No Valid Regions

$ Input: image = [[10,20,30],[15,25,35],[20,30,40]], threshold = 3

› Output: [[10,20,30],[15,25,35],[20,30,40]]

💡 Note: Adjacent pixels differ by more than threshold=3 (e.g., |10-20|=10 > 3), so no valid 3x3 regions exist. All pixels retain their original values.

example_3.py — Multiple Overlapping Regions

$ Input: image = [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], threshold = 0

› Output: [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]]

💡 Note: All pixels have the same value, so every 3x3 region is valid with average 1. Each pixel belongs to multiple regions, but all regions have the same average, so the result is unchanged.

Constraints

3 ≤ m, n ≤ 300
0 ≤ image[i][j] ≤ 255
0 ≤ threshold ≤ 255
Adjacent pixels are those that share an edge (not diagonal)
All averages should be calculated using floor division

Visualization

Tap to expand

Understanding the Visualization

Identify Smooth Regions

Find 3×3 areas where adjacent pixels don't vary much (≤ threshold)

Calculate Region Averages

Compute floor(sum/9) for each valid region

Handle Overlaps

Pixels in multiple regions get the average of all their region averages

Preserve Edges

Pixels not in any smooth region keep their original values

Key Takeaway

🎯 Key Insight: Pre-compute all valid regions once instead of revalidating them for each pixel - this transforms an O(mn×9) problem into O(mn) by eliminating redundant work.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a single-pass preprocessing approach to identify all valid 3×3 regions and their averages, then efficiently maps each pixel to its containing regions. This avoids redundant region validations and achieves O(mn) time complexity compared to the brute force O(mn × 9) approach. The key insight is that each region needs to be validated only once, not once per pixel it contains.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Regions for Each Pixel)	O(m * n * 9)	O(1)	For each pixel, check all possible 3x3 regions it could belong to
Optimized Single Pass (Optimal)	O(m * n)	O(m * n)	Pre-compute all valid regions and their averages, then map pixels to regions

Brute Force (Check All Regions for Each Pixel) — Algorithm Steps

For each pixel (i,j) in the result grid
Find all 3x3 regions that contain pixel (i,j)
For each potential region, check if it's valid (adjacent pixels differ ≤ threshold)
Calculate average of valid regions containing this pixel
If no valid regions, use original pixel value

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Target Pixel

Choose pixel (1,1) to calculate its result value

Find Candidate Regions

Find all 3x3 regions that contain pixel (1,1) - there are up to 9 possible regions

Validate Each Region

Check if adjacent pixels in each region differ by ≤ threshold

Calculate Averages

For valid regions, compute floor(sum/9) for each region

Final Result

Average all valid region averages, or use original pixel if no valid regions

Code -

solution.c — C

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

int isValidRegion(int** image, int m, int n, int topRow, int leftCol, int threshold) {
    if (topRow + 2 >= m || leftCol + 2 >= n) return 0;
    
    for (int i = topRow; i < topRow + 3; i++) {
        for (int j = leftCol; j < leftCol + 3; j++) {
            if (j + 1 < leftCol + 3) {
                if (abs(image[i][j] - image[i][j + 1]) > threshold) {
                    return 0;
                }
            }
            if (i + 1 < topRow + 3) {
                if (abs(image[i][j] - image[i + 1][j]) > threshold) {
                    return 0;
                }
            }
        }
    }
    return 1;
}

int getRegionAverage(int** image, int topRow, int leftCol) {
    int total = 0;
    for (int i = topRow; i < topRow + 3; i++) {
        for (int j = leftCol; j < leftCol + 3; j++) {
            total += image[i][j];
        }
    }
    return total / 9;
}

int** resultGrid(int** image, int m, int n, int threshold) {
    int** result = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int regionAverages[9];
            int count = 0;
            
            int startRowMin = (i - 2 > 0) ? i - 2 : 0;
            int startRowMax = (i < m - 3) ? i : m - 3;
            int startColMin = (j - 2 > 0) ? j - 2 : 0;
            int startColMax = (j < n - 3) ? j : n - 3;
            
            for (int startRow = startRowMin; startRow <= startRowMax; startRow++) {
                for (int startCol = startColMin; startCol <= startColMax; startCol++) {
                    if (isValidRegion(image, m, n, startRow, startCol, threshold)) {
                        regionAverages[count++] = getRegionAverage(image, startRow, startCol);
                    }
                }
            }
            
            if (count > 0) {
                int sum = 0;
                for (int k = 0; k < count; k++) {
                    sum += regionAverages[k];
                }
                result[i][j] = sum / count;
            } else {
                result[i][j] = image[i][j];
            }
        }
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n * 9)

For each of m*n pixels, we check up to 9 possible 3x3 regions, and each region validation takes O(9) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

28.8K Views

Medium Frequency

~25 min Avg. Time

1.2K 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 (Check All Regions for Each Pixel) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler