2024.04.23_学习日记
天气：晴
学习地点：图书馆
学习时长：10h
学习内容
- 双指针
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23class Solution:
def sortedSquares(self, nums: List[int]) -> List[int]:
# 初始化左指针 l、右指针 r 和结果列表索引 i
l, r, i = 0, len(nums)-1, len(nums)-1
# 初始化结果列表，全部填充为 0
res = [0] * len(nums)
# 循环直到左指针大于右指针
while l <= r:
# 如果左指针指向的元素的平方值小于右指针指向的元素的平方值
if nums[l] * nums[l] < nums[r] * nums[r]:
# 将右指针指向的元素的平方值放入结果列表的末尾
res[i] = nums[r] * nums[r]
# 右指针向左移动
r -= 1
else:
# 将左指针指向的元素的平方值放入结果列表的末尾
res[i] = nums[l] * nums[l]
# 左指针向右移动
l += 1
# 结果列表索引向前移动
i -= 1
# 返回排序后的平方值列表
return res - 螺旋矩阵
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40class Solution:
def generateMatrix(self, n: int) -> List[List[int]]:
# 如果 n 小于等于 0，返回空列表
if n <= 0:
return []
# 初始化结果矩阵，全部填充为 0
res = [[0] * n for i in range(n)]
# 初始化左边界 l、右边界 r、上边界 t、下边界 b，以及填充的数字 num
l, r, t, b = 0, n-1, 0, n-1
num = 1
# 开始填充数字循环
while True:
# 从左到右填充数字
for i in range(l, r+1):
res[t][i] = num
num += 1
t += 1
# 如果上边界大于下边界，跳出循环
if t > b:
break
# 从上到下填充数字
for j in range(t, b+1):
res[j][r] = num
num += 1
r -= 1
# 如果右边界小于左边界，跳出循环
if r < l:
break
# 从右到左填充数字
for i in range(r, l-1, -1):
res[b][i] = num
num += 1
b -= 1
# 从下到上填充数字
for j in range(b, t-1, -1):
res[j][l] = num
num += 1
l += 1
# 返回填充完成的矩阵
return res - 算法题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25while True:
try:
# 输入一个整数 n
n = int(input())
# 如果 n 为 0，跳出循环
if n == 0:
break
# 输入 n 个整数，并将它们存储在列表 nums 中
nums = list(map(int, input().split()))
# 计算 nums 列表的平均值
target = sum(nums) // len(nums)
# 初始化结果变量为 0
res = 0
# 遍历 nums 列表的索引范围
for i in range(len(nums)):
# 计算每个元素与平均值的绝对差，并累加到结果变量中
res += abs(nums[i] - target)
# 输出结果的一半（因为每次计算都是成对的）
print(res // 2)
# 输出空行
print()
except:
# 捕获异常并跳出循环
break - 算法题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16while True: # 无限循环，直到遇到 break 语句
try: # 尝试执行以下代码块
m, k = map(int, input().split()) # 输入两个整数 m 和 k，以空格分隔
if m == 0 and k == 0: # 如果输入的 m 和 k 都为 0，结束循环
break
res = m // k * k # 初始化结果为 m 除以 k 的商乘以 k
while True: # 无限循环，直到遇到 break 语句
add, rest = m // k, m % k # 计算 m 除以 k 的商和余数
m = add + rest # 新的 m 为商和余数的和
if m < k: # 如果余数小于 k，跳出循环
break
res += m // k * k # 将商乘以 k 加入结果
res += m # 将剩余的 m 加入结果
print(res) # 输出结果
except: # 如果遇到异常，则结束循环
break - 算法题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26while True: # 无限循环，直到遇到 break 语句
try: # 尝试执行以下代码块
n = int(input()) # 输入家族成员的数量
fatherlist = [0] * 21 # 初始化父子关系列表，下标范围为 0 到 20
for i in range(n): # 循环读取每个家族成员的父子关系
son, father = map(int, input().split()) # 输入儿子和父亲的编号
fatherlist[son] = father # 将父子关系记录到列表中
count1 = 0 # 初始化计数器 count1 为 0
x = 1 # 从编号为 1 的人开始向上查找祖先
while fatherlist[x] != 0: # 当 x 的父亲不为 0 时，继续向上查找祖先
x = fatherlist[x] # x 更新为其父亲的编号
count1 += 1 # 计数器 count1 自增
count2 = 0 # 初始化计数器 count2 为 0
y = 2 # 从编号为 2 的人开始向上查找祖先
while fatherlist[y] != 0: # 当 y 的父亲不为 0 时，继续向上查找祖先
y = fatherlist[y] # y 更新为其父亲的编号
count2 += 1 # 计数器 count2 自增
if count1 < count2: # 如果 count1 小于 count2，则输出 "You are my younger"
print("You are my younger")
elif count1 == count2: # 如果 count1 等于 count2，则输出 "You are my brother"
print("You are my brother")
else: # 否则输出 "You are my elder"
print("You are my elder")
except: # 如果遇到异常，则结束循环
break - 算法题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22while True: # 无限循环，直到遇到 break 语句
try: # 尝试执行以下代码块
n = int(input()) # 输入一个整数 n
alllist = [] # 初始化存储数字三角形的列表
# 生成数字三角形
for i in range(1, n + 1): # 循环控制行数
list1 = [] # 初始化当前行的列表
for j in range(1, i + 1): # 循环生成当前行的数字
list1.append(str(j)) # 将数字转换为字符串并添加到列表中
relist1 = list1[::-1] # 将当前行的列表反转
list1.extend(relist1[1:]) # 将反转后的列表除去首个元素后添加到当前行的列表中
alllist.append(list1) # 将当前行的列表添加到数字三角形列表中
# 正序打印数字三角形
for i in range(1, n + 1): # 控制打印的行数
print(' ' * (n - i), end='') # 输出前导空格
print(' '.join(alllist[i - 1])) # 将当前行的列表中的数字用空格连接成字符串并打印
# 倒序打印数字三角形
for i in range(n - 2, -1, -1): # 倒序循环控制打印的行数
print(' ' * (n - i - 1), end='') # 输出前导空格
print(' '.join(alllist[i])) # 将当前行的列表中的数字用空格连接成字符串并打印
except: # 如果遇到异常，则结束循环
break - 注意upper和lower函数
1
2
3
4
5
6
7n = int(input()) # 输入一个整数 n，表示接下来有 n 个单词需要处理
for i in range(n): # 循环 n 次，处理每个单词
nums = [] # 初始化一个空列表 nums，用于存储当前单词的每个字符
nums.extend(input().split()) # 输入一个单词，并将其按空格分割后添加到列表 nums 中
for c in nums: # 遍历列表 nums 中的每个字符
print(c[0].upper(), end='') # 将当前字符的首字母转换为大写并打印，end='' 表示不换行
print() # 打印一个换行，用于分隔每个处理的单词 - 栈
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21while True: # 无限循环，直到遇到 break 语句
try: # 尝试执行以下代码块
n = int(input()) # 输入一个整数 n，表示序列的长度
if n == 0: # 如果输入的 n 为 0，结束循环
break
nums = list(map(int, input().split())) # 输入一个由空格分隔的整数序列，将其转换为列表
stack = [] # 初始化一个空栈
i = 1 # 初始化一个变量 i 为 1，表示当前待入栈的元素
j = 0 # 初始化一个变量 j 为 0，表示当前待匹配的元素在序列 nums 中的索引
while i <= n: # 当待入栈元素小于等于序列长度时，继续循环
stack.append(i) # 将当前待入栈元素入栈
i += 1 # 待入栈元素自增
while stack and stack[-1] == nums[j]: # 当栈非空且栈顶元素等于当前待匹配元素时，执行以下循环
stack.pop() # 弹出栈顶元素
j += 1 # 待匹配元素索引自增
if stack: # 如果栈非空，说明匹配失败，打印 'No'
print('No')
else: # 否则，匹配成功，打印 'Yes'
print('Yes')
except: # 如果遇到异常，则结束循环
break - 反转链表
这个题注意构造链表的操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def reversnode(head):
# 初始化指针
temp = None # 临时节点，用于保存当前节点的下一个节点
cur = head # 当前节点
pre = None # 前一个节点
# 遍历链表进行反转
while cur:
temp = cur.next # 保存当前节点的下一个节点
cur.next = pre # 将当前节点的指针指向前一个节点
pre = cur # 更新前一个节点为当前节点
cur = temp # 更新当前节点为临时节点
return pre # 返回反转后的链表头节点
def printnode(head):
cur = head
while cur:
print(cur.val, end=' ') # 打印当前节点的值
cur = cur.next # 移动到下一个节点
print() # 打印换行，用于分隔不同的链表输出
while True:
try:
nums = list(map(int, input().split())) # 从用户输入获取一串数字，转换为整数列表
n = nums[0] # 第一个数字表示链表的长度
nums = nums[1:] # 去掉第一个数字，得到链表的元素列表
if n == 0:
print('list is empty')
continue
# 创建一个虚拟头节点
dummyhead = ListNode()
cur = dummyhead
# 根据用户输入构建链表
for i in range(n):
cur.next = ListNode(nums[i]) # 创建一个新节点并将其链接到当前节点
cur = cur.next # 移动到新节点
# 打印原始链表和反转后的链表
printnode(dummyhead.next)
printnode(reversnode(dummyhead.next))
except:
break # 当出现异常时退出循环