1.

 2.

def methods(m, n):
    #创建一个二维数组cp，用于存储到到每个位置的不同走法数量；
    cp = [[0] * n for _ in range(m)]

#从第一行和第一列的格子上的走法数量都为1
    for i in range(m):
        cp[i][0] = 1
    for j in range(n):
        cp [0][j] = 1

#从第二行和第二列开始，计算每个位置的走法数量
    for i in range(1, m):
        for j in range(1, n):
            cp[i][j] = cp[i-1][j] + cp[i][j - 1]

#返回右下角格子的走法数量
    return cp[m - 1][n - 1]

#调用函数计算棋盘上的走法数量
m = 5
n = 8
result = methods(m, n)
print(result)

2. 

# 定义一个函数，用于判断输入行中的对称符号是否匹配
def is_symmetric(expression):
    # 定义对称符号的映射关系
    brackets = {'{': '}', '[': ']', '(': ')', '<': '>'}
    
    # 初始化一个空栈，用于存储遇到的左括号
    stack = []
    
    # 遍历输入字符串中的每个字符
    for char in expression:
        # 如果是左括号，则入栈
        if char in brackets.keys():
            stack.append(char)
        # 如果是右括号
        elif char in brackets.values():
            # 如果栈不为空，且栈顶的左括号与当前右括号匹配
            if stack and brackets[stack[-1]] == char:
                # 出栈，表示找到了匹配的左括号
                stack.pop()
            else:
                # 如果不匹配，则对称符号不成立，返回'no'
                return 'no'
    
    # 如果栈为空，说明所有左括号都有匹配的右括号，返回'yes'，否则返回'no'
    return 'yes' if not stack else 'no'
 
# 测试用例一
test_case_1 = "({<(({{}>}))>})"
result_1 = is_symmetric(test_case_1)
# 输出：yes
print(result_1)  
 
# 测试用例二
test_case_2 = "()()()"
result_2 = is_symmetric(test_case_2)
 # 输出：no
print(result_2) 

 3.

 

class solution:

    def find(self, nums):
        left = 1
        right = len(nums) - 1
        while left < right:
            mid = left + (right - left + 1) // 2
            count = 0
            for num in nums:
                if num < mid:
                    count += 1
                if count < mid:
                    left = mid
                else:
                    right = mid - 1

        return left