6/ 6 | 豆包MarsCode AI刷题6/6 195.小M的奶酪问题（简） 226.小T的密码变换规则（简） 48

6/6第一题问题描述

小M在集市上买了一公斤奶酪回家。然而，在小M不在的时候，小F偷偷地偷走了 ABBA 公斤的奶酪。现在，小M想知道他还剩下多少奶酪。要求答案以分数的形式表示，并且分数的分母必须为 BB。

测试样例

样例1：

输入：A = 2,B = 7
输出：'5/7'

样例2：

输入：A = 1,B = 3
输出：'2/3'

样例3：

输入：A = 3,B = 5
输出：'2/5'

问题理解

小M原本有一公斤（即1000克）奶酪。
小F偷走了 $\frac{A}{B}$ 公斤的奶酪。
我们需要计算小M还剩下多少奶酪，并以分数形式表示，且分母必须为 $B$ 。

数据结构选择

由于我们需要以分数形式表示剩余的奶酪量，并且分母必须为 $B$ ，我们可以直接使用整数运算来处理这个问题。

算法步骤

计算剩余的奶酪量：
- 原本的奶酪量是1公斤，即 $\frac{B}{B}$ 公斤。
- 小F偷走了 $\frac{A}{B}$ 公斤的奶酪。
- 剩余的奶酪量就是 $\frac{B}{B} - \frac{A}{B}$ ，即 $\frac{B - A}{B}$ 。
返回结果：
- 将剩余的奶酪量以分数形式返回，即 f"{remaining_cheese}/{B}"。

代码

def solution(A: int, B: int) -> str:
    # 计算剩余的奶酪量
    remaining_cheese = B - A
    # 返回分数形式的字符串
    return f"{remaining_cheese}/{B}"

if __name__ == '__main__':
    print(solution(2, 7) == "5/7")
    print(solution(1, 3) == "2/3")
    print(solution(3, 5) == "2/5")

6/6第二题问题描述

小T设计了一套密码变换规则，将输入的字符串转换成一串数字密码。变换规则如下：

小写字母按以下映射关系进行转换：

a, b, c -> 2
d, e, f -> 3
g, h, i -> 4
j, k, l -> 5
m, n, o -> 6
p, q, r, s -> 7
t, u, v -> 8
w, x, y, z -> 9

大写字母先转为小写字母，再跳到字母表中的前一个字母，并按上述规则转换为对应的数字。例如，B 转换为 a，再转换为 2；A 特殊处理，先变为 Z，再转换为 9。
非字母字符保持不变。

例如：对于输入字符串 "LIming0701"，转换后的数字密码为 5464640701。

测试样例

样例1：

输入：s = "LIming0701"
输出：'5464640701'

样例2：

输入：s = "PassW0rd"
输出：'62778073'

样例3：

输入：s = "helloWORLD123"
输出：'4355686752123'

解题思路

理解问题：
- 你需要将输入的字符串转换成一串数字密码。
- 小写字母有特定的映射关系。
- 大写字母需要先转换为小写字母，然后跳到字母表中的前一个字母，再进行映射。
- 非字母字符保持不变。
数据结构的选择：
- 使用字典来存储字母到数字的映射关系。
- 使用字符串来存储最终的转换结果。
算法步骤：
- 创建一个字典来存储小写字母到数字的映射。
- 遍历输入字符串的每个字符：
  - 如果是大写字母，先转换为小写字母，然后跳到前一个字母，再进行映射。
  - 如果是小写字母，直接进行映射。
  - 如果是非字母字符，保持不变。
- 将每个字符的转换结果拼接成最终的字符串。

代码框架

def solution(s: str) -> str:
    # 创建字母到数字的映射字典
    letter_to_digit = {
        'a': '2', 'b': '2', 'c': '2',
        'd': '3', 'e': '3', 'f': '3',
        'g': '4', 'h': '4', 'i': '4',
        'j': '5', 'k': '5', 'l': '5',
        'm': '6', 'n': '6', 'o': '6',
        'p': '7', 'q': '7', 'r': '7', 's': '7',
        't': '8', 'u': '8', 'v': '8',
        'w': '9', 'x': '9', 'y': '9', 'z': '9'
    }
    
    # 初始化结果字符串
    result = ''
    
    # 遍历输入字符串的每个字符
    for char in s:
        if char.isupper():
            # 如果是大写字母，先转换为小写字母，然后跳到前一个字母
            if char == 'A':
                char = 'z'
            else:
                char = chr(ord(char.lower()) - 1)
            # 进行映射
            result += letter_to_digit[char]
        elif char.islower():
            # 如果是小写字母，直接进行映射
            result += letter_to_digit[char]
        else:
            # 如果是非字母字符，保持不变
            result += char
    
    return result

if __name__ == '__main__':
    print(solution(s="LIming0701") == '5464640701')
    print(solution(s="PassW0rd") == '62778073')
    print(solution(s="helloWORLD123") == '4355686752123')

关键步骤

