leetcode初级算法——其他

（题目源自leetcode，方法都是自(cai)己(ji)写的，可能比较符合菜鸡们的思路）

1.位1的个数

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。

提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。

进阶：

如果多次调用这个函数，你将如何优化你的算法？

示例 1：

输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。

class Solution:
    def hammingWeight(self, n: int) -> int:
        result = 0
        for i in range(32):
            result += n%2
            n = n//2
        return result

其实就是个10进制转2进制的问题。但是这样做效率很低

可以用库函数 bin()返回其二进制表示

class Solution:
    def hammingWeight(self, n: int) -> int:
        return bin(n).count("1")

还可以用移位法：与1的结果放到res，并将n右移1位

class Solution:
    def hammingWeight(self, n: int) -> int:
        res=0
        while n:
            res+=n&1
            n>>=1
        return res

还看到一种方法，二进制中地位的1会通过与n-1相与消去。

class Solution:
    def hammingWeight(self, n: int) -> int:
        res=0
        while n:
            n&=n-1
            res+=1
        return res

2.汉明距离

两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。

给出两个整数 x 和 y，计算它们之间的汉明距离。

注意：
0 ≤ x, y < 231.

示例:

输入: x = 1, y = 4

输出: 2

解释:
1   (0 0 0 1)
4   (0 1 0 0)
       ↑   ↑

上面的箭头指出了对应二进制位不同的位置。

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        result = 0
        while x != 0 or y != 0:
            result += abs(x%2-y%2)
            x = x//2
            y = y//2
        
        return result

也可以用bin和异或

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        return bin(x^y).count('1')

3.颠倒二进制位

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

示例 1：

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

class Solution:
    def reverseBits(self, n: int) -> int:
        result = []
        out = 0
        length = 32
        while n!= 0 or length!=0:
            result.append(n%2)
            n = n // 2
            length = length - 1
        for i in range(32):
            out += result[i]*(2**(31-i))
        return out

大佬解法，用bin

class Solution:
    def reverseBits(self, n: int) -> int:
        return int("0b"+("0"*32+bin(n)[2:])[-32:][::-1], base=2)

4. 杨辉三角

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

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

示例:

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

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        #result = []
        if numRows == 0:
            return []
        elif numRows == 1:
            return [[1]]
        elif numRows == 2:
            return [[1],
            [1,1]]
        else:
            result = [[1],[1,1]]
            for i in range(2,numRows):
                temp = [None]*(i+1)
                temp[0] = 1
                temp[-1] = 1
                for j in range(1,i):
                    temp[j] = result[i-1][j-1]+result[i-1][j]
                result.append(temp)
        return result

就是按性质做，temp[j] = result[i-1][j-1]+result[i-1][j]

大佬一行解法

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        return [[comb(i,j) for j in range(i+1)] for i in range(numRows)]

作者：JamLeon

comb排列组合，就是杨辉三角
杨辉三角第n行第m个数,是C(m-1,n-1)
莱布尼茨三角的第n行乘以n的阶乘,就是杨辉三角的第n行
莱布尼茨三角的第n行第m个数,是C(m-1,n-1)/n!

5.有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true

class Solution:
    def isValid(self, s: str) -> bool:
        queue = [1]
        for ss in s:
            if queue[-1] == '(' and ss == ')':
                queue.pop()
            elif queue[-1] == '[' and ss == ']':
                queue.pop()
            elif queue[-1] == '{' and ss == '}':
                queue.pop()
            else:
                queue.append(ss)
        
        return True if len(queue)==1 else False

用栈，匹配就pop，不匹配就append，最后清空就证明全配对了。

6.缺失数字

给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数。

进阶：

你能否实现线性时间复杂度、仅使用额外常数空间的算法解决此问题?

示例 1：

输入：nums = [3,0,1]
输出：2
解释：n = 3，因为有 3 个数字，所以所有的数字都在范围 [0,3] 内。2 是丢失的数字，因为它没有出现在 nums 中。

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        return sum(list(range(len(nums)+1)))-sum(nums)

求和相减就是那个没出现的数字