python
class ListNode:
def __init__(self, val=0, next=None):
self.v = val # 节点值
self.n = next # 指向下一个节点
def addnumbers(l1: ListNode, l2: ListNode) -> ListNode:
d = ListNode() # 虚拟头节点（假头）
c = d # 写字笔，指向当前要写的位置
jinwei = 0 # 进位，初始为0
# 循环：有数字没算 或 有进位，就继续
while l1 or l2 or jinwei:
# 读当前位数字，短链表补0
v1 = l1.v if l1 else 0
v2 = l2.v if l2 else 0
# 计算当前位总和+进位
s = v1 + v2 + jinwei
dangqianwei = s % 10 # 当前位要写的数字
jinwei = s // 10 # 更新进位
# 核心：把当前位数字写入结果链表
c.n = ListNode(dangqianwei)
c = c.n # 写字笔往后挪
# 读数笔往后挪（非空才挪）
if l1:
l1 = l1.n
if l2:
l2 = l2.n
# 循环结束后，返回真实结果（跳过假头）
return d.n
python
class ListNode:
def __init__(self, val=0, next=None):
self.v = val
self.n = next
def merge(l1: ListNode, l2: ListNode) -> ListNode:
d = ListNode() # 虚拟头节点
c = d # 当前指针（拼接新链表用）
# 两个链表都有节点时，循环比较拼接
while l1 and l2:
if l1.v < l2.v:
c.n = l1
l1 = l1.n # l1指针后移
else:
c.n = l2
l2 = l2.n # l2指针后移
c = c.n # 当前指针后移，始终指向新链表最后一个节点
# 拼接剩余未遍历的节点
c.n = l1 if l1 else l2
return d.n # 跳过虚拟头节点，返回真实结果
python
# 链表节点定义
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
# 合并两个有序链表
def mergenode(l1, l2):
dummy = ListNode()
cur = dummy
while l1 and l2:
if l1.val < l2.val:
cur.next = l1
l1 = l1.next
else:
cur.next = l2
l2 = l2.next
cur = cur.next
cur.next = l1 if l1 else l2
return dummy.next
# ==================== 下面是你缺的工具函数 ====================
# 列表转链表
def list_to_link(lst):
dummy = ListNode()
cur = dummy
for num in lst:
cur.next = ListNode(num)
cur = cur.next
return dummy.next
# 链表转列表
def link_to_list(head):
res = []
cur = head
while cur:
res.append(str(cur.val)) # 直接转字符串方便输出
cur = cur.next
return res
# ==================== 主程序（输入输出） ====================
if __name__ == '__main__':
l1_lst = list(map(int, input().split()))
l2_lst = list(map(int, input().split()))
# 列表 → 链表
l1 = list_to_link(l1_lst)
l2 = list_to_link(l2_lst)
# 合并
merged_link = mergenode(l1, l2)
# 链表 → 列表
result = link_to_list(merged_link)
# 蓝桥杯标准输出：空格分隔
print(' '.join(result))
python
def major (nums):
nums.sort()
return nums[len(nums)//2]
if __name__ =="__main__":
nums=list(map(int,input().split()))
print(major(nums))哈希表实现
python
def major(nums):
dict={}
for num in nums:
if num in dict:
dict[num]+=1
else:
dict[num]=1
n=len(nums)
for key,val in dict.items():
if val>n//2:
return key
if __name__ =="__main__":
nums=list(map(int,input().split()))
print(major(nums))
python
def maxsub(nums):
current_max=max_sum=nums[0]
for num in nums[1:]:
current_max=max(num,current_max+num)
max_sum=max(max_sum,current_max)
return max_sum
if __name__ == "__main__":
nums=list(map(int,input().split()))
print(maxsub(nums))爬楼梯（LeetCode70）
斐波那契型 DP 入门题，核心是状态转移 + 空间优化
核心题意
假设你正在爬楼梯，需要
n阶才能到达楼顶。每次你可以爬1或2个台阶，求有多少种不同的爬楼方法。
python
def climb(n):
if n<=1:
return 1
dp=[0]*(n+1)
dp[0],dp[1]=1,1
for i in range(2,n+1):
dp[i]=dp[i-1]+dp[i-2]
return dp[n]
if __name__ =="__main__":
n=int(input())
print(climb)
python
def maxProfit(prices):
min_price = prices[0] # 初始化最小价格为第一天价格
max_profit = 0 # 最大利润初始为0（不交易的情况）
for price in prices:
min_price = min(min_price, price) # 更新遍历到当前的最低价格
current_profit = price - min_price # 计算当前卖出的利润
max_profit = max(max_profit, current_profit) # 更新最大利润
return max_profit
# 蓝桥杯标准输入输出（兼容空格/逗号输入，无格式报错）
if __name__ == "__main__":
s = input().replace(',', ' ') # 替换逗号为空格，兼容两种输入
prices = list(map(int, s.split())) # 转为整数数组
print(maxProfit(prices))
python
def maxProfit(prices):
n = len(prices)
if n <= 1:
return 0
# dp[i][0] = 第i天不持有股票的最大利润
# dp[i][1] = 第i天持有股票的最大利润
dp = [[0] * 2 for _ in range(n)]
# 初始状态
dp[0][0] = 0 # 第0天不买
dp[0][1] = -prices[0] # 第0天买入，花了prices[0]
# 从第1天开始递推
for i in range(1, n):
# 今天不持股：昨天不持股 或 昨天持股今天卖了
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
# 今天持股：昨天持股 或 今天第一次买（只能买一次）
dp[i][1] = max(dp[i - 1][1], -prices[i])
# 答案一定是最后一天不持股（卖了才赚钱）
return dp[-1][0]
# 蓝桥杯输入输出
if __name__ == "__main__":
s = input().replace(',', ' ')
prices = list(map(int, s.split()))
print(maxProfit(prices))
python
# 最终答案：最长连续登录次数
ans = 0
# 上一次有效登录的时间戳，初始设为 -1 表示还没登录过
last_time = -1
# 当前连续登录次数
cnt = 0
while True:
try:
# 读入一行数据：账号a、账号b、时间t
a, b, t = input().split()
t = int(t)
# ------------------------------------------------------
# 关键：只有 a == b 才是有效登录
# ------------------------------------------------------
if a != b:
# 不是本人登录，当前连续中断，重置为 0
cnt = 0
# 上一次时间也作废
last_time = -1
continue
# 到这里说明是有效登录
# 第一次有效登录
if last_time == -1:
cnt = 1
else:
# 时间差 ≤1000，连续 +1
if t - last_time <= 1000:
cnt += 1
# 间隔太久，重新开始
else:
cnt = 1
# 更新上一次时间
last_time = t
# 更新最大连续次数
if cnt > ans:
ans = cnt
# 读到文件末尾结束
except EOFError:
break
print(ans)
python
# 数字0-9对应的笔画数，题目直接给的
duiyin=[13, 1, 2, 3, 5, 4, 4, 2, 2, 2]
# 判断闰年（省三必背模板）
def runnian(year):
if year%400==0 or (year%4 ==0 and year%100!=0):
return True
return False
# 计算这一天的笔画和是否>50
def riqi(y,m,d):
# 拼成8位日期：YYYYMMDD
date_str=f"{y:04d}{m:02d}{d:02d}"
total=0
for c in date_str:
num=int(c)
total+=duiyin[num]
return total>50
# 统计答案
count=0
# 遍历2000 ~ 2024年
for year in range(2000,2025):
# 闰年2月29天，平年28天
feb_day=29 if runnian(year) else 28
# 每个月的天数
month_day=[0,31,feb_day,31,30,31,30,31,31,30,31,30,31]
# 2024年只算到4月，其他年算到12月
max_month=12
if year==2024:
max_month=4
# 遍历月份
for month in range(1,max_month+1):
# 每个月的最大天数
max_day=month_day[month]
# 2024年4月只算到13号
if year==2024 and month==4:
max_day=13
# ----------------- 这里是修复点 -----------------
# 遍历日期，必须和if对齐，不能缩进去！
for day in range(1,max_day+1):
if riqi(year,month,day):
count+=1
print(count)
python
n=int(input())
w1=list(map(int,input().split()))
w2=list(map(int,input().split()))
w3=list(map(int,input().split()))
m=int(input())
steps=[list(map(int,input().split())) for _ in range(m)]
p1,p2,p3=0,0,0
total=0
for x1,x2,x3 in steps:
p1=(p1+x1)%n
p2=(p2+x2)%n
p3=(p3+x3)%n
a=w1[p1]
b=w2[p2]
c=w3[p3]
nums=[a,b,c]
score=0
if a==b==c:
score =200
elif b ==a+1 and c ==b+1:
score =200
elif sorted(nums)==list(range(min(nums),max(nums)+1)):
score=100
total+=score
print(total)