字典创建：创建一个字典来存储字母到数字的映射关系。
字符处理：遍历输入字符串的每个字符，根据字符的类型进行相应的处理和映射。
结果拼接：将每个字符的转换结果拼接成最终的字符串。

6/6第三题问题描述

小U面临一个有趣的任务：在一个 n×nn×n 的方阵中填入 11 到 n×nn×n 这些数字，并要求按照蛇形顺序从右上角开始，沿着方阵的边界顺时针进行填充。蛇形填充的特殊排列方式使得每一层数字呈现出波浪形的排列方式。

例如，当 n=4n=4 时，方阵应如下所示：

10 11 12  1
9 16 13  2
8 15 14  3
7  6  5  4

你需要编写程序输出填充后的方阵，确保格式的整齐性。

测试样例

样例1：

输入：n = 4
输出：[[10, 11, 12, 1], [9, 16, 13, 2], [8, 15, 14, 3], [7, 6, 5, 4]]

样例2：

输入：n = 5
输出：[[13, 14, 15, 16, 1], [12, 23, 24, 17, 2], [11, 22, 25, 18, 3], [10, 21, 20, 19, 4], [9, 8, 7, 6, 5]]

样例3：

输入：n = 3
输出：[[7, 8, 1], [6, 9, 2], [5, 4, 3]]

问题理解

我们需要在一个 n x n 的方阵中按照蛇形顺序填充数字。蛇形填充的特殊之处在于每一层数字呈现出波浪形的排列方式。具体来说，填充顺序是从右上角开始，沿着方阵的边界顺时针进行填充。

数据结构选择

我们可以使用一个二维列表（矩阵）来表示这个 n x n 的方阵。

算法步骤

初始化矩阵：创建一个 n x n 的矩阵，所有元素初始化为 0。
定义方向：我们需要定义四个方向：右、下、左、上。可以使用一个列表来存储这些方向的偏移量。
填充数字：从数字 1 开始填充，直到 n * n。
计算下一个位置：根据当前方向计算下一个位置，并检查是否需要改变方向。
改变方向：如果下一个位置超出矩阵边界或已经填充过，则改变方向。
更新当前位置：更新当前位置为下一个位置，继续填充。

具体步骤

初始化矩阵：
```
matrix = [[0] * n for _ in range(n)]
```

定义方向：

directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

填充数字：

for num in range(1, n * n + 1):
    matrix[x][y] = num
    next_x, next_y = x + directions[dir_index][0], y + directions[dir_index][1]
    if not (0 <= next_x < n and 0 <= next_y < n and matrix[next_x][next_y] == 0):
        dir_index = (dir_index + 1) % 4
        next_x, next_y = x + directions[dir_index][0], y + directions[dir_index][1]
    x, y = next_x, next_y

关键点

方向控制：通过一个方向索引 dir_index 来控制当前的填充方向。
边界检查：在计算下一个位置时，需要检查是否超出矩阵边界或已经填充过。
方向切换：当需要改变方向时，更新方向索引 dir_index。

通过这些步骤，我们可以按照蛇形顺序填充矩阵，并返回最终的结果。

代码实现：

def solution(n: int) -> list:
    # 初始化一个 n x n 的矩阵，所有元素为 0
    matrix = [[0] * n for _ in range(n)]
    
    # 定义四个方向：右、下、左、上
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    # 当前方向索引
    dir_index = 0
    
    # 当前位置
    x, y = 0, n - 1
    
    # 填充数字
    for num in range(1, n * n + 1):
        matrix[x][y] = num
        
        # 计算下一个位置
        next_x, next_y = x + directions[dir_index][0], y + directions[dir_index][1]
        
        # 判断是否需要改变方向
        if not (0 <= next_x < n and 0 <= next_y < n and matrix[next_x][next_y] == 0):
            # 改变方向
            dir_index = (dir_index + 1) % 4
            next_x, next_y = x + directions[dir_index][0], y + directions[dir_index][1]
        
        # 更新当前位置
        x, y = next_x, next_y
    
    return matrix

if __name__ == '__main__':
    print(solution(4) == [[10, 11, 12, 1], [9, 16, 13, 2], [8, 15, 14, 3], [7, 6, 5, 4]])
    print(solution(5) == [[13, 14, 15, 16, 1], [12, 23, 24, 17, 2], [11, 22, 25, 18, 3], [10, 21, 20, 19, 4], [9, 8, 7, 6, 5]])
    print(solution(3) == [[7, 8, 1], [6, 9, 2], [5, 4, 3]])

代码解释

初始化矩阵：我们首先创建一个 n x n 的矩阵，所有元素初始化为 0。
定义方向：我们定义了四个方向：右、下、左、上，并使用一个索引来控制当前的方向。
填充数字：我们从数字 1 开始填充，直到 n * n。
计算下一个位置：根据当前方向计算下一个位置，并检查是否需要改变方向。
改变方向：如果下一个位置超出矩阵边界或已经填充过，则改变方向。
更新当前位置：更新当前位置为下一个位置，继续填充。

这样，我们就可以按照蛇形顺序填充矩阵，并返回最终的结果。