Image Smoother - Practice Coding Problems

Image Smoother - Problem

Array Matrix Easy

Imagine you're working with image processing software and need to implement a blur effect! An image smoother is a filter that reduces noise and creates a softer appearance by averaging pixel values.

Given an m x n integer matrix img representing the grayscale values of an image, you need to apply a 3x3 smoothing filter to each cell:

For each cell, calculate the average of the cell itself and its 8 surrounding neighbors
If some neighbors don't exist (edge/corner cells), only use the available cells in the average
Round down the result using integer division

Return the smoothed image matrix where each cell contains the averaged value of its neighborhood.

Think of it like applying a blur effect in photo editing software - each pixel becomes the average of itself and its neighbors!

Input & Output

example_1.py — Basic 3x3 Matrix

$ Input: img = [[1,1,1],[1,0,1],[1,1,1]]

› Output: [[0,0,0],[0,0,0],[0,0,0]]

💡 Note: For the center cell (1,1) with value 0: neighbors are [1,1,1,1,0,1,1,1,1], sum=8, count=9, average=8//9=0. Corner cells have fewer neighbors but follow same logic.

example_2.py — Different Values

$ Input: img = [[100,200,100],[200,50,200],[100,200,100]]

› Output: [[137,141,137],[141,138,141],[137,141,137]]

💡 Note: Center cell: (100+200+100+200+50+200+100+200+100)/9 = 1250/9 = 138. Corner cells average 4 neighbors, edge cells average 6 neighbors.

example_3.py — Single Cell Edge Case

$ Input: img = [[36]]

› Output: [[36]]

💡 Note: Single cell has no neighbors, so it averages only itself: 36/1 = 36. This demonstrates proper handling of matrices with no actual neighbors.

Constraints

m == img.length
n == img[i].length
1 ≤ m, n ≤ 200
0 ≤ img[i][j] ≤ 255
Each cell value represents a grayscale pixel (0-255)

Visualization

Tap to expand

Understanding the Visualization

Select Target Pixel

Choose the pixel to smooth (center of 3x3 window)

Gather Neighborhood

Collect values from the 3x3 grid around the target pixel

Handle Boundaries

For edge/corner pixels, only use available neighbors

Calculate Average

Sum all valid neighbors and divide by count, rounding down

Apply to All Pixels

Repeat this process for every pixel in the image

Key Takeaway

🎯 Key Insight: Image smoothing is essentially a convolution operation with a 3x3 averaging filter. The algorithm naturally handles edge cases through boundary checking, and the O(m×n) time complexity is optimal since every pixel must be processed exactly once.

Asked in

A Adobe 35 ⊞ Microsoft 28 G Google 22 N NVIDIA 18

The optimal approach uses matrix traversal to process each cell exactly once. For every cell, we check its 3x3 neighborhood, sum the valid neighbors (handling boundaries), and calculate the integer average. Time complexity is O(m×n) which is optimal since we must visit every cell. The key insight is that this matrix processing problem has a straightforward optimal solution - sometimes the 'brute force' approach is actually the best we can do!

Common Approaches

Approach	Time	Space	Notes
✓ Matrix Traversal with Neighbor Averaging	O(m × n)	O(m × n)	Process each cell by checking all 8 directions and averaging valid neighbors

Matrix Traversal with Neighbor Averaging — Algorithm Steps

Create a result matrix of the same size
For each cell (i,j) in the original matrix
Check all 9 positions in the 3x3 neighborhood centered at (i,j)
Sum valid neighbors and count how many exist
Calculate average using integer division
Store result in the new matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Target Cell

Choose the cell to smooth (highlighted in blue)

Check 3x3 Neighborhood

Examine all 9 positions around and including the target cell

Sum Valid Neighbors

Add up values from cells that exist within matrix bounds

Calculate Average

Divide sum by count and round down using integer division

Code -

solution.c — C

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

int** imageSmoother(int** img, int imgSize, int* imgColSize, int* returnSize, int** returnColumnSizes) {
    if (imgSize == 0 || imgColSize[0] == 0) {
        *returnSize = imgSize;
        return img;
    }
    
    int m = imgSize, n = imgColSize[0];
    int** result = (int**)malloc(m * sizeof(int*));
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
        (*returnColumnSizes)[i] = n;
    }
    
    int directions[9][2] = {{-1,-1}, {-1,0}, {-1,1}, {0,-1}, {0,0}, {0,1}, {1,-1}, {1,0}, {1,1}};
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int totalSum = 0;
            int count = 0;
            
            for (int d = 0; d < 9; d++) {
                int ni = i + directions[d][0];
                int nj = j + directions[d][1];
                if (ni >= 0 && ni < m && nj >= 0 && nj < n) {
                    totalSum += img[ni][nj];
                    count++;
                }
            }
            
            result[i][j] = totalSum / count;
        }
    }
    
    *returnSize = m;
    return result;
}

int main() {
    // Input parsing and function call would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We visit each cell once and do constant work (check at most 9 neighbors) per cell

✓ Linear Growth

Space Complexity

O(m × n)

We need a new matrix to store results to avoid modifying the original while reading from it

⚡ Linearithmic Space

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

Matrix Traversal with Neighbor Averaging — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler