智能成绩表

题目描述
小明来到学校当老师，需要将学生按考试总分或单科分数进行排名，你能帮帮他吗？

输入描述
第 1 行输入两个整数，学生人数 n 和科目数量 m。
0 < n < 100
0 < m < 10
第 2 行输入 m 个科目名称，彼此之间用空格隔开。

科目名称只由英文字母构成，单个长度不超过10个字符。

科目的出现顺序和后续输入的学生成绩一一对应。

不会出现重复的科目名称。

第 3 行开始的 n 行，每行包含一个学生的姓名和该生 m 个科目的成绩（空格隔开）

学生不会重名。
学生姓名只由英文字母构成，长度不超过10个字符。
成绩是0~100的整数，依次对应第2行种输入的科目。
第n+2行，输入用作排名的科目名称。若科目不存在，则按总分进行排序。

输出描述
输出一行，按成绩排序后的学生名字，空格隔开。成绩相同的按照学生姓名字典顺序排序。

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=" ")

按身高和体重排队

题目描述
某学校举行运动会，学生们按编号(1、2、3…n)进行标识，现需要按照身高由低到高排列， 对身高相同的人，按体重由轻到重排列； 对于身高体重都相同的人，维持原有的编号顺序关系。请输出排列后的学生编号。

输入描述
两个序列，每个序列由n个正整数组成（0 < n <= 100）。

第一个序列中的数值代表身高，第二个序列中的数值代表体重。

输出描述
排列结果，每个数值都是原始序列中的学生编号，编号从1开始
用例1
输入
4
100 100 120 130
40 30 60 50

输出
2 1 3 4

说明
❝
输出的第一个数字2表示此人原始编号为2，即身高为100，体重为30的这个人。 由于他和编号为1的人身高一样，但体重更轻，因此要排在1前面。
❞

class Person:
    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

n=int(input())
height=list(map(int,input().split()))
weight=list(map(int,input().split()))
person=[]
for i in range(n):
    person.append([height[i],weight[i],i+1])

person.sort(key=lambda x:(x[0],x[1],x[2]))

for i in range(n):
    print(person[i][2],end='')
    if i+1<n:
        print(" ",end='')

攀登者1

s=input()
s=s[1:len(s)-1]  #去掉开头的[和结尾的]
w=list(map(int,s.split(',')))  #转为数组
res=0
n=len(w)
for i in range(n):
    l,r=-10**9,-10**9  #初始化相邻元素值
    if i>0:
        l=w[i-1]
    if i+1<n:
        r=w[i+1]
    if w[i]>l and w[i]>r:
        res+=1
print(res)

攀登者2

def count_mountain_climbs(terrain, stamina):
    size = len(terrain)

    # 初始化数组 left_moves、right_moves，表示从左右两边攀爬到当前位置的代价
    left_moves, right_moves = [-1] * (size + 1), [-1] * (size + 1)

    # 计算从左边攀爬到当前位置的代价
    for i in range(size):
        if terrain[i] == 0 and i - 1 > 0 and terrain[i - 1] != 0:
            j = i - 1
            right_moves[i] = 0
            while j >= 0 and terrain[j] != 0:
                if terrain[j] > terrain[j + 1]:
                    right_moves[j] = right_moves[j + 1] + 2 * (terrain[j] - terrain[j + 1])
                else:
                    right_moves[j] = right_moves[j + 1] + (terrain[j + 1] - terrain[j])
                j -= 1

        # 计算从右边攀爬到当前位置的代价
        if terrain[i] == 0 and i + 1 < size and terrain[i + 1] != 0:
            j = i + 1
            left_moves[i] = 0
            while j < size and terrain[j] > 0:
                if terrain[j] > terrain[j - 1]:
                    left_moves[j] = left_moves[j - 1] + 2 * (terrain[j] - terrain[j - 1])
                else:
                    left_moves[j] = left_moves[j - 1] + (terrain[j - 1] - terrain[j])
                j += 1

    # 初始化数组 left_total、right_total，表示从左右两边攀爬到当前位置的总代价
    left_total, right_total = [-1] * (size + 1), [-1] * (size + 1)

    # 计算从左边攀爬到当前位置的总代价
    for i in range(1, size):
        if terrain[i] == 0:
            left_total[i] = 0
        else:
            if terrain[i - 1] > terrain[i]:
                left_total[i] = left_total[i - 1] + 2 * (terrain[i - 1] - terrain[i])
            else:
                left_total[i] = left_total[i - 1] + terrain[i] - terrain[i - 1]

    # 计算从右边攀爬到当前位置的总代价
    for i in range(size - 2, -1, -1):
        if terrain[i] == 0:
            right_total[i] = 0
        else:
            if terrain[i + 1] > terrain[i]:
                right_total[i] = right_total[i + 1] + 2 * (terrain[i + 1] - terrain[i])
            else:
                right_total[i] = right_total[i + 1] + terrain[i] - terrain[i + 1]

    climb_count = 0
    
    # 遍历山脉，判断是否可以攀爬
    for i in range(0, size):
        if terrain[i] > terrain[i - 1] and terrain[i] > terrain[i + 1]:
            min_cost = 10**15

            # 如果存在从左边攀爬到当前位置的代价，则更新 min_cost
            if left_moves[i] != -1:
                min_cost = min(min_cost, left_moves[i] + left_total[i])

            # 如果存在从右边攀爬到当前位置的代价，则更新 min_cost
            if right_moves[i] != -1:
                min_cost = min(min_cost, right_moves[i] + right_total[i])

            # 如果同时存在从左边和右边攀爬到当前位置的代价，则更新 min_cost
            if left_moves[i] != -1 and right_moves[i] != -1:
                min_cost = min(left_moves[i] + right_total[i], right_moves[i] + left_total[i], min_cost)

            # 如果最小代价小于等于 stamina，则可攀爬，计数加一
            if min_cost <= stamina:
                climb_count += 1

    return climb_count

# 从输入中读取整数数组 terrain
terrain_data = list(map(int, input().split()))

# 从输入中读取目标值 stamina
stamina_value = int(input())

# 输出计算结果
print(count_mountain_climbs(terrain_data, stamina_value))

分披萨

n = int(input())  # 输入披萨的数量
a = [int(input()) for i in range(n)]  # 输入每块披萨的美味值
dp = [[-1] * n for i in range(n)]  # 记忆化数组，用于存储已计算过的状态

def solve(L, R):
    # “馋嘴“选择一块披萨吃掉，对应端点移动
    if a[L] > a[R]:
        L = (L+1) % n
    else:
        R = (R+n-1) % n
    # 如果该状态已经计算过，则直接返回结果
    if dp[L][R] != -1:
        return dp[L][R]
    # 如果左右端点相同，则说明只剩下一块披萨，直接返回该披萨的美味值
    if L == R:
        dp[L][R] = a[L]
    else:
        # 分别计算选择左边披萨和选择右边披萨的情况下的最大美味值
        dp[L][R] = max(a[L] + solve((L+1)%n, R), a[R] + solve(L, (R+n-1)%n))
    return dp[L][R]

ans = 0
# 枚举吃货第一步取哪块披萨
for i in range(n):
    # 计算当前情况下吃货最多能吃到的披萨的美味值，并更新答案
    ans = max(ans, solve((i+1)%n, (i+n-1)%n) + a[i])

print(ans)  # 输出最多能吃到的披萨的美味值

机械绘图

n, e = map(int, input().split())
last_x = 0   # 记录上一个位置的横坐标
y = 0      # 记录起始点的纵坐标
area = 0    # 记录面积
for i in range(n):
    x, d = map(int, input().split())
    area += (x - last_x) * abs(y)   # 计算执行第i个指令后的增量面积
    y += d   # 更新纵坐标
    last_x = x   # 更新上一个位置的横坐标
area += (e - last_x) * abs(y)   # 计算终点的增量面积
print(area)

英文输入法

import re  # 导入re模块
 
s = input()  # 读取输入的字符串s
t = input()  # 读取输入的字符串t
 
s1 = re.split("[^a-zA-Z]", s)  # 使用正则表达式将字符串s按非字母字符分割
s2 = list(set(s1))  # 将分割后的结果转为集合去重，再转为列表
s2.sort()  # 对列表进行排序
s2 = list(filter(lambda x: x.startswith(t), s2))  # 过滤出以t开头的字符串
if len(s2) > 0:  # 如果过滤后的列表长度大于0
    print(" ".join(s2))  # 输出连接后的字符串
else:  # 否则
    print(t)  # 输出字符串t

小华最多能得到多少克黄金

from queue import Queue

m, n, k = map(int, input().split(" "))
if m == 0 or n == 0:
    print(0)
else:
    arr = []
    res = 0
    for i in range(m):
        tem = []
        for j in range(n):
            x = sum(int(digit) for digit in str(i))
            y = sum(int(digit) for digit in str(j))
            if x + y <= k:
                tem.append(1)
            else:
                tem.append(0)
        arr.append(tem)
    q = Queue()
    q.put([0, 0])
    arr[0][0] = 0
    dirs = [-1, 0, 1, 0, -1]
    while not q.empty():
        cur = q.get()
        res += 1
        i, j = cur
        for k in range(4):
            x = i + dirs[k]
            y = j + dirs[k + 1]
            if x < 0 or x >= m or y < 0 or y >= n or arr[x][y] == 0:
                continue
            arr[x][y] = 0
            q.put([x, y])
    print(res)

分配土地

n, m = map(int, input().split())
mp = {}

# 读取矩阵数据并记录非零元素的位置
for i in range(1, n + 1):
    j = 1
    for a in list(map(int, input().split())):
        if a != 0:
            if a not in mp:
                mp[a] = []
            mp[a].append((i, j))
        j += 1

ans = 0
# 遍历记录的非零元素及其位置，计算包含该元素的矩形的最大面积
for u, v in mp.items():
    minrow, maxrow, mincol, maxcol = float('inf'), 0, float('inf'), 0

    # 计算当前非零元素所在矩形的行列范围
    for t in v:
        minrow = min(minrow, t[0])
        maxrow = max(maxrow, t[0])
        mincol = min(mincol, t[1])
        maxcol = max(maxcol, t[1])

    # 计算当前矩形的面积，并更新最大面积
    ans = max(ans, (maxrow - minrow + 1) * (maxcol - mincol + 1))

print(ans)  # 输出最大矩形面积

字符串变换最小字符串

题目描述
给定一个字符串s，最多只能进行一次变换，返回变换后能得到的最小字符串（按照字典序进行比较）。

变换规则：交换字符串中任意两个不同位置的字符。

输入描述
一串小写字母组成的字符串s

输出描述
按照要求进行变换得到的最小字符串。

s = input()
t = sorted(s)

for i in range(len(s)):
    if s[i] != t[i]:
        for j in range(len(s) - 1, -1, -1):
            if s[j] == t[i]:
                s = s[:i] + s[j] + s[i+1:j] + s[i] + s[j+1:]
                break
        break

print(s)

考勤信息

题目描述
公司用一个字符串来表示员工的出勤信息

absent：缺勤

late：迟到

leaveearly：早退

present：正常上班

现需根据员工出勤信息，判断本次是否能获得出勤奖，能获得出勤奖的条件如下：

缺勤不超过一次；

没有连续的迟到/早退；

任意连续7次考勤，缺勤/迟到/早退不超过3次。

输入描述
用户的考勤数据字符串
记录条数 >= 1；
输入字符串长度 < 10000；
不存在非法输入；

如：

❝
2
present
present absent present present leaveearly present absent
❞
输出描述
根据考勤数据字符串，如果能得到考勤奖，输出”true”；否则输出”false”，
对于输入示例的结果应为：

❝
true false
❞

mp={"absent":0,"late":1,"leaveearly":2,"present":3}  #出勤信息映射
def check(s):
    cnts=[0]*4  #统计每一项的次数
    m=len(s)
    for i in range(m):
        cnts[mp[s[i]]]+=1
        if i>6: 
            cnts[mp[s[i-7]]]-=1
        if i>=6 and cnts[3]<4:  #正常上班天数<4，则说明其他天数超过3次
            return False
        if i and 1<=mp[s[i]]<=2 and 1<=mp[s[i-1]]<=2:  #连续的迟到，早退
            return False
    count=0  #单独统计所有的缺勤次数
    for x in s:
        if mp[x]==0:
            count+=1
    return count<=1
    
n=int(input())
for _ in range(n):
    s=input().split(' ')
    if check(s):
        print("true")
    else:
        print("false")

游戏分组/英雄联盟

题目描述
2020年题：

英雄联盟是一款十分火热的对战类游戏。每一场对战有10位玩家参与，分为两组，每组5人。每位玩家都有一个战斗力，代表着这位玩家的厉害程度。为了对战尽可能精彩，我们需要把玩家们分为实力尽量相等的两组。一组的实力可以表示为这一组5位玩家的战斗力和。现在，给你10位玩家的战斗力，请你把他们分为实力尽量相等的两组。请你输出这两组的实力差。

2023年题：

部门准备举办一场王者荣耀表演赛，有10名游戏爱好者参与，分5为两队，每队5人。每位参与者都有一个评分，代表着他的游戏水平。为了表演赛尽可能精彩，我们需要把10名参赛者分为实力尽量相近的两队。一队的实力可以表示为这一队5名队员的评分总和。 现在给你10名参与者的游戏水平评分，请你根据上述要求分队最后输出这两组的实力差绝对值。 例: 10名参赛者的评分分别为5 1 8 3 4 6 710 9 2，分组为 (135 8 10) (24 679)，两组实力差最小，差值为1。有多种分法，但实力差的绝对值最小为1。

输入描述
10个整数，表示10名参与者的游戏水平评分。范围在[1,10000]之间

输出描述
1个整数，表示分组后两组实力差绝对值的最小值.

a=list(map(int,input().split()))
ans=abs(sum(a[:5])-sum(a[5:]))
for i in range(1<<10):
    cnt=[0,0]
    val=[0,0]
    for j in range(10):
        cnt[(i>>j)&1]+=1
        val[(i>>j)&1]+=a[j]
    if cnt[0]==cnt[1]:
        ans=min(ans,abs(val[0]-val[1]))
print(ans)

精准核酸检测

while True:
    try:
       
        n = int(input())
        list_qz = list(map(int, input().split(",")))
        list_qz1 = list_qz.copy()
        list_rq = []
        for i in range(n):
            list_rq.append(list(map(int, input().split(","))))
       
        result = []
        vistied = []
        while list_qz:
            a = list_qz.pop(0)
            if a not in vistied:
                vistied.append(a)
                
                for i in range(n):
                    if list_rq[a][i] == 1 and i != a:
                        result.append(i)
                       
                        if sum(list_rq[i]) > 1:
                            list_qz.append(i)
 
      
        result = [i for i in result if i not in list_qz1]
        print(len(set(result)))
    except:
        break