日志3月20日

题目：

根据 逆波兰表示法，求表达式的值。

class Solution(object):
    def evalRPN(self, tokens):
        sign = ["+", "-", "*", "/"]
        stack = []
        for token in tokens:
            if token not in sign:
                stack.append(int(token))
            else:
                tmp1 = stack.pop()
                tmp2 = stack.pop()
                if token == "+":
                    stack.append(tmp1 + tmp2)
                elif token == "-":
                    stack.append(tmp2 - tmp1)
                elif token == "*":
                    stack.append(tmp1 * tmp2)
                else:
                    stack.append(int(float(tmp2) / tmp1))
        return stack[0]

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        op_to_binary_fn = {
            "+": add,
            "-": sub,
            "*": mul,
            "/": lambda x, y: int(x / y),   # 需要注意 python 中负数除法的表现与题目不一致
        }

        stack = list()
        for token in tokens:
            try:
                num = int(token)
            except ValueError:
                num2 = stack.pop()
                num1 = stack.pop()
                num = op_to_binary_fn[token](num1, num2)
            finally:
                stack.append(num)
            
        return stack[0]

给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。

请你统计并返回 grid 中 负数 的数目。

class Solution:
    def countNegatives(self, grid: List[List[int]]) -> int:
        cout = 0
        for i in range(len(grid) - 1, -1, -1):
            for j in range(len(grid[0]) - 1, -1, -1):
                if grid[i][j] < 0:
                    cout += 1
                else:
                    break
        return cout

class Solution:
    def countNegatives(self, grid: List[List[int]]) -> int:
        row_s, col_s = 0, 0
        row_e, col_e = len(grid)-1, len(grid[0])-1
        count = 0

        if grid[0][0] < 0:
            return (row_e + 1) * (col_e + 1)

        while row_e >= row_s and col_e >= col_s:
            for r in range(row_e, -1, -1):
                if grid[r][col_s] >= 0:
                    count += (row_e - r) * (col_e - col_s + 1)
                    row_e = r
                    break
                
            for c in range(col_e, -1, -1):
                if grid[row_s][c] >= 0:
                    count += (col_e - c) * (row_e - row_s + 1)
                    col_e = c
                    break

            row_s += 1
            col_s += 1

        return count

给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), …, (an, bn) ，使得从 1 到 n 的 min(ai, bi) 总和最大。

class Solution:
    def arrayPairSum(self, nums: List[int]) -> int:
        nums.sort()
        return sum(nums[::2])

    def arrayPairSum(self, nums):
        nums.sort()
        res = 0
        for i in range(0, len(nums), 2):
            res += min(nums[i], nums[i + 1])
        return res

自除数 是指可以被它包含的每一位数除尽的数。

例如，128 是一个自除数，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。

还有，自除数不允许包含0

class Solution(object):
    def selfDividingNumbers(self, left, right):
        result = []
        for i in range(left, right+1):
            if "0" in str(i):
                continue
            for num in str(i):
                if i % int(num) != 0:
                    break;
            else:
                result.append(i)
        return result

class Solution(object):
    def selfDividingNumbers(self, left, right):
        def self_dividing(n):
            for d in str(n):
                if d == '0' or n % int(d) > 0:
                    return False
            return True
        ans = []
        for n in range(left, right + 1):
            if self_dividing(n):
                ans.append(n)
        return ans #Equals filter(self_dividing, range(left, right+1))

给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。

class Solution:
    def commonChars(self, A: List[str]) -> List[str]:
        res = []
        min_length_char = min(A, key=len)
        for char in min_length_char:
            if all(char in item  for item in A):
                res.append(char)
                A = [i.replace(char,'',1)  for i in A]

        return res

class Solution:
    def commonChars(self, A: List[str]) -> List[str]:
        res = []

        if not A:
            return res
        
        key = set(A[0])
        for k in key:
               
            minimum = min(a.count(k) for a in A)
            res += minimum*k
        return res

请实现一个函数，输入一个整数（以二进制串形式），输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。

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

class Solution:
    def hammingWeight(self, n: int) -> int:
        #简单思路：转为2进制进行各位相加
        strs = bin(n)[2:]
        res = 0
        for i in range(len(strs)):
            if strs[i] == "1":
                res += 1
        return res