LeetCode

Given a 2D integer matrix M representing the gray scale of an image, you need to design a smoother to make the gray scale of each cell becomes the average gray scale (rounding down) of all the 8 surrounding cells and itself. If a cell has less than 8 surrounding cells, then use as many as you can.

Example 1:

Input:
[[1,1,1],
 [1,0,1],
 [1,1,1]]
Output:
[[0, 0, 0],
 [0, 0, 0],
 [0, 0, 0]]
Explanation:
For the point (0,0), (0,2), (2,0), (2,2): floor(3/4) = floor(0.75) = 0
For the point (0,1), (1,0), (1,2), (2,1): floor(5/6) = floor(0.83333333) = 0
For the point (1,1): floor(8/9) = floor(0.88888889) = 0

class Solution {
    public int[][] imageSmoother(int[][] m) {
        if (m == null)
            return null;
        int[][] ret = new int[m.length][m[0].length];
        for (int i=0; i<m.length; i++) {
            for (int j=0; j<m[i].length; j++) {
                int sum = m[i][j], cnt = 1;
                if (i-1 >= 0) {
                    sum += m[i-1][j];cnt++;
                    if (j-1 >= 0) {
                        sum += m[i-1][j-1];
                        cnt ++;
                    }
                    if (j+1 < m[i].length) {
                        sum += m[i-1][j+1];
                        cnt ++;
                    }
                }
                if (i+1 < m.length) {
                    sum += m[i+1][j];cnt++;
                    if (j-1 >= 0) {
                        sum += m[i+1][j-1];
                        cnt++;
                    }
                    if (j+1 < m[i].length) {
                        sum += m[i+1][j+1];
                        cnt++;
                    }
                }
                if (j-1 >= 0) {
                    sum += m[i][j-1];
                    cnt++;
                }
                if (j+1 < m[i].length) {
                    sum += m[i][j+1];
                    cnt++;
                }
                ret[i][j] = sum / cnt;
            }
        }
        return ret;
    }
}