• python刷题笔记1(42例题)


    1. split()函数

    str.split([sep [, maxsplit]])

     分割字符串,返回一个数组

    2. 判断子串

    1. # 判断子串是否在主串里面,是则输出“Yes”,否则输出“No”
    2. str1 = input("子串:")
    3. str2 = input("主串:")
    4. if str1 in str2:
    5. print("Yes")
    6. else:
    7. print("NO")
    子串:hello world
    主串:this is hello world, it is ok.
    Yes

    3. 反向输出一个三位数

    法一:运用字符串切片

    字符串可以切片:

    法二:取余和除法

    1. def reverse_integer(num):
    2. reversed_num = 0
    3. while num != 0:
    4. digit = num % 10
    5. reversed_num = reversed_num * 10 + digit
    6. num = num // 10
    7. return reversed_num
    8. # 示例
    9. # num = 12345
    10. num = int(input("输入一个数:")) # erro: 输入100,输出1
    11. reversed_num = reverse_integer(num)
    12. print(reversed_num) # 输出:54321

    4.  22、整数序列的元素最大跨度值

     描述

    给定一个长度为n的非负整数序列,请计算序列的最大跨度值(最大跨度值 = 最大值减去最小值)。

    输入

    一共2行,第一行为序列的个数n(1 <= n <= 1000),第二行为序列的n个不超过1000的非负整数,整数之间以一个空格分隔。

    输出

    输出一行,表示序列的最大跨度值。

    样例输入

    6
    3 0 8 7 5 9

    样例输出

    9

    代码:!!

    1. n = int(input())
    2. s = input().split()
    3. maxV = minV = int(s[0])
    4. for i in s:
    5. maxV = max(maxV,int(i))
    6. minV = min(minV,int(i))
    7. print(maxV-minV)

    5.  28、数字统计

     描述

    请统计某个给定范围[L, R]的所有整数中,数字2出现的次数。

    比如给定范围[2, 22],数字2在数2中出现了1次,在数12中出现1次,在数20中出现1次,在数21中出现1次,在数22中出现2次,所以数字2在该范围内一共出现了6次。

    输入

    输入共 1 行,为两个正整数 L 和 R,之间用一个空格隔开。

    输出

    输出共 1 行,表示数字 2 出现的次数。

    样例输入输出

    2 100
    20

    2 22

    6

    代码展示:

    1. # 28、!!数字统计
    2. m = input().split()
    3. L, R = int(m[0]), int(m[1])
    4. count = 0
    5. for i in range(L,R+1):
    6. if i%10 == 2:
    7. count+=1
    8. if i // 10 == 2:
    9. count+=1
    10. # 参考答案1:
    11. # total=0
    12. # for i in range(L,R+1):
    13. # while i!=0:
    14. # m=i%10
    15. # if m == 2:
    16. # total+=1
    17. # i//=10
    18. # 参考答案2:
    19. # for i in range(L,R+1):
    20. # s=str(i)
    21. # for x in s:
    22. # if x == '2':
    23. # total+=1
    24. print(count)

    6.  29、数字反转​​

     描述

    给定一个整数,请将该数各个位上数字反转得到一个新数。新数也应满足整数的常见形式,即除非给定的原数为零,否则反转后得到的新数的最高位数字不应为零(参见样例2)。

    输入

    输入共 1 行,一个整数N。

    -1,000,000,000 ≤ N≤ 1,000,000,000。

    输出

    输出共 1 行,一个整数,表示反转后的新数。

    样例输入输出:

    123

    321

    -380

    -83

    代码展示:

    1. # 29、数字反转
    2. num = input()
    3. if num == 0:
    4. print(0)
    5. else:
    6. if num[0] == "-":
    7. num = num[1:]
    8. while num[-1] == "0":
    9. num = num[:-1]
    10. else:
    11. num = num
    12. num = num[::-1]
    13. print("-"+num)
    14. else:
    15. while num[-1] == "0":
    16. num = num[:-1]
    17. else:
    18. num = num
    19. num = num[::-1]
    20. print(num)

    7.30、求最大公约数问题

     描述

    给定两个正整数,求它们的最大公约数。

    输入

    输入一行,包含两个正整数(<1,000,000,000)。

    输出

    输出一个正整数,即这两个正整数的最大公约数。

    样例输入输出:

    6 9

    3

    提示:求最大公约数可以使用辗转相除法

    假设a > b > 0,那么a和b的最大公约数等于b和a%b的最大公约数,然后把b和a%b作为新一轮的输入。
    由于这个过程会一直递减,直到a%b等于0的时候,b的值就是所要求的最大公约数。
    比如:
    9和6的最大公约数等于6和9%6=3的最大公约数。
    由于6%3==0,所以最大公约数为3。

    代码展示

    1. s = input().split()
    2. a, b = int(s[0]), int(s[1])
    3. if a > b:
    4. while a%b!=0:
    5. c = a % b
    6. a = b
    7. b = c
    8. print(b)
    9. else:
    10. while b%a!=0:
    11. c = b % a
    12. b = a
    13. a = c
    14. print(a)

    8.  多少种取法(递归)

     描述

    给定三个正整数m,n,s问从1到m这m个数里面取n个不同的数,使它们和是s,有多少种取法

    输入

    多组数据
    输入的第一行是整数t,表示有t组数据
    此后有t行,每行是一组数据
    每组数据就是三个正整数,m,n, s ( n <= 10,s <= 20)

    5
    13 4 20
    12 5 18
    1 1 1
    1 2 1
    119 3 20

    输出

    22
    3
    1
    0
    24

    代码展示:

    1. def count_ways(m,n,s):
    2. if n == 0 and s == 0:
    3. return 1
    4. elif n == 0 or m == 0:
    5. return 0
    6. if m <= 0:
    7. return 0 # 如果可选的数已经用完,返回0
    8. if m > s:
    9. m = s # 如果可选的最大数大于s,将其限制为s,以减小计算复杂性
    10. return count_ways(m-1,n-1,s-m) + count_ways(m-1,n,s)
    11. n = int(input())
    12. for i in range(n):
    13. a, b, c = map(int,input().split())
    14. #map()会根据提供的函数对指定的序列做出映射
    15. print(count_ways(a,b,c))
    函数的递归逻辑如下:
    • 如果 n 等于 0 并且 s 等于 0,则表示已经成功选择了 n 个整数使它们的和等于 s,此时返回 1,表示找到一种方法。

    • 如果 m 等于 0 或 n 等于 0,则不可能再选择整数,因此返回 0,表示没有方法

    return count_ways(m-1,n-1,s-m) + count_ways(m-1,n,s)讲解:

    在一般情况下,函数会递归调用自身两次

    • 一次是选择当前整数 m,然后递归计算在剩余的整数范围内选择 n-1 个整数使它们的和为 s-m
    • 另一次是不选择当前整数 m,然后递归计算在剩余的整数范围内选择 n 个整数使它们的和为 s

    函数会返回这两种情况的方法数量之和,因为这代表了所有可能的方法。

    这个递归函数通过不断减小整数范围 mn 的值,同时调整目标和 s,来计算所有可能的方法数。在达到基本情况之后,递归函数开始回溯,计算所有可能的方法数,最终返回总的方法数量。

    9.石头剪刀布

    描述

    石头剪刀布是常见的猜拳游戏。石头胜剪刀,剪刀胜布,布胜石头。如果两个人出拳一样,则不分胜负。

    一天,小A和小B正好在玩石头剪刀布。已知他们的出拳都是有周期性规律的,比如:“石头-布-石头-剪刀-石头-布-石头-剪刀……”,就是以“石头-布-石头-剪刀”为周期不断循环的。请问,小A和小B比了N轮之后,谁赢的轮数多?

    输入

    输入包含三行。
    第一行包含三个整数:N,NA,NB,分别表示比了N轮,小A出拳的周期长度,小B出拳的周期长度。0 < N,NA,NB < 100。
    第二行包含NA个整数,表示小A出拳的规律。
    第三行包含NB个整数,表示小B出拳的规律。
    其中,0表示“石头”,2表示“剪刀”,5表示“布”。相邻两个整数之间用单个空格隔开。

    输出

    输出一行,如果小A赢的轮数多,输出A;如果小B赢的轮数多,输出B;如果两人打平,输出draw。

    样例输入

    10 3 4
    0 2 5
    0 5 0 2

    样例输出

    A

    提示

    对于测试数据,猜拳过程为:
    A:0 2 5 0 2 5 0 2 5 0
    B:0 5 0 2 0 5 0 2 0 5
    A赢了4轮,B赢了2轮,双方打平4轮,所以A赢的轮数多。

    代码:

    1. # !!!!!32、石头剪刀布
    2. # 0表示“石头”,2表示“剪刀”,5表示“布”
    3. def result(a,b):
    4. if a == b:
    5. return 0
    6. if a == 5 and b == 0:
    7. return 1
    8. if a == 0 and b == 5:
    9. return -1
    10. if a < b:
    11. return 1
    12. else:
    13. return -1
    14. # n, na, nb--分别表示比了n轮,小A出拳的周期长度,小B出拳的周期长度
    15. n, na, nb = map(int,input().split())
    16. a = input().split() # 小A出拳的规律,包含na个整数
    17. b = input().split() # # 小B出拳的规律,包含nb个整数
    18. a_count = b_count = 0 # 赢的次数
    19. pa = pb = 0 # 用来遍历周期长度
    20. for i in range(n):
    21. r = result(int(a[pa]),int(b[pb]))
    22. if r == 1:
    23. a_count += 1
    24. elif r == -1:
    25. b_count += 1
    26. pa = (pa + 1) % na
    27. pb = (pb + 1) % nb
    28. if a_count > b_count:
    29. print("A wins!")
    30. elif a_count < b_count:
    31. print("B wins!")
    32. else:
    33. print("draw")

    10.统计数字字符个数

    描述

    输入一行字符,统计出其中数字字符的个数

    输入

    一行字符串,总长度不超过255。

    输出

    输出为1行,输出字符串里面数字字符的个数。

    样例输入

    Peking University is set up at 1898.

    样例输出

    4

    代码:(两种方法)

    1. # 33、统计数字字符个数 方法一
    2. s = input()
    3. count = 0
    4. for i in s:
    5. if '0' <= i <= '9':
    6. count += 1
    7. print(count)
    1. # 33、统计数字字符个数 方法二
    2. s = input()
    3. sum = 0
    4. for i in s:
    5. if i.isdigit(): # isdigit()函数判断是否为数字字符
    6. sum += 1
    7. print(sum)

    isdigit()函数:

    1.语法

    str.isdigit()

    2.参数:该方法不接受任何参数。

    3.返回值

    • 如果字符串中所有字符都是数字字符,则返回True
    • 如果字符串中至少有一个非数字字符(包括空格、标点符号等),则返回False

    11.大小写字母互换

     描述

    把一个字符串中所有出现的大写字母都替换成小写字母,同时把小写字母替换成大写字母。

    输入

    输入一行:待互换的字符串。

    输出

    输出一行:完成互换的字符串(字符串长度小于80)。

    样例输入

    She hasn't started writing it.

    样例输出

    sHE HASN'T STARTED WRITING IT.

    代码展示

    1. # 34、大小写字母互换
    2. s = input()
    3. for c in s:
    4. if 'a' <= c <= 'z':
    5. print(chr(ord(c) - 32 ),end="")
    6. elif 'A' <= c <= 'Z':
    7. print(chr(ord(c) + 32),end="")
    8. else:
    9. print(c,end="")

     Python内置函数——chr()函数和ord()函数

    • chr() 函数用于获取给定整数(0~255)对应的 ASCll字符
    • ord() 函数用于获取给定字符的ASCll数值
      1. print(chr(65)) # Output: 'A'
      2. print(ord('A')) # Output: 65

    11.找第一个只出现一次的字符

     描述

    给定一个只包含小写字母的字符串,请你找到第一个仅出现一次的字符。如果没有,输出no。

    输入

    一个字符串,长度小于100000。

    输出

    输出第一个仅出现一次的字符,若没有则输出no。

    输入样例

    abcabd

    输出样例

    c

    代码

    1. def find_first_unique_character(s):
    2. char_count = {}
    3. # 统计每个字符出现的次数
    4. for char in s:
    5. char_count[char] = char_count.get(char, 0) + 1
    6. # 找到第一个仅出现一次的字符
    7. for char in s:
    8. if char_count[char] == 1:
    9. return char
    10. return 'no' # 如果没有仅出现一次的字符,则返回'no'
    11. # 主程序
    12. if __name__ == '__main__':
    13. input_str = input().strip() # 获取用户输入的字符串
    14. result = find_first_unique_character(input_str)
    15. print(result)

    字典 get()方法

    语法:dict.get(key[, value])

    参数

    • key -- 字典中要查找的键。
    • value -- 可选,如果指定键的值不存在时,返回该默认值

    例:

    1. tinydict = {'Name': 'Kim', 'Age': 27}
    2. print ("Age : %s" % tinydict.get('Age'))
    3. # 没有设置 Sex,也没有设置默认的值,输出 None
    4. print ("Sex : %s" % tinydict.get('Sex'))  
    5. # 没有设置 Salary,输出默认的值  0.0
    6. print ('Salary: %s' % tinydict.get('Salary', 0.0))

    Age : 27

    Sex : None

    Salary: 0.0

    strip()函数

    strip()是一个字符串方法,用于去除字符串两端的空白字符(包括空格、制表符和换行符)。它返回一个新的字符串,该字符串是原始字符串去除两端空白字符后的结果。注意,原始字符串text本身不会被修改,而是返回了一个新的字符串。

    1. text = " Hello, World! "
    2. new_text = text.strip()
    3. print(new_text) # 输出: "Hello, World!"

    此外,strip()方法还可以接受一个参数,用于指定要删除的字符集合。例如,可以使用strip('!')来删除字符串两端的感叹号:

    1. text = "!!Hello, World!!!"
    2. new_text = text.strip('!')
    3. print(new_text) # 输出: "Hello, World"

    12.判断字符串是否为回文

     描述

    输入一个字符串,输出该字符串是否回文。回文是指顺读和倒读都一样的字符串。

    输入

    输入为一行字符串(字符串中没有空白字符,字符串长度不超过100)。

    输出

    如果字符串是回文,输出yes;否则,输出no。

    实例输入

    abcdedcba

    实例输出

    yes

    代码:

    1. # 37、!!!判断字符串是否为回文
    2. s = input()
    3. def huiwen():
    4. i = 0
    5. j = len(s) - 1
    6. while i < j:
    7. if s[i] != s[j]:
    8. return "no"
    9. i += 1
    10. j -= 1
    11. return "yes"
    12. if __name__ == '__main__':
    13. result = huiwen()
    14. print(result)
    1. a = input()
    2. if a == a[::-1]:
    3. print('yes')
    4. else:
    5. print('no')

    13.38、字符串最大跨距

     描述

    有三个字符串S,S1,S2,其中,S长度不超过300,S1和S2的长度不超过10。想检测S1和S2是否同时在S中出现,且S1位于S2的左边,并在S中互不交叉(即,S1的右边界点在S2的左边界点的左侧)。计算满足上述条件的最大跨距(即,最大间隔距离:最右边的S2的起始点与最左边的S1的终止点之间的字符数目)。如果没有满足条件的S1,S2存在,则输出-1。

    例如,S = "abcd123ab888efghij45ef67kl", S1="ab", S2="ef",其中,S1在S中出现了2次,S2也在S中出现了2次,最大跨距为:18。

    输入

    三个串:S, S1, S2,其间以逗号间隔(注意,S, S1, S2中均不含逗号和空格);

    输出

    S1和S2在S最大跨距;若在S中没有满足条件的S1和S2,则输出-1。

    样例输入

    abcd123ab888efghij45ef67kl,ab,ef

    样例输出

    18

    代码

    1. # 38、字符串最大跨距
    2. n = input().split(',')
    3. s, s1, s2 = n[0], n[1], n[2]
    4. if s1 in s and s2 in s:
    5. x = s.find(s1) # 在字符串a中查找子字符串b的第一个出现位置,并将结果赋值给变量x
    6. y = s.rfind(s2) # 在字符串a中查找子字符串c的最后一个出现位置,并将结果赋值给变量y
    7. if x >= y:
    8. print('-1')
    9. else:
    10. print(y-x-len(s2))
    11. else:
    12. print('-1')

    find()rfind()函数是Python中用于查找子字符串在字符串中位置的方法。它们的具体功能如下:

    find()函数

    find()函数用于在字符串中查找子字符串第一次出现的位置。如果找到子字符串,则返回子字符串的起始索引;如果没有找到,则返回-1

    str.find(sub[, start[, end]])

    • sub:要搜索的子字符串。
    • start(可选):搜索的起始位置,默认为0。
    • end(可选):搜索的结束位置,默认为字符串的长度。

    示例:

    s = "Hello, world"

    print(s.find("o")) # 输出:4

    print(s.find("x")) # 输出:-1

    rfind()函数

    rfind()函数与find()类似,不同之处在于它从右向左查找子字符串最后一次出现的位置。如果找到子字符串,则返回子字符串的起始索引;如果没有找到,则返回-1

    str.rfind(sub[, start[, end]])

    • sub:要搜索的子字符串。
    • start(可选):搜索的起始位置,默认为0。
    • end(可选):搜索的结束位置,默认为字符串的长度。

    示例:

    s = "Hello, world"

    print(s.rfind("o")) # 输出:8

    print(s.rfind("x")) # 输出:-1

    总结:
    • find()rfind()函数都是用来查找子字符串在字符串中的位置。
    • find()从左向右查找子字符串第一次出现的位置。
    • rfind()从右向左查找子字符串最后一次出现的位置。
    • 如果找到子字符串,这两个方法返回子字符串在原始字符串中的索引;如果没有找到,则返回-1。

    14 39、找出全部子串位置

     描述

    输入两个串s1,s2,找出s2在s1中所有出现的位置

    两个子串的出现不能重叠。例如'aa'在 aaaa 里出现的位置只有0,2

    输入

    第一行是整数n
    接下来有n行,每行两个不带空格的字符串s1,s2

    输出

    对每行,从小到大输出s2在s1中所有的出现位置。位置从0开始算
    如果s2没出现过,输出 "no"
    行末多输出空格没关系

    样例输入

    4
    ababcdefgabdefab ab
    aaaaaaaaa a
    aaaaaaaaa aaa 
    112123323 a

    样例输出:

    0 2 9 14 
    0 1 2 3 4 5 6 7 8 
    0 3 6 
    no

    代码:

    1. # 39、找出全部子串位置
    2. num = int(input())
    3. for i in range(num):
    4. s = input().split()
    5. m = 0
    6. if s[1] not in s[0]:
    7. print('no',end='')
    8. for j in s[0]:
    9. a = s[0].find(s[1],m)
    10. if a == -1:
    11. continue
    12. else:
    13. m = a + len(s[1])
    14. print(a,'',end='')
    15. print("") #每次循环换行

    运行结果:

    15   40、万年历

     描述

    给定年月日,求星期几。已知2020年11月18日是星期三。另外,本题有公元0年,这个和真实的纪年不一样

    输入

    第一行是n(n <=30),表示有n组数据
    接下来n行,每行是一组数据。
    每行三个整数y,m,d,分别代表年,月,日。(-1000000<=y<=1000000)

    若今年是2017年,则往前就是2016年,2015年....一直数到2年,1年,再往前就是0年,-1年,-2年.....

    输出

    对每组数据,输出星期几,星期几分别用

    "Sunday","Monday","Tuesday","Wednesday","Thursday", "Friday","Saturday" 表示

    如果月份和日期不合法,输出"Illegal"

    样例输入

    6
    2017 2 29
    2017 13 2
    0 1 1
    -2 3 4
    2017 10 18
    2015 12 31

    样例输出

    Illegal
    Illegal
    Saturday
    Wednesday
    Wednesday
    Thurs

    代码:

    1. # 40、万年历
    2. # 判断是否为闰年
    3. def is_leap_year(year):
    4. if (year % 4 == 0) and (year % 100 != 0) or (year % 400 == 0):
    5. return True
    6. else:
    7. return False
    8. def judge_week(year, month, day):
    9. days = date = 0
    10. lst1 = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] # 闰年每月天数列表
    11. lst2 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] # 平年每月天数列表
    12. lst_days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
    13. is_leap = is_leap_year(year) # 判断是否为闰年
    14. # 判断month是哪月
    15. if month in [1, 3, 5, 7, 8, 10, 12]: # 月份有31天
    16. if day < 1 or day > 31:
    17. print('Illegal')
    18. return
    19. elif month == 2: # 2月份
    20. # 公历年份能够被4整除但不能被100整除的年份是闰年,或者能够被400整除的年份也是闰年
    21. if is_leap:
    22. if day < 1 or day > 29: # 闰年2月份有29天
    23. print('Illegal')
    24. return
    25. else:
    26. if day < 1 or day > 28: # 闰年2月份有28天
    27. print('Illegal')
    28. return
    29. elif month in [4, 6, 9, 11]:
    30. if day < 1 or day > 30:
    31. print('Illegal')
    32. return
    33. else:
    34. print('Illegal')
    35. return
    36. if year >= 1: #1年1月1日为星期一
    37. #累加整年数
    38. for i in range(1,year):
    39. if i % 4 == 0 and i % 100 != 0 or i % 400 == 0:
    40. days+=366
    41. else:
    42. days+=365
    43. #累加整月数
    44. if is_leap:
    45. for i in range(month-1,12):
    46. date += lst1[i] # 闰年每月天数
    47. else:
    48. for i in range(month-1,12):
    49. date += lst2[i] # 平年每月天数
    50. total = date + day + days
    51. x=total % 7
    52. print(lst_days[x])
    53. else:
    54. for i in range(year+1, 1):
    55. if (i % 4 == 0) and (i % 100 != 0) or i % 400 == 0:
    56. days += 366
    57. else:
    58. days += 365 # 累加整年数
    59. if is_leap:
    60. for i in range(month - 1,12):
    61. date += lst1[i]
    62. else:
    63. for i in range(month - 1,12):
    64. date += lst2[i] # 累加整月数
    65. total = date - day + 1 + days
    66. x = total % 7
    67. print(lst_days[(8-x)%7])
    68. n = int(input())
    69. for i in range(n):
    70. y, m, d = map(int,input().split())
    71. judge_week(y, m, d)

    计算实际年月份的对应日期 代码:

    1. import datetime
    2. def judge_week(year, month, day):
    3. try:
    4. input_date = datetime.date(year, month, day)
    5. week_day = input_date.strftime("%A")
    6. print(week_day)
    7. except ValueError:
    8. print('Illegal')
    9. n = int(input("请输入要查询的日期数量:"))
    10. for i in range(n):
    11. y, m, d = map(int, input("请输入年月日,空格分隔:").split())
    12. judge_week(y, m, d)

    通过Python内置的datetime模块,调用其中的date类和strftime方法。date类用于表示日期,接收三个参数:年、月、日。strftime方法用于将日期格式化为字符串,其中"%A"表示输出星期几的全称(比如Monday、Tuesday等)

    函数judge_week中,首先通过datetime.date创建一个日期对象input_date,然后使用input_date.strftime方法将星期几格式化成字符串。如果输入的年月日不合法,则捕获ValueError异常并打印"Illegal"。

    16  41、病人排队

     描述

    病人登记看病,编写一个程序,将登记的病人按照以下原则排出看病的先后顺序:
    1. 老年人(年龄 >= 60岁)比非老年人优先看病。
    2. 老年人按年龄从大到小的顺序看病,年龄相同的按登记的先后顺序排序。
    3. 非老年人按登记的先后顺序看病。

    输入

    第1行,输入一个小于100的正整数,表示病人的个数;
    后面按照病人登记的先后顺序,每行输入一个病人的信息,包括:一个长度小于10的字符串表示病人的ID(每个病人的ID各不相同且只含数字和字母),一个整数表示病人的年龄,中间用单个空格隔开。

    输出

    按排好的看病顺序输出病人的ID,每行一个。

    样例输入

    5
    021075 40
    004003 15
    010158 67
    021033 75
    102012 30

    样例输出

    021033
    010158
    021075
    004003
    102012

    代码:

    1. # 41、病人排队
    2. num = int(input())
    3. lst = []
    4. for i in range(num):
    5. s = input().split()
    6. lst1 = [str(s[0]),int(s[1]),i] #添加登记顺序
    7. lst.append(lst1)
    8. def f(x):
    9. if x[1] >= 60: # 病人的年龄大于等于60岁,则返回一个元组 (-x[1], x[2]
    10. return(-x[1],x[2]) # x[1] 是年龄的相反数,x[2] 是病人的登记顺序(索引 i)
    11. else:
    12. return(0,x[2])
    13. lst.sort(key=f) # #key为自定义比较函数,按函数f的方式比较
    14. # 根据年龄从大到小的顺序和病人的登记顺序
    15. for i in range(num):
    16. print(lst[i][0]) # 使用循环遍历排好序的列表 a,并打印每个病人的ID(a[i][0])

    1. class Patient:
    2. def __init__(self, id, age):
    3. self.id = id
    4. self.age = age
    5. n = int(input("请输入病人的个数:"))
    6. patients = []
    7. for _ in range(n):
    8. patient_info = input("请输入病人的信息(ID 年龄):").split()
    9. id, age = patient_info[0], int(patient_info[1])
    10. patients.append(Patient(id, age))
    11. # 老年人优先,按年龄从大到小,年龄相同按登记顺序
    12. old_patients = [patient for patient in patients if patient.age >= 60]
    13. old_patients.sort(key=lambda x: (-x.age, patients.index(x))) # 从大到小
    14. other_patients = [patient for patient in patients if patient not in old_patients]
    15. sorted_patients = old_patients + other_patients
    16. for patient in sorted_patients:
    17. print(patient.id)

    ### 定义Patient类
    class Patient:
        def __init__(self, id, age):
            self.id = id
            self.age = age
    这里定义了一个Patient类表示病人。该类有两个属性:id表示病人的ID,age表示病人的年龄。__init__方法是类的构造函数,用于创建Patient对象时初始化属性。

    ### 输入病人信息
    n = int(input("请输入病人的个数:"))
    patients = []
    for _ in range(n):
        patient_info = input("请输入病人的信息(ID
        年龄):").split()
        id, age = patient_info[0], int(patient_info[1])
        patients.append(Patient(id, age))
    首先通过input函数获取病人个数n,然后使用for循环逐个输入病人信息,并将每个病人的id和age分别存储在变量id和age中。由于age是从输入中获取的字符串类型,需要使用int函数将其转换为整型。最后通过Patient类创建病人对象,并将其添加到列表patients中。

    ### 按规则排序
    old_patients = [patient for patient in patients if patient.age >= 60]
    old_patients.sort(key=lambda x: (-x.age, patients.index(x)))
    other_patients = [patient for patient in patients if patient not in old_patients]

    sorted_patients = old_patients + other_patients
    先使用列表推导式将老年病人和非老年病人分别提取出来,old_patients存储老年病人,other_patients存储非老年病人。对于老年病人,按照题目描述的规则进行排序,首先按照年龄从大到小排序,年龄相同的按照登记顺序排序。这里使用sort方法,其中key参数是一个函数,用于指定排序规则。这里使用了一个lambda函数表示按照年龄和登记顺序排序。具体实现是将年龄取相反数,这样年龄大的排在前面;如果年龄相同,则按照原始列表中的顺序排列。对于非老年病人,不需要排序,直接按照登记顺序排列。

    最后将排序好的老年病人和非老年病人合并成一个列表,即为排好序的病人列表sorted_patients。

    ### 输出排队顺序
    for patient in sorted_patients:
        print(patient.id)
    使用for循环逐个输出病人ID,完成排队顺序的输出。

    17 42、校园食宿预订系统

     描述

    某校园为方便学生订餐,推出食堂预定系统。食宿平台会在前一天提供菜单,学生在开饭时间前可订餐。 食堂每天会推出m个菜,每个菜有固定的菜价和总份数,售卖份数不能超过总份数。 假设共有n个学生点餐,每个学生固定点3个菜,当点的菜售罄时, 学生就买不到这个菜了。 请根据学生预定记录,给出食堂总的预定收入 数据满足1 <= n <= 6000,3 <= m <= 6000,单品菜价不大于1000元,每个菜的配额不超过3000

    输入

    第一行两个整数n和m,代表有n个学生订餐,共有m个可选的菜
    下面m行,每行三个元素,分别是菜名、售价和可提供量,保证菜名不重合,菜价为整数
    下面n行,每行三个元素,表示这个学生点的三个菜的菜名

    输出

    一个整数,表示食堂的收入

    样例输入

    5 5
    yangroupaomo 13 10
    jituifan 7 5
    luosifen 16 3
    xinlamian 12 20
    juruo_milktea 999 1
    yangroupaomo luosifen juruo_milktea
    luosifen xinlamian jituifan
    yangroupaomo jituifan juruo_milktea
    jituifan xinlamian luosifen
    yangroupaomo yangroupaomo yangroupaomo
    

    样例输出

    1157

    提示

    如果用python做,要用字典,
    如果用其它语言做,也要用类似的数据结构
    否则会超时
    名字长度范围没有给出,长度不会太离谱。请自己选用合适的办法确保这不是个问题

    代码

    1. n, m = map(int,input().split())
    2. t={}
    3. for i in range(m):
    4. s = input().split()
    5. name, price, num =s[0], int(s[1]), int(s[2])
    6. t[name]=[price,num]
    7. total = 0
    8. for i in range(n):
    9. names = input().split()
    10. for name in names:
    11. if t[name][1]>0: # 即num>0
    12. total += t[name][0]
    13. t[name][1] -= 1
    14. print(total)

  • 相关阅读:
    设将n(n>1)个整数存放在一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移P(0<P<n)个位置
    【力扣每日一题】2023.10.11 奖励最顶尖的k名学生
    【uvm】Wait for Interface Signals in UVM
    计算机毕业设计php_thinkphp_vue的约课管理系统-课程预约
    软件运维面试题
    【Android 从入门到出门】第二章:使用声明式UI创建屏幕并探索组合原则
    面向Ai设计的Mojo编程语言支持下载,当前只有Linux系统版本
    Conmi的正确答案——“Cannot read properties of null (reading ‘pickAlgorithm‘)”解决方案
    《JAVA EE》内部类(下篇)&Lambda表达式
    mysql sql_mode 设置
  • 原文地址:https://blog.csdn.net/m0_73809176/article/details/134233137