一天一道力扣题

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.

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/flipping-an-image

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这是一道简单的题。大数组顺序不变，数组内数组倒序，并且0变1，1变0。

很简单想到reversed()倒序函数和 ^ 异或运算(1 ^ 1 = 0, 0 ^ 1 = 1, 1 ^ 0 = 1, 0 ^ 0 = 0)

代码如下

func flipAndInvertImage(_ image: [[Int]]) -> [[Int]] {
     var rotateImage: [[Int]] = []
     for i in 0..<image.count {
         let subImg = image[i].reversed()
         let rotateSubImage = subImg.map { $0^1 }
         rotateImage.append(rotateSubImage)
     }
     return rotateImage
}

再简写下就是 

func flipAndInvertImage(_ image: [[Int]]) -> [[Int]] {
    return image.map { $0.reversed().map { $0 ^ 1 } }
}

附结果:

48. 旋转图像

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]

输出：[[7,4,1],[8,5,2],[9,6,3]]

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/rotate-image

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这道题一个简单的想法就是，数组最后一组数据作为新数据的每组首位，倒数第二组数据为新数据的第二位... 以3x3举例，新数组结果 每个小数组首位  为  7 8 9，第二位为4 5 6。

综上 代码如下

    func rotate(_ matrix: inout [[Int]]) {
        var newMatrix: [[Int]] = matrix
        for i in 0..<matrix.count {
            let subMatrix = matrix[matrix.count - 1 - i]
            for j in 0..<subMatrix.count {
                newMatrix[j][i] = subMatrix[j]
            }
        }
        matrix = newMatrix
    }

附结果。

还有另一种想法。先上下翻转，再斜对角翻转

即

    func rotate(_ matrix: inout [[Int]]) {
       let len = matrix.count
        for i in 0..<len/2 {
            //上下翻转
           let tmp = matrix[i]
            matrix[i] = matrix[len - 1 - i]
            matrix[len - 1 - i] = tmp
        }
        for i in 0..<len {
            for j in i..<len {
                let tmp = matrix[i][j]
                 matrix[i][j] = matrix[j][i]
                 matrix[j][i] = tmp
            }
        } 
    }