递归作业集

1.某个人进入如下一个棋盘中，要求从左上角开始走，最后从右下角出来（要求只能前进，不能后退）

问题：共有多少种走法？

def path(row , column):
    if row == 1 or column == 1 :
        return 1
    else:
        return path(row - 1 , column) + path(row , column - 1)
    
    
row = eval(input("请输入棋盘的行和列"))
column = eval(input())
Temporary_variables = path(row,column)
print(f"有{Temporary_variables}中走法")

2.输入一行符号，以#结束，判断其中的对称符号是否匹配。

对称符号包括：{ } 、 [ ] 、 ( )、 < >=如果对称符号能够实现中间对称，则输出yes否则输出no

def symmetry():
    array = []
    while True:
        Temporary_variables = eval(input("请输入符号,以#号结束"))
        array.append(Temporary_variables)
        if array[len(array) - 1] == "#":
            break
    num = len(array)
    if num%2 != 0:
        print("no")
    else:
        arrays = arrays[0:(num/2)]
        array = array[(num/2):num - 1]
    judgement(arrays)
    
def judgement(arrays , array: list):
    Temporary_variables = True
    for i,j in arrays,array:
        if (i == "{" and j == "}") or (i == "[" and j == "]") or (i == "<" and j == ">") or (i == "(" and j == ")"):
            Temporary_variables = True
        else:
            Temporary_variables = False
    if Temporary_variables == True:
        print("Yes") 
    else:
        print("no")
    
symmetry()

3.给定一个包含n+1个整数的数组nums，其数字在1到n之间（包含1和n），可知至少存在一个重复的整数，假设只有一个重复的整数，请找出这个重复的数

def repeat(array:list)->int:
    array = quickSort(array)
    for num1 in array:
        list2.remove(num1)
        for num2 in array:
            if(num1==num2):
                print("相同字符串为%s"%(num1))
            else:
                continue
            
def quickSort(arr, left=None, right=None):
     left = 0 if not isinstance(left,(int, float)) else left
     right = len(arr)-1 if not isinstance(right,(int, float)) else right
     if left < right:
         partitionIndex = partition(arr, left, right)
         quickSort(arr, left, partitionIndex-1)
         quickSort(arr, partitionIndex+1, right)
     return arr
 
def partition(arr, left, right):
     pivot = left
     index = pivot+1
     i = index
     while  i <= right:
         if arr[i] < arr[pivot]:
             swap(arr, i, index)
             index+=1
         i+=1
     swap(arr,pivot,index-1)
     return index-1
 
def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

array = list(str(input("请输入以空格分隔的列表元素")).split)
repeat(array)