AI刷题小结（1）| 豆包MarsCode AI 刷题

单独的数

问题描述 在一个班级中，每位同学都拿到了一张卡片，上面有一个整数。有趣的是，除了一个数字之外，所有的数字都恰好出现了两次。现在需要你帮助班长小C快速找到那个拿了独特数字卡片的同学手上的数字是什么。

要求：

设计一个算法，使其时间复杂度为 O(n)，其中 n 是班级的人数。 尽量减少额外空间的使用，以体现你的算法优化能力。

解题思路：利用位运算，将数字的每一位进行异或运算，最后得到的结果就是单独的数。例如：x ^ x = 0，x ^ 0 = x，因此我们可以将数字的每一位进行异或运算，最后得到的结果就是单独的数。

代码：

```python

def solution(cards):

result = 0
for card in cards:
    result = result ^ card
return result     

if name == "main":

print(solution([1, 1, 2, 2, 3, 3, 4, 5, 5]) == 4)
print(solution([0, 1, 0, 1, 2]) == 2)

简单四则运算解析器

问题描述:

小F面临一个编程挑战：实现一个基本的计算器来计算简单的字符串表达式的值。该字符串表达式有效，并可能包含数字（0-9）、运算符+、-及括号()。注意，字符串中不包含空格。除法运算应只保留整数结果。请实现一个解析器计算这些表达式的值，且不使用任何内置的eval函数。

1. 初始化栈：你需要两个栈，一个用于操作数（operand_stack），一个用于运算符（operator_stack）。
2. 定义运算符优先级：使用字典来定义运算符的优先级。
3. 遍历表达式：逐个字符遍历表达式，处理数字、运算符和括号。
4. 处理数字：将连续的数字字符转换为整数，并压入操作数栈。
5. 处理运算符：根据运算符的优先级进行计算，并将运算符压入运算符栈。

处理括号：使用栈来确保括号内的表达式优先计算。

6. 计算剩余的运算符：在遍历完表达式后，处理栈中剩余的运算符

代码：

def solution(expression):
    # 初始化两个栈，一个用于操作数，一个用于运算符
    operand_stack = []
    operator_stack = []
    
    # 定义运算符优先级
    precedence = {'+': 1, '-': 1, '*': 2, '/': 2}
    
    # 遍历表达式中的每个字符
    i = 0
    while i < len(expression):
        char = expression[i]
        
        if char.isdigit():
            # 处理数字
            num = 0
            while i < len(expression) and expression[i].isdigit():
                num = num * 10 + int(expression[i])
                i += 1
            operand_stack.append(num)
            continue
        
        if char in "+-*/":
            # 处理运算符
            while operator_stack and precedence[operator_stack[-1]] >= precedence[char]:
                # 弹出运算符并计算
                op = operator_stack.pop()
                b = operand_stack.pop()
                a = operand_stack.pop()
                if op == '+':
                    operand_stack.append(a + b)
                elif op == '-':
                    operand_stack.append(a - b)
                elif op == '*':
                    operand_stack.append(a * b)
                elif op == '/':
                    operand_stack.append(a // b)  # 整数除法
            operator_stack.append(char)
        
        elif char == '(':
            # 处理左括号
            operator_stack.append(char)
        
        elif char == ')':
            # 处理右括号
            while operator_stack and operator_stack[-1] != '(':
                op = operator_stack.pop()
                b = operand_stack.pop()
                a = operand_stack.pop()
                if op == '+':
                    operand_stack.append(a + b)
                elif op == '-':
                    operand_stack.append(a - b)
                elif op == '*':
                    operand_stack.append(a * b)
                elif op == '/':
                    operand_stack.append(a // b)  # 整数除法
            operator_stack.pop()  # 弹出左括号
        
        i += 1
    
    # 处理剩余的运算符
    while operator_stack:
        op = operator_stack.pop()
        b = operand_stack.pop()
        a = operand_stack.pop()
        if op == '+':
            operand_stack.append(a + b)
        elif op == '-':
            operand_stack.append(a - b)
        elif op == '*':
            operand_stack.append(a * b)
        elif op == '/':
            operand_stack.append(a // b)  # 整数除法
    
    return operand_stack[0]

if __name__ == "__main__":

    #  You can add more test cases here
    print(solution("1+1") == 2)
    print(solution("3+4*5/(3+2)") == 7)
    print(solution("4+2*5-2/1") == 12)
    print(solution("(1+(4+5+2)-3)+(6+8)") == 23)

红包运气排行榜

问题描述：小C参与了一场抢红包的游戏，现在他想要对所有参与抢红包的人进行一次运气排名。排名规则如下：抢到的金额越多，排名越靠前；如果两个人抢到的金额相同，则按照他们抢红包的顺序进行排名。比如，如果小C和小U抢到的金额相同，但小C比小U先抢，则小C排在小U前面。

解题思路： 考虑到一个人会抢到多个红包的情况，我们可以用一个字典来记录每个人的抢到的金额，然后根据字典的键值对进行排序。字典的键是参与抢红包的人，值是他们抢到的金额。排序的规则是按照字典的值进行排序，如果两个人的金额相同，则按照字典的键进行排序。

考点：字典，元组

代码：

def solution(n: int, s: list, x: list) -> list:

    # 首先计算每个人的总金额
    # 初始化总金额字典
    total_money = {}
    for name,money in zip(s,x):
        if name in total_money:
            total_money[name] += money
        else:
            total_money[name] = money     
    
    # 提取字典中的键值形成元组
    participant = [(name,money) for name, money in total_money.items()]
    # 从大到小排序
    sorted_luck = sorted(participant,key =lambda x:(-x[1],s.index(x[0])) )
    result = [name for name,money in sorted_luck ]

    
    return result 

小Tips:

• 元组,字典的排序可以用lambda表达式来实现，lambda表达式的第一个参数是元组的元素，第二个参数是排序的依据。 例如：

sorted_luck = sorted(participant,key =lambda x:(-x[1],s.index(x[0])) )

-x[1]代表倒序排序，x[1]代表正序从小到大排序。