刷LeetCode吧

1.Array

1.给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。

水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。

反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。

示例 1:

输入: [[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]]

java:
class Solution {
    public int[][] flipAndInvertImage(int[][] A) {
        int n = A.length; //求数组长度
        int i,j;
        int[][] B = new int[n][n]; //新建二维数组
        for(i = 0;i < n;i++){
            for(j = 0;j<n;j++){
                B[i][n-j-1] = 1- A[i][j];
            }
        }
        return B;
    }
}//没有反转，直接新建数组倒叙赋值了 取反的话直接1减就可
1.求数组长度.length  新建二维数组int[][] B = new int[i][j]

python:
class Solution(object):
    def flipAndInvertImage(self, A):
        """
        :type A: List[List[int]]
        :rtype: List[List[int]]
        """
        for i in range(len(A)):
            for j in range((len(A)+1)/2):
                if A[i][j] == A[i][-1-j]:
                    t = 1-A[i][j]
                    A[i][j] = A[i][-1-j] = t
                
        return A
解题思路是:
如果相对称的两个数不相同，什么操作都不需要做：A[i][j] != A[i][-1-j]，如：0, 1，先交换变成1, 0，再取非又变回0, 1，故什么都不做。
如果相同，先1-取非，再赋值：A[i][j] == A[i][-1-j]，同时取非。
range(len())英姿不减当年

相对于第一个Java：如果某行处于对称位置上的数字不相同的话其实是不需要动的，翻转加互换后还是它本身；如果相同的话，就两个位置都分别互换。
Java:
class Solution {
    public int[][] flipAndInvertImage(int[][] A) {
        int n = A.length;
        for(int i = 0;i<n;i++){
            for(int j = 0;j < (n+1)/2;j++){
                if(A[i][j] == A[i][n-1-j]){
                    A[i][j] = A[i][n-1-j] = A[i][j] ^1;
                }
            }
          
        }
          return A;
    }
}
java连等赋值：自右向左逐一赋值的，比如：A=B=C=0，首先给C赋值0，即C=0，然后B=C;最后A=B。

python：一行完
class Solution(object):
    def flipAndInvertImage(self, A):
        """
        :type A: List[List[int]]
        :rtype: List[List[int]]
        """
        return [[1-i for i in col][::-1]for col in A]

python： map()  不过内存消耗很大
def filp(l):
    return l[::-1]
def convert(x):
    return 1^x
def invert(l):
    return list(map(convert,l))
class Solution:
    def flipAndInvertImage(self, A: List[List[int]]) -> List[List[int]]:
        return list(map(invert,list(map(filp,A))))
        
：map() 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
我不懂为什么非都得往list走，还有filp让A中每个元素水平翻转，以行作为划分，而invert是对于每一个元素进行的动作  删去了所有list 也能执行
可能因为filp传的对象就是一个数组要不然没法[::-1] 所以在filp那A 是一维数组??????????????????