Image Smoother

Image Smoother - Problem

Array Matrix Easy

An image smoother is a filter of the size 3 x 3 that can be applied to each cell of an image by rounding down the average of the cell and the eight surrounding cells (i.e., the average of the nine cells in the blue smoother).

If one or more of the surrounding cells of a cell is not present, we do not consider it in the average (i.e., the average of the four cells in the red smoother).

Given an m x n integer matrix img representing the grayscale of an image, return the image after applying the smoother on each cell of it.

Input & Output

Example 1 — Basic 2x3 Matrix

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

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

💡 Note: For each cell, calculate average of itself and valid neighbors. Center cell (1,1) has value 0, surrounded by eight 1s: (1+1+1+1+0+1+1+1+1)/9 = 8/9 = 0 (floor division)

Example 2 — Edge Cell Handling

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

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

💡 Note: Corner cells only have 4 neighbors (3 neighbors + itself). Top-left: (100+200+200+50)/4 = 550/4 = 137. Edge cells have 6 neighbors total.

Example 3 — Single Cell

$ Input: img = [[1]]

› Output: [[1]]

💡 Note: Single cell matrix - only the cell itself is considered: 1/1 = 1

Constraints

m == img.length
n == img[i].length
1 ≤ m, n ≤ 200
0 ≤ img[i][j] ≤ 255

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 12

The Image Smoother applies a 3×3 averaging filter to each cell in a matrix. The key insight is handling boundary conditions where edge/corner cells have fewer than 9 neighbors. Both brute force and helper function approaches work in O(m×n) time with O(m×n) space for the result matrix.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized - Helper Function Approach	O(m×n)	O(m×n)	Extract neighbor checking logic into reusable helper function
Brute Force - Direct Neighbor Averaging	O(m×n)	O(m×n)	For each cell, manually check all 8 directions and calculate average

Optimized - Helper Function Approach — Algorithm Steps

Step 1: Create helper function to get cell average
Step 2: Helper checks boundaries and sums neighbors
Step 3: Main function calls helper for each position
Step 4: Return the smoothed result matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Call Helper

Main function calls getAverage(i, j)

Calculate Bounds

Helper determines valid neighbor range

Return Average

Helper returns computed average

Code -

solution.c — C

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

int getAverage(int** img, int imgSize, int* imgColSize, int x, int y) {
    int total = 0, count = 0;
    
    int startRow = (x > 0) ? x - 1 : 0;
    int endRow = (x < imgSize - 1) ? x + 1 : imgSize - 1;
    
    for (int i = startRow; i <= endRow; i++) {
        int startCol = (y > 0) ? y - 1 : 0;
        int endCol = (y < imgColSize[i] - 1) ? y + 1 : imgColSize[i] - 1;
        
        for (int j = startCol; j <= endCol; j++) {
            total += img[i][j];
            count++;
        }
    }
    
    return total / count;
}

int** solution(int** img, int imgSize, int* imgColSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = imgSize;
    *returnColumnSizes = (int*)malloc(imgSize * sizeof(int));
    
    int** result = (int**)malloc(imgSize * sizeof(int*));
    
    for (int i = 0; i < imgSize; i++) {
        (*returnColumnSizes)[i] = imgColSize[i];
        result[i] = (int*)malloc(imgColSize[i] * sizeof(int));
        
        for (int j = 0; j < imgColSize[i]; j++) {
            result[i][j] = getAverage(img, imgSize, imgColSize, i, j);
        }
    }
    
    return result;
}

int main() {
    // Simple test case parsing
    int imgSize = 2;
    int* imgColSize = (int*)malloc(2 * sizeof(int));
    imgColSize[0] = 3;
    imgColSize[1] = 3;
    
    int** img = (int**)malloc(2 * sizeof(int*));
    img[0] = (int*)malloc(3 * sizeof(int));
    img[1] = (int*)malloc(3 * sizeof(int));
    
    img[0][0] = 1; img[0][1] = 1; img[0][2] = 1;
    img[1][0] = 1; img[1][1] = 0; img[1][2] = 1;
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(img, imgSize, imgColSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Still visit each cell once with constant neighbor checks per cell

✓ Linear Growth

Space Complexity

O(m×n)

Result matrix plus small constant space for helper function

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Optimized - Helper Function Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler