智能成绩表
class Student:
def __init__(self):
self.name = "" # 学生名字
self.scores = [] # 每门课成绩
students = [Student() for _ in range(10004)] # 存储学生信息的数组
key_index = 0 # 要排序的课程名的下标
# 自定义排序函数
def student_comparator(a, b):
if a.scores[key_index] != b.scores[key_index]:
return b.scores[key_index] - a.scores[key_index]
return (a.name > b.name) - (a.name < b.name)
n, m = map(int, input().split()) # 学生数量和课程数量
course_names = input().split() # 课程名数组
for i in range(1, n + 1):
student_info = input().split()
students[i].name = student_info[0] # 读取学生名字
total_score = 0
students[i].scores = list(map(int, student_info[1:])) # 读取每门课成绩
total_score = sum(students[i].scores) # 计算总分
students[i].scores.append(total_score) # 将总分放入成绩数组末尾
key = input() # 要排序的课程名
key_index = m # 若没找到，赋值为最后一个位置，也就是总分
for i in range(m): # 寻找这个课程名的下标
if course_names[i] == key:
key_index = i
break
students = students[1:n+1] # 仅保留有效学生信息
students.sort(key=lambda x: (x.scores[key_index], -ord(x.name[0])), reverse=True) # 排序
for i in range(n):
print(students[i].name, end=" ")
最长合法表达式
s = input() # 输入字符串
ans = 0 # 最终答案
mx = 0 # 最长的有效连续段长度
# 检查字符串是否满足条件
def check(s):
for i in range(len(s)-2):
if all([x in "*-+" for x in s[i:i+3]]): # 判断是否有三个连续的符号
return False
return True
# 遍历所有可能的连续段
for i in range(len(s)):
for j in range(i, len(s)):
if j-i+1 > mx and check(s[i:j+1]): # 如果当前段长度大于最长长度且满足条件
try:
ans = eval(s[i:j+1]) # 计算当前段的表达式值
mx = j-i+1 # 更新最长长度
except:
continue
print(ans) # 输出最终答案
最大N个数与最小N个数的和
def function():
m = int(input())
nums = list(set(input().split(" ")))
n = int(input())
nums = [int(num) for num in nums]
nums.sort()
if len(nums) < 2 * n:
return -1
ans = 0
for i in range(0, n):
ans += nums[i]
ans += nums[len(nums) - i - 1]
return ans
if __name__ == '__main__':
ans = function()
print(ans)
小朋友来自多少小区
def get_value(arr):
friends = 0
i = 0
while i < len(arr):
friends += arr[i]
if i + 1 < len(arr) and arr[i] == arr[i + 1]:
j = i
while j < i + arr[i] and j < len(arr):
if arr[i] != arr[j]:
break
j += 1
i = j - 1
i += 1
return friends
arr = [int(i)+1 for i in input().split()]
arr.sort()
print(get_value(arr))
停车场车辆统计
w=list(map(int,input().split(',')))
n=len(w)
l,r=0,0 #双指针
res=0 #最少停车数量
while l<n:
if w[l]==0:
l+=1
continue
r=l
while r<n and w[r]:
r+=1
num=r-l #连续1的个数(某一段可以停的车的数量)
# print(num)
for i in range(3,0,-1): #从大到小枚举停卡车 货车 小车
res+=num//i
num=num%i
l=r
print(res)
执行任务赚积分
题目描述
现有N个任务需要处理，同一时间只能处理一个任务，处理每个任务所需要的时间固定为1。
每个任务都有最晚处理时间限制和积分值，在最晚处理时间点之前处理完成任务才可获得对应的积分奖励。
可用于处理任务的时间有限，请问在有限的时间内，可获得的最多积分。
输入描述
第一行为一个数 N，表示有 N 个任务
1 ≤ N ≤ 100
第二行为一个数 T，表示可用于处理任务的时间
1 ≤ T ≤ 100
接下来 N 行，每行两个空格分隔的整数（SLA 和 V），SLA 表示任务的最晚处理时间，V 表示任务对应的积分。
1 ≤ SLA ≤ 100
0 ≤ V ≤ 100000
输出描述
可获得的最多积分
用例1
输入
4
3
1 2
1 3
1 4
1 5
输出
5
说明
虽然有3个单位的时间用于处理任务，可是所有任务在时刻1之后都无效。 所以在第1个时间单位内，选择处理有5个积分的任务。1-3时无任务处理。
用例2
输入
4
3
1 2
1 3
1 4
3 5
输出
9
说明
第1个时间单位内，处理任务3，获得4个积分
第2个时间单位内，处理任务4，获得5个积分
第3个时间单位内，无任务可处理
共获得9个积分
解题思路
首先，我们将所有任务按照截止时间进行分类，并在每个截止时间内按照积分从高到低进行排序。这样做的目的是为了在每个截止时间内优先处理积分最高的任务。
然后，我们从最大的截止时间开始，逆序遍历每一个截止时间。这样做的目的是为了优先处理截止时间最晚的任务，因为这些任务有更大的灵活性。
对于每个截止时间，我们将所有的任务添加到剩余的任务列表中，。
如果剩余的任务列表不为空，我们就处理积分最高的任务，并将其积分添加到总积分中并对其进行排序，以便优先处理积分最高的任务。这是贪心选择，我们总是选择当前可用的积分最高的任务。
import heapq
# 输入任务数量和时刻上限
n = int(input())
T = int(input())
# 使用列表存储任务，每个任务用一个元组表示
v = []
# 输入每个任务的开始时间和价值
for _ in range(n):
a, b = map(int, input().split())
v.append((a, b))
# 按照处理事件先后顺序从小到大排序
v.sort()
# 创建小根堆，用于存储当前时刻的任务价值
heap = []
# 处理任务
for i in range(n):
# 如果当前任务在当前时刻没有过期
if v[i][0] > len(heap):
# 如果堆的大小小于上限 T，则直接添加任务价值
if len(heap) < T:
heapq.heappush(heap, v[i][1])
# 如果堆已满，比较堆顶任务价值与当前任务价值
# 如果当前任务价值大于堆顶任务价值，则替换堆顶任务价值
elif heap[0] < v[i][1]:
heapq.heappop(heap)
heapq.heappush(heap, v[i][1])
# 如果当前任务在当前时刻已过期，比较堆顶任务价值与当前任务价值
# 如果当前任务价值大于堆顶任务价值，则替换堆顶任务价值
else:
if v[i][1] > heap[0]:
heapq.heappop(heap)
heapq.heappush(heap, v[i][1])
# 计算总任务价值
res = sum(heap)
print(res)
最多购买宝石数目
题目描述
橱窗里有一排宝石，不同的宝石对应不同的价格，宝石的价格标记为 gems[i] 0 ≤ i < n n = gems.length 宝石可同时出售0个或多个，如果同时出售多个，则要求出售的宝石编号连续；
例如客户最大购买宝石个数为m，购买的宝石编号必须为：gems[i]，gems[i+1]，…，gems[i+m-1] 0 ≤ i < n m ≤ n 假设你当前拥有总面值为 value 的钱，请问最多能购买到多少个宝石，如无法购买宝石，则返回0。
输入描述
第一行输入n，参数类型为int，取值范围：[0,10^6]，表示橱窗中宝石的总数量。
之后 n 行分别表示从第0个到第n-1个宝石的价格，即 gems[0] 到 gems[n-1] 的价格，类型为int，取值范围：(0,1000]。
之后一行输入v，类型为int，取值范围：[0,10^9]，表示你拥有的钱。
输出描述
输出int类型的返回值，表示最大可购买的宝石数量。
用例1
输入
7
8
4
6
3
1
6
7
10
输出
3
说明
gems = [8,4,6,3,1,6,7], value = 10
最多购买的宝石为gems[2]至gems[4]或者gems[3]至gems[5]
用例2
输入
0
1
输出
0
说明
gems = [], value = 1 因为没有宝石，所以返回0
用例3
输入
9
6
1
3
1
8
9
3
2
4
15
输出
4
说明
gems = [6, 1, 3, 1, 8, 9, 3, 2, 4], value = 15 最多购买的宝石为gems[0]至gems[3]
用例4
输入
9
1
1
1
1
1
1
1
1
1
10
输出
9
说明
gems = [1, 1, 1, 1, 1, 1, 1, 1, 1], value = 10 最多购买的宝石为gems[0]至gems[8]，即全部购买
解题思路
以下是详细的解题思路：
首先，代码从控制台读取宝石的数量，每颗宝石的价格，以及你拥有的钱的总面值。
然后，初始化滑动窗口的左右边界（left和right）为0，窗口内宝石的总价（sum），以及最大可购买的宝石数量（max）。
在while循环中，首先将右边界的宝石价格加到总价中。如果总价超过你拥有的钱，那么就将左边界的宝石价格从总价中减去，并将左边界向右移动，直到总价不超过你拥有的钱。
然后，更新最大可购买的宝石数量。这是通过比较当前最大可购买的宝石数量和滑动窗口内的宝石数量（right - left + 1）来实现的。
最后，将右边界向右移动，扩大滑动窗口。当滑动窗口的右边界超过宝石数量时，结束循环。
在while循环结束后，输出最大可购买的宝石数量。
通过这种方式，代码能够找出在给定预算下，最多可以购买的宝石数量。
以例3中的宝石数量是9，宝石的价格分别是6、1、3、1、8、9、3、2、4，你拥有的钱的总面值是15。
以下是详细的计算步骤：
初始化：left=0，right=0，sum=0，max=0。
第一步：将右边界的宝石价格加到总价中，sum=6，right=1，left=0，max=1。
第二步：将右边界的宝石价格加到总价中，sum=7，right=2，left=0，max=2。
第三步：将右边界的宝石价格加到总价中，sum=10，right=3，left=0，max=3。
第四步：将右边界的宝石价格加到总价中，sum=11，right=4，left=0，max=4。
第五步：将右边界的宝石价格加到总价中，sum=19，总价超过了你拥有的钱，所以将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=13，right=4，left=1，max=4。
第六步：将右边界的宝石价格加到总价中，sum=22，总价超过了你拥有的钱，所以将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=21，right=5，left=2，max=4。
第七步：继续将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=18，right=5，left=3，max=4。
第八步：继续将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=17，right=5，left=4，max=4。
第九步：继续将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=9，right=5，left=5，max=4。
第十步：将右边界的宝石价格加到总价中，sum=12，right=6，left=5，max=4。
第十一步：将右边界的宝石价格加到总价中，sum=14，right=7，left=6，max=4。
第十一步：将右边界的宝石价格加到总价中，sum=18，总价超过了你拥有的钱，所以将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=9，right=8，left=7，max=4。
第十四步：滑动窗口的右边界已经超过了宝石数量，结束循环。
因此，最大可购买的宝石数量是4。
n=int(input())
w=[0]*n
for i in range(n):
w[i]=int(input())
value=int(input())
ans,sum=0,0 #最大子数组长度/区间和初始化
l,r=0,0 #双指针起始位置
while r<n:
sum+=w[r]
while sum>value: #当区间不满足条件时,l指针右移
sum-=w[l]
l+=1
ans=max(ans,r-l+1) #更新最大值
r+=1
print(ans)
求字符串中所有整数的最小和
s = input()
res = 0
i = 0
while i < len(s):
if not s[i].isdigit() and s[i] != '-':
i += 1
continue
if s[i] == '-':
j = i + 1
num = 0
while j < len(s) and s[j].isdigit():
num = num * 10 + int(s[j])
j += 1
res -= num
i = j
else:
res += int(s[i])
i += 1
print(res)
堆内存申请
n = int(input())
arr = []
while True:#不定行输入
try:
l,r=map(int,input().split())
arr.append([l,l+r-1])
except:
break
arr.sort() #按照左端点进行排序
m=len(arr)
def check(arr): #判断是否有不合法输入
for i in range(m):
x,y=arr[i][0],arr[i][1]
if x<0 or y<0 or x>=100 or y>=100 or x>y: #输入数据不合法
print(x,y)
return False
if i and x<=arr[i-1][1]: #区间有重叠
return False
return True
if not check(arr):
print(-1)
else:
pos,diff=-1,10**9
for i in range(m):
if i==0:
if arr[i][0]>=n and abs(arr[i][0]-n)<diff:
pos=0
diff=abs(arr[i][0]-n)
elif arr[i][0]-arr[i-1][1]>n and abs(arr[i][0]-arr[i-1][1]-n)<diff:
pos=arr[i-1][1]+1
diff=abs(arr[i][0]-arr[i-1][1]-n)
break
if 99-arr[m-1][1]>=n and abs(99-arr[m-1][1]-n)<diff:
pos=arr[m-1][1]+1
print(pos)
测试用例执行计划
n, m = map(int, input().split()) # 读取输入的整数n和m
w = [0] * (n + 1) # 创建长度为n+1的整数列表w，初始值为0
for i in range(1, n + 1):
w[i] = int(input()) # 读取n个整数并存入列表w
lists = [[] for _ in range(m)] # 创建m个空列表的列表
for i in range(m):
arr = [w[int(x)] for x in input().split()] # 读取一行输入，将其按空格分割并转为整数列表arr
_sum = sum(arr) # 计算arr的和
lists[i].append(_sum) # 将和添加到lists的第i个元素中
lists[i].append(i + 1) # 将i+1添加到lists的第i个元素中
lists.sort(key=lambda x: (-x[0], x[1])) # 对lists进行排序，首先按照第一个元素降序排序，然后按照第二个元素升序排序
for l in lists:
print(l[-1]) # 输出lists的每个元素的最后一个值
338
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
