[4] 颠倒二进制位和杨辉三角

内容来自leetcode，用python 完成

1.颠倒二进制位

题目要求

颠倒给定的 32 位无符号整数的二进制位。

示例 1：

输入：n = 00000010100101000001111010011100
输出：964176192 (00111001011110000010100101000000)
解释：输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
     因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。

思路

和把十进制的数颠倒的思路类似，只不过二进制的移动采用的是位运算符

class Solution:
    def reverseBits(self, n: int) -> int:
        reverse = 0
        count = 0
        while n != 0  :
            if n&1:
                reverse = reverse | 1
            count +=1 
            if count !=32:
                reverse = reverse << 1
            n = n>>1
            
        if count < 31:
            reverse = reverse << (31-count)
        return reverse

虽然不难，但是写的时候还是遇到了一些问题，比如光写个n>>1，没有赋值。。。还有就是最后得到的位数，容易多移。

官方给出了位运算分治的解决方案

若要翻转一个二进制串，可以将其均分成左右两部分，对每部分递归执行翻转操作，然后将左半部分拼在右半部分的后面，即完成了翻转。

由于左右两部分的计算方式是相似的，利用位掩码和位移运算，我们可以自底向上地完成这一分治流程。

class Solution:
    M32 = 0xffffffff  # 1*32
    M1 = 0x55555555  # ...0101010101010101
    M2 = 0x33333333  # ...0011001100110011
    M4 = 0x0f0f0f0f  # ...0000111100001111
    M8 = 0x00ff00ff  # ...0000000011111111

    def reverseBits(self, n: int) -> int:
        # print(format(n, 'b').zfill(32))
        n = ((n & self.M1) << 1) & self.M32 | ((n >> 1) & self.M1)
        n = ((n & self.M2) << 2) & self.M32 | ((n >> 2) & self.M2)
        n = ((n & self.M4) << 4) & self.M32 | ((n >> 4) & self.M4)
        n = ((n & self.M8) << 8) & self.M32 | ((n >> 8) & self.M8)
        n = (n << 16) & self.M32 | (n >> 16)
        return n

2.杨辉三角

题目要求

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

示例 1:

输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

 思路

首和尾都保持1不变，中间的元素为上一行的元素两两相加。感觉略微麻烦一点就是Python本身没得二维数组，只能通过向列表增加另一个列表的形式实现。

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        yang = [[1]]
        if numRows == 1:
            return yang
        for i in range(numRows-1):
            if i == 0:
                addlist = [1,1]
                yang.append(addlist)
            else:
                orilist = yang[i]
                addlist = [1]
                for i in range(len(orilist)-1):
                    addlist.append(orilist[i]+orilist[i+1])
                addlist.append(1)
                yang.append(addlist)
        return yang

官方的解法提醒了我。。。虽然不能声明二维，但是可以以二维的办法读取。。。

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        ret = list()
        for i in range(numRows):
            row = list()
            for j in range(0, i + 1):
                if j == 0 or j == i:
                    row.append(1)
                else:
                    row.append(ret[i - 1][j] + ret[i - 1][j - 1])
            ret.append(row)
        return ret