832. 翻转图像：

给定一个 n x n 的二进制矩阵 image ，先 水平 翻转图像，然后 反转 图像并返回 结果 。

水平翻转图片就是将图片的每一行都进行翻转，即逆序。

• 例如，水平翻转 [1,1,0] 的结果是 [0,1,1]。

反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。

• 例如，反转 [0,1,1] 的结果是 [1,0,0]。

样例 1：

输入：
	image = [[1,1,0],[1,0,1],[0,0,0]]
	
输出：
	[[1,0,0],[0,1,0],[1,1,1]]
	
解释：
	首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]；
	然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]

样例 2：

输入：
	image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
	
输出：
	[[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
	
解释：
	首先翻转每一行: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]]；
	然后反转图片: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]

提示：

• n == image.length
• n == image[i].length
• 1 <= n <= 20
• images[i][j] == 0 或 1.

分析

• 面对这道算法题目，二当家的陷入了沉思。
• 直接按照题意，两次遍历，分别去做水平翻转和翻转即可。
• 一次遍历是否可行呢？一次就把两种翻转都做了就可以了。
• 进一步思考发现，如果对称的两个值是相同的根本不需要做水平翻转，直接去做翻转即可；而如果两个值不同，由于取值只有0或者1，那么一定其中一个是0，另外一个是1，水平翻转相当于取反，而翻转操作也相当于取反，经过两次取反，值就变回去了，所以可以什么都不做。

题解

rust

impl Solution {
    pub fn flip_and_invert_image(mut image: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
        image.iter_mut().for_each(|r| {
            let mut left = 0;
            let mut right = r.len() - 1;
            while left < right {
                if r[left] == r[right] {
                    r[left] ^= 1;
                    r[right] ^= 1;
                }
                left += 1;
                right -= 1;
            }
            if left == right {
                r[left] ^= 1;
            }
        });

        image
    }
}

go

func flipAndInvertImage(image [][]int) [][]int {
    for _, r := range image {
		left := 0
		right := len(r) - 1
		for left < right {
			if r[left] == r[right] {
				r[left] ^= 1
				r[right] ^= 1
			}
			left++
			right--
		}
		if left == right {
			r[left] ^= 1
		}
	}

	return image
}

c++

class Solution {
public:
    vector<vector<int>> flipAndInvertImage(vector<vector<int>>& image) {
        for (vector<int> &r: image) {
            int left = 0;
            int right = r.size() - 1;
            while (left < right) {
                if (r[left] == r[right]) {
                    r[left] ^= 1;
                    r[right] ^= 1;
                }
                ++left;
                --right;
            }
            if (left == right) {
                r[left] ^= 1;
            }
        }

        return image;
    }
};

java

class Solution {
    public int[][] flipAndInvertImage(int[][] image) {
        for (int[] r : image) {
            int left = 0;
            int right = r.length - 1;
            while (left < right) {
                if (r[left] == r[right]) {
                    r[left] ^= 1;
                    r[right] ^= 1;
                }
                ++left;
                --right;
            }
            if (left == right) {
                r[left] ^= 1;
            }
        }

        return image;
    }
}

python

class Solution:
    def flipAndInvertImage(self, image: List[List[int]]) -> List[List[int]]:
        for r in image:
            left, right = 0, len(r) - 1
            while left < right:
                if r[left] == r[right]:
                    r[left] ^= 1
                    r[right] ^= 1
                left += 1
                right -= 1
            if left == right:
                r[left] ^= 1
        return image

原题传送门：https://leetcode.cn/problems/flipping-an-image/

非常感谢你阅读本文~
欢迎【点赞】【收藏】【评论】~
放弃不难，但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由 二当家的白帽子：https://le-yi.blog.csdn.net/ 博客原创~