Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/661.html

661. Image Smoother (Easy)

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

Note:

  1. The value in the given matrix is in the range of [0, 255].
  2. The length and width of the given matrix are in the range of [1, 150].

Related Topics:
Array

Solution 1.

  • class Solution {
        public int[][] imageSmoother(int[][] M) {
            if (M == null || M.length == 0 || M[0].length == 0)
                return M;
            int rows = M.length, columns = M[0].length;
            int[][] smooth = new int[rows][columns];
            int[][] directions = { {-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1} };
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < columns; j++) {
                    int sum = M[i][j];
                    int count = 1;
                    for (int[] direction : directions) {
                        int newRow = i + direction[0], newColumn = j + direction[1];
                        if (newRow >= 0 && newRow < rows && newColumn >= 0 && newColumn < columns) {
                            sum += M[newRow][newColumn];
                            count++;
                        }
                    }
                    smooth[i][j] = sum / count;
                }
            }
            return smooth;
        }
    }
    
    ############
    
    class Solution {
        public int[][] imageSmoother(int[][] img) {
            int m = img.length;
            int n = img[0].length;
            int[][] ans = new int[m][n];
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < n; ++j) {
                    int s = 0;
                    int cnt = 0;
                    for (int x = i - 1; x <= i + 1; ++x) {
                        for (int y = j - 1; y <= j + 1; ++y) {
                            if (x >= 0 && x < m && y >= 0 && y < n) {
                                ++cnt;
                                s += img[x][y];
                            }
                        }
                    }
                    ans[i][j] = s / cnt;
                }
            }
            return ans;
        }
    }
    
  • // OJ: https://leetcode.com/problems/image-smoother/
    // Time: O(MN)
    // Space: O(1)
    class Solution {
    public:
        vector<vector<int>> imageSmoother(vector<vector<int>>& A) {
            int M = A.size(), N = A[0].size();
            vector<vector<int>> ans(M, vector<int>(N));
            for (int i = 0; i < M; ++i) {
                for (int j = 0; j < N; ++j) {
                    int cnt = 0;
                    for (int x = i - 1; x <= i + 1; ++x) {
                        for (int y = j - 1; y <= j + 1; ++y) {
                            if (x < 0 || x >= M || y < 0 || y >= N) continue;
                            ans[i][j] += A[x][y];
                            ++cnt;
                        }
                    }
                    ans[i][j] /= cnt;
                }
            }
            return ans;
        }
    };
    
  • class Solution:
        def imageSmoother(self, img: List[List[int]]) -> List[List[int]]:
            m, n = len(img), len(img[0])
            ans = [[0] * n for _ in range(m)]
            for i in range(m):
                for j in range(n):
                    s = cnt = 0
                    for x in range(i - 1, i + 2):
                        for y in range(j - 1, j + 2):
                            if 0 <= x < m and 0 <= y < n:
                                cnt += 1
                                s += img[x][y]
                    ans[i][j] = s // cnt
            return ans
    
    ############
    
    class Solution(object):
      def imageSmoother(self, M):
        """
        :type M: List[List[int]]
        :rtype: List[List[int]]
        """
        m = len(M)
        n = len(M[0])
        ans = [[0] * n for _ in range(m)]
    
        for i in range(m):
          for j in range(n):
            cnt = 0
            sums = 0
            for di in range(-1, 2):
              for dj in range(-1, 2):
                newi, newj = i + di, j + dj
                if 0 <= newi < m and 0 <= newj < n:
                  cnt += 1
                  sums += M[newi][newj]
            ans[i][j] = sums / cnt
        return ans
    
    
  • func imageSmoother(img [][]int) [][]int {
    	m, n := len(img), len(img[0])
    	ans := make([][]int, m)
    	for i, row := range img {
    		ans[i] = make([]int, n)
    		for j := range row {
    			s, cnt := 0, 0
    			for x := i - 1; x <= i+1; x++ {
    				for y := j - 1; y <= j+1; y++ {
    					if x >= 0 && x < m && y >= 0 && y < n {
    						cnt++
    						s += img[x][y]
    					}
    				}
    			}
    			ans[i][j] = s / cnt
    		}
    	}
    	return ans
    }
    
  • function imageSmoother(img: number[][]): number[][] {
        const m = img.length;
        const n = img[0].length;
        const locations = [
            [-1, -1],
            [-1, 0],
            [-1, 1],
            [0, -1],
            [0, 0],
            [0, 1],
            [1, -1],
            [1, 0],
            [1, 1],
        ];
    
        const res = [];
        for (let i = 0; i < m; i++) {
            res.push([]);
            for (let j = 0; j < n; j++) {
                let sum = 0;
                let count = 0;
                for (const [y, x] of locations) {
                    if ((img[i + y] || [])[j + x] != null) {
                        sum += img[i + y][j + x];
                        count++;
                    }
                }
                res[i].push(Math.floor(sum / count));
            }
        }
        return res;
    }
    
    
  • impl Solution {
        pub fn image_smoother(img: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
            let m = img.len();
            let n = img[0].len();
            let locations = [
                [-1, -1],
                [-1, 0],
                [-1, 1],
                [0, -1],
                [0, 0],
                [0, 1],
                [1, -1],
                [1, 0],
                [1, 1],
            ];
    
            let mut res = vec![];
            for i in 0..m {
                res.push(vec![]);
                for j in 0..n {
                    let mut sum = 0;
                    let mut count = 0;
                    for [y, x] in locations.iter() {
                        let i = i as i32 + y;
                        let j = j as i32 + x;
                        if i < 0 || i == m as i32 || j < 0 || j == n as i32 {
                            continue;
                        }
                        count += 1;
                        sum += img[i as usize][j as usize];
                    }
                    res[i].push(sum / count);
                }
            }
            res
        }
    }
    
    

All Problems

All Solutions