算法学习记录2

热知识CTRL+F可以在页面进行快速查找😁

L1-028 判断素数

import math

N = int(input())

for _ in range(N):
    num = int(input())
    if num < 2:
        print("No")
        continue

    is_prime = True
    for i in range(2,int(math.sqrt(num)) + 1):
        if num % i == 0:
            is_prime = False
            break

    if is_prime:
        print("Yes")
    else:
        print("No")

L1-030 一帮一

“一帮一学习小组”是中小学中常见的学习组织方式，老师把学习成绩靠前的学生跟学习成绩靠后的学生排在一组。本题就请你编写程序帮助老师自动完成这个分配工作，即在得到全班学生的排名后，在当前尚未分组的学生中，将名次最靠前的学生与名次最靠后的异性学生分为一组。

输入格式：

输入第一行给出正偶数N（≤50），即全班学生的人数。此后N行，按照名次从高到低的顺序给出每个学生的性别（0代表女生，1代表男生）和姓名（不超过8个英文字母的非空字符串），其间以1个空格分隔。这里保证本班男女比例是1:1，并且没有并列名次。

输出格式：

每行输出一组两个学生的姓名，其间以1个空格分隔。名次高的学生在前，名次低的学生在后。小组的输出顺序按照前面学生的名次从高到低排列。

输入样例：

8
0 Amy
1 Tom
1 Bill
0 Cindy
0 Maya
1 John
1 Jack
0 Linda

输出样例：

Amy Jack
Tom Linda
Bill Maya
Cindy John

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

def pair_students(n, student_info):
    # 标记已配对的学生
    paired = [False] * n

    for i in range(n):
        for j in range(n - 1, i, -1):
            # 如果找到一对异性且未被配对过的学生，输出并标记为已配对
            if student_info[i][0] != student_info[j][0] and not paired[i] and not paired[j]:
                print(student_info[i][1], student_info[j][1])
                paired[i] = True
                paired[j] = True
                break

# 读取学生人数
n = int(input("请输入学生总数: "))

# 读取学生信息
student_info = []
for _ in range(n):
    gender, name = input("请输入学生性别(0代表女生, 1代表男生)和姓名，用空格分隔: ").split()
    student_info.append((int(gender), name))

# 调用函数进行配对
pair_students(n, student_info)

 

L1-031 到底是不是太胖了

lines = []
N = int(input())
for i in  range(N):
    line = input()
    lines.append(line)

for line in lines:
    H,W = map(int,line.split())
    standard_weight = (H - 100) * 0.9 * 2
    diff = abs(W - standard_weight)
    if diff < standard_weight * 0.1:
        print("You are wan mei!")
    elif W > standard_weight:
        print("You are tai pang le!")
    else:
        print("You are tai shou le!")

 

L1-032 Left-pad

 

n=input().split()
s=input()
if int(n[0])>len(s):
    print(s.rjust(int(n[0]),n[1]))
else:
    print(s[len(s)-int(n[0]):])

L1-033 出生年

def find_unique_year(burn_year, num):
    year = int(burn_year)
    while True:
        year_str = str(year).zfill(4)  # 确保年份是4位数
        if len(set(year_str)) == num:  # 检查不同数字的个数是否符合条件
            #set(str(year)): set是一个集合类型，它会自动移除重复的元素。
            # 当我们将字符串转换成集合时，它会保留所有唯一的字符。
            # 继续上面的例子，set("1988")将会是{'1', '9', '8'}，
            # 这里’8’只出现一次，即使在原始字符串中它出现了两次。
            return year - int(burn_year), year_str  # 返回经过的年数和符合条件的年份
        year += 1

# 输入出生年份和目标年份中不同数字的个数
input_year, num = input().split()
num = int(num)

# 计算结果
years_passed, unique_year = find_unique_year(input_year, num)

# 输出结果
print(years_passed, unique_year)

L1-034 点赞

# 创建一个字典，用于统计每个特性标签出现的次数
tag_counts = {}

# 读取博文数量 N
N = int(input())

# 循环 N 次，读取每篇博文的特性标签
for _ in range(N):
    tags = list(map(int, input().split()))[1:]  # 读取特性标签列表
    for tag in tags:
        tag_counts[tag] = tag_counts.get(tag, 0) + 1  # 统计特性标签出现次数

# 找到出现次数最多的特性标签
max_count = max(tag_counts.values())
max_tags = [tag for tag, count in tag_counts.items() if count == max_count]
max_tag = max(max_tags)

# 输出结果
print(max_tag, max_count)

L1-035 情人节

liked_names = []
while True:
    name = input()
    if name == '.':
        break
    liked_names.append(name)

if len(liked_names) >= 2:
    second_person = liked_names[1]
else:
    second_person = None

if  len(liked_names) >= 14:
    fourteenth_person = liked_names[13]
else:
    fourteenth_person = None

if second_person and fourteenth_person:
    print(f"{second_person} and {fourteenth_person} are inviting you to dinner...")
elif second_person:
    print(f"{second_person} is the only one for you...")
else:
    print("Momo... No one is for you...")

L1-037 A除以B

A, B = map(int,input().split())
if B > 0:
    c = A / B
    print('{}/{}={:.2f}'.format(A,B,c))
if B < 0:
    c = A / B
    print('{}/({})={:.2f}'.format(A, B, c))
if B == 0:
    print('{}/{}=Error'.format(A, B))

 

L1-039 古风排版

中国的古人写文字，是从右向左竖向排版的。本题就请你编写程序，把一段文字按古风排版。

输入格式：

输入在第一行给出一个正整数N（<100），是每一列的字符数。第二行给出一个长度不超过1000的非空字符串，以回车结束。

输出格式：

按古风格式排版给定的字符串，每列N个字符（除了最后一列可能不足N个）。

输入样例：

4
This is a test case

输出样例：

asa T
st ih
e tsi
 ce s

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

n = int(input())
s = input().rstrip()
# 假设输入的字符串没有换行符并且不是n的倍数或长度

# 检查输入的字符串长度是否是 n 的倍数，
# 如果不是，则在字符串后面添加空格，直到长度成为 n 的倍数。

while len(s) % n != 0:
    s += " "
sz = len(s)
m = sz // n
# 将输入的字符串按照规定进行分组，每组有 n 个字符。
# 分组的方法是以列为单位，依次将字符串的每个字符放入对应的组中。
# 这里用了一个二维列表 g 来存储分组结果。

g = [[] for _ in range(n)]

for i in range(n):  # 控制列数
    for j in range(i, sz, n):  # 控制每列中的字符，i控制当前处理的列号
        # 生成一个从i开始，步长为n的等差数列，即列号为i，i+n，i+2n的字符下标
        g[i].append(s[j])
        # 取出s 字符串中对应下标 j 的字符，然后将其添加到二维列表 g[i] 的末尾，实现了按列分组的效果。

# 按照每列N个字符的方式输出排版后的结果。
# 外层循环 for i in range(n) 控制列数，
# 内层循环 for j in range(m - 1, -1, -1) 控制输出每列字符的顺序。
for i in range(n):
    for j in range(m - 1, -1, -1):
        print(g[i][j], end="")
    print()
# i 控制当前处理的列号。
# range(m - 1, -1, -1) 生成一个从 m - 1 开始，递减到 -1（不包括 -1）的等差数列，即从最后一行到第一行的顺序。
# print(g[i][j], end="") 就是输出 g[i][j] 这个位置上的字符，end="" 是为了防止自动换行，实现一行输出多个字符。
# 最后一个 print() 是为了换行，表示当前列的字符已经输出完毕，需要换到下一行输出。
# 逆序输出每一列。即先输出最后一列，然后倒数第二列，以此类推，直到第一列。

L1-041 寻找250

input_numbers = input().split()
numbers = [ int(num) for num in input_numbers]
for index,value in enumerate(numbers,start = 1):
    if value == 250:
        print(index)
        break

 

L1-042 日期格式化

date = input().split('-')
month, day, year = date
print(f"{year}-{month}-{day}")

L1-043 阅览室

days = int(input())

for _ in range(days):
    records = {}
    while True:
        line = input().strip().split()
        if line[0] == '0':
            break

        book_id,key,time = int(line[0]),line[1],line[2]
        if key == 'S':
            records[book_id] = [time,None]
        elif key == 'E' and book_id in records:
            start_time = records[book_id][0]
            end_time = time
            duration = (int(end_time[:2]) - int(start_time[:2])) * 60 + int(end_time[3:]) - int(start_time[3:])
            records[book_id][1] = duration

    tottal_books = 0
    tottal_duration = 0
    for book_id,record in records.items():
        if record[1] is not None:
            tottal_books += 1
            tottal_duration += record[1]

    if tottal_books > 0:
        average_duration = round(tottal_duration / tottal_books)
    else:
        average_duration = 0

    print(tottal_books,average_duration)

L1-044 稳赢 

# 读取K的值
K = int(input())

# 初始化计数器
counter = 0

# 定义赢招的映射
winning_moves = {
    "ChuiZi": "Bu",
    "JianDao": "ChuiZi",
    "Bu": "JianDao"
}

# 循环读取对方的出招
while True:
    move = input()
    if move == "End":
        break  # 结束输入

    if counter == K:
        # 如果计数器达到K，输出平局的招式，并重置计数器
        print(move)
        counter = 0
    else:
        # 输出赢的招式，并递增计数器
        print(winning_moves[move])
        counter += 1

L1-046 整除光棍

def find_min_stick_number(x):
    #初始化光棍数字为1和位数计数器
    stick_number = 1
    n = 1

    #循环直达光棍数字能被x整除
    while stick_number % x != 0:
        #增加光棍数字的位数
        stick_number = stick_number * 10 + 1
        n += 1

    s = stick_number // x
    return s,n

x = int(input())

if x % 2 == 0 or x % 10 == 5:
    exit()
else:
    s, n = find_min_stick_number(x)
    print(s,n)

L1-048 矩阵A乘以B

row_A, cols_A = map(int,input().split())
matrixA = [list(map(int,input().split())) for _ in range(row_A)]

row_B, cols_B = map(int,input().split())
matrixB = [list(map(int,input().split())) for _ in range(row_B)]

if cols_A != row_B:
    print(f"Error: {cols_A} != {row_B}")
    exit()
else:
    result = [[0 for _ in range(cols_B)] for _ in range(row_A)]

    for i in range(row_A):
        for j in range(cols_B):
            for k in range(cols_A):
                result[i][j] += matrixA[i][k] * matrixB[k][j]
    print(f"{row_A} {cols_B}")
    for row in result:
        print(''.join(map(str, row)))

L1-049 天梯赛座位分配

num = [0] * 111  # 记录每个学校的队伍数量
pos = [[[0]*11 for _ in range(11)] for _ in range(111)]  # i学校j队伍中k队员的位置
maxx, pre = 0, 0  # maxx记录学校中队伍数量的最大值，pre记录上一个被编号的学校
x = 0  # 记录编号

n = int(input())  # 学校数量
input_str = input().split()  # 输入每个学校的队伍数量并用空格分隔
for i in range(1, n+1):
    num[i] = int(input_str[i-1])  # 每个学校的队伍数量
    maxx = max(maxx, num[i])  # 记录最大队伍数量

for j in range(1, maxx+1):  # 以最大队伍数量为上界，为了让每个人都能在这个循环里添加上位置
    for k in range(1, 11):  # 循环每个队员
        for i in range(1, n+1):  # 遍历学校开始编号
            if j <= num[i]:  # 如果当前的队伍数量j小于等于当前学校的队伍数量，说明可以编号
                if pre == i:  # 相邻学校的两个队员必须隔位就坐
                    x += 2
                else:
                    x += 1  # 不是同一个学校的，连续编排
                pos[i][j][k] = x  # 特别有意思的循环，i学校j队伍中k队员的编号就是x
                pre = i  # 记录上一个被编号的学校

for i in range(1, n+1):
    print(f"#{i}")
    for j in range(1, num[i]+1):
        for k in range(1, 11):
            if k <= 9:
                print(pos[i][j][k], end=" ")
            else:
                print(pos[i][j][k])

 

L1-050 倒数第N个字符串

def find_string(L, N):
    # 计算总共有多少个字符串
    total_strings = 26 ** L

    # 计算正数第N个字符串
    number = total_strings - N
    string = ""

    # 将数字转换为26进制表示的字符串
    for _ in range(L):
        number, remainder = divmod(number, 26)
        string = chr(remainder + ord('a')) + string
        #`ord` 是 Python 中的一个内置函数，
        # 它用来返回某个字符（一个字符串）的 ASCII 码值。
        # ASCII 码是一个字符编码标准，用于表示文本在计算机中的表示方式。

    # 如果结果长度小于L，说明前面有零(即’a‘)，需要补全
    string = 'a' * (L - len(string)) + string

    return string

# 示例输入
L, N = map(int, input().split())
# 输出结果
print(find_string(L, N))

L1-051 打折

origin_price,discount = input().split()
origin_price = int(origin_price)
discount = int(discount)
final_price = (origin_price * (discount / 10))
print(f'{final_price:.2f}')
#f'{value:.2f}'，来保留两位小数

L1-053 电子汪

A, B = input().split()
sum_of_A_and_B = int(A) + int(B)
for _ in range(sum_of_A_and_B):
    print('Wang!',end='')
    # 打印"Wang!"，并指定结束符为空字符串，这样就不会有换行

L1-054 福到了

word, num = input().split()  # 读取输入的字符和数字，分割成两部分。
num = int(num)  # 将数字部分转换为整数。

grid = []  # 创建一个空列表，用于存储网格的每一行。

# 下面的循环读取接下来的 num 行输入。
for _ in range(num):
    line = list(input())  # 将每行输入转换为列表。
    grid.append(line)  # 将这个列表添加到网格列表中。

# 检查网格是否需要倒置。如果网格的上半部分和下半部分不相同，则需要倒置。
need_reverse = any(grid[i] != grid[num - i - 1] for i in range(num // 2))

# 如果需要倒置...
if need_reverse:
    reversed_grid = [row[::-1] for row in grid[::-1]]  # 倒置网格的每一行，然后整个网格倒置。
    for row in reversed_grid:  # 遍历倒置后的网格。
        print(''.join(row).replace('@',word))  # 将每行的 '@' 替换为输入的字符，并输出。

# 如果不需要倒置...
else:
    print('bu yong dao le')  # 输出 "bu yong dao le"。
    for row in grid:  # 遍历原网格。
        print(''.join(row).replace('@',word))  # 将每行的 '@' 替换为输入的字符，并输出。

L1-055 谁是赢家

Pa, Pb = map(int,input().split())
vote_one, vote_two, vote_three = map(int,(input().split()))
total_votes = vote_one + vote_two + vote_three
final_votes = 3 - total_votes
if Pa > Pb and final_votes >= 1 or Pa < Pb and final_votes == 3:
    print("The winner is a: {} + {}".format(Pa,final_votes))
else:
    print("The winner is b: {} + {}".format(Pb,total_votes))

L1-056 猜数字

N = int(input().strip())
players = []
total_sum = 0

for _ in range(N):
    name,number = input().strip().split()#这行代码用于读取一行文本，去除空白字符，并按空格分割为名字和数字。
    number = int(number)
    players.append((name,number))
    total_sum += number

average_half = total_sum / (2 * N)
average_half_int = int(average_half)

winner = None
min_diff = float('inf')#将min_diff初始化为正无穷大，用于后面找到最小的差值。

for player,number in players:
    diff = abs(number - average_half_int)
    if diff < min_diff:
        min_diff = diff
        winner = player

print(average_half_int,winner,sep=' ')

L1-058 6翻了

import re
#正则表达式
def replace_sixes(sentence):
    # 替换超过9个连续的6为'27'
    sentence = re.sub(r'6{10,}', '27', sentence)
    # 替换超过3个连续的6为'9'
    sentence = re.sub(r'6{4,9}', '9', sentence)
    return sentence

# 输入
input_sentence = input()
# 输出
output_sentence = replace_sixes(input_sentence)
print(output_sentence)

L1-059 敲笨钟

n=int(input())
for _ in range(n):
    ls=list(input().split(','))
    ls1=list(ls[0].split())
    ls2=list(ls[1].split())
    if 'ong' in ls1[-1] and 'ong' in ls2[-1]:
        ls2[-1] = 'zhong.'
        ls2[-2] = 'ben'
        ls2[-3] = 'qiao'
        print(' '.join(ls1)+', '+' '.join(ls2))
    else:
        print('Skipped')

L1-062 幸运彩票

def is_lucky(ticket_number):
    # 将彩票号码分为前三位和后三位
    front = ticket_number[:3]
    back = ticket_number[3:]

    # 计算前三位和后三位的数字和
    front_sum = sum(int(digit) for digit in front)
    back_sum = sum(int(digit) for digit in back)

    # 比较和是否相等
    return front_sum == back_sum


# 读取彩票数量
N = int(input())

# 读取并判断每张彩票
for _ in range(N):
    ticket_number = input()
    if is_lucky(ticket_number):
        print("You are lucky!")
    else:
        print("Wish you good luck.")

L1-063 吃鱼还是吃肉

N = int(input())

for _ in range(N):
    gender, height, weight = input().split()
    gender = int(gender)
    height = int(height)
    weight = int(weight)

    advice = ""

    if gender == 1:
        if height > 130:
            advice += "ni li hai!"
        elif height < 130:
            advice += "duo chi yu!"

    else:
        if height > 129:
            advice += "ni li hai!"
        elif height < 129:
            advice += "duo chi yu!"

    if weight > 27:
        advice += "shao chi rou!"
    elif weight < 25:  # 正确的条件应该是 weight < 25
        advice += "duo chi rou!"
    else:
        advice += "wan mei!"

    print(advice)

L1-068 调和平均

n = int(input())
numbers = list(map(float,input().split()))
aver_num = n / sum([1 / num for num in numbers])
print("{:.2f}".format(aver_num))

#map() 会根据提供的函数对指定序列做映射。
#第一个参数 function 以参数序列中的每一个元素调用 function 函数，
# 返回包含每次 function 函数返回值的新列表。
#map(function, iterable, ...)

L1-069 胎压监测

lis = list(map(int,input().split()))
flag = -1
count = 0
for i in range(4):
    if lis[i]<lis[4] or abs(lis[i]-max(lis[:4]))>lis[5]:    # 轮胎的压力值与它们中的最大值误差不在一个给定阈值内，或者低于系统设定的最低报警胎压
        flag = i    # 若只有一个需检测 记住轮胎位置的下标
        count += 1  # 需检测轮胎的计数
if count == 0:      # 都是合适的
    print("Normal")
elif count == 1:     # 一个需检测
    print("Warning: please check #{}!".format(flag+1))
else:                # 两个或两个以上需检测
    print("Warning: please check all the tires!")

L1-070 吃火锅

lines = []
element = "chi1 huo3 guo1"
keyword_count = 0
first_appearance_index = -1

while True:
    line = input().rstrip('\n')#去除字符串末尾的指定字符，此处指换行符'\n'
    #.rstrip('\n')方法的作用就是帮助我们清理输入行中的换行符，以便后续处理。
    if line == '.':
        break
    elif line != '.':
        lines.append(line)
        if element in line.lower():
            keyword_count += 1
            if first_appearance_index == -1:#条件判断检查是否第一次发现了关键词
                first_appearance_index = len(lines)
#如果在遍历过程中发现了关键词，并且index仍然为-1，就说明是第一次发现关键词，此时需要更新apperance
num_of_lines = len(lines)

if first_appearance_index != -1:
    print(num_of_lines)
    print(f"{first_appearance_index} {keyword_count}")
else:
    print(num_of_lines)
    print("-_-#")

L1-071 前世档案

def main():
    n, m = map(int, input().split())
    num = (2 ** n) - 1  # 问题结点的树是一颗满二叉树，总结点数为2^n - 1

    for _ in range(m):
        k = 1  # 初始值1，即为根节点开始
        answers = input().strip()

        for ch in answers:
            if ch == 'y':
                k = 2 * k  # 当输入y时，遍历到左孩子结点(2*k)
            else:
                k = 2 * k + 1  # 当输入n时，遍历到右孩子结点(2*k + 1)

        # 当输入结束后，也就遍历到了最后一层结点(即结论的结点)
        #当回答问题并沿着树向下移动时，我们最终会到达最后一层的某个节点。
        #这个节点的编号是给予我们从根节点开始的路径
        #但是，我们想要的是这个节点在最后一层中的编号，而不是整个树中的编号
        #为了得到这个编号，我们需要从节点的总编号总减去除了最后一层之外的所有结点的数量
        print(k - num)  # 最后一层的任意孩子编号k - 问题结点树的总结点数num = 结论编号

if __name__ == "__main__":
    main()

L1-072 刮刮彩票

dc = {6:10000,7:36,8:720,9:360,
      10:80,11:252,12:108,
      13:72,14:54,15:180,16:72,
      17:180,18:119,19:36,20:306,
      21:1080,22:144,23:1800,24:3600}
arr = [[] for i in range(3)]
for i in range(3):
    arr[i] = list(map(int,input().split()))
for i in range(3):
    x,y = map(int,input().split())
    temp = arr[x-1][y-1]
    print(temp)
brr = (1,2,3,4,5,6,7,8,9)
x = 0
for i in range(3):
    x += sum(arr[i])
x = sum(brr) - x #记录差值
for i in range(3):
    for j in range(3):
        if arr[i][j] == 0:
            arr[i][j] = x
            break
        else:
            continue
total = 0
m = int(input())
if m == 1:
    total += sum(arr[0])
elif m == 2:
    total + sum(arr[1])
elif m == 3:
    total + sum(arr[2])
elif m == 4:
    for i in range(3):
        total += arr[i][0]
elif m == 5:
    for i in range(3):
        total += arr[i][1]
elif m == 6:
    for i in range(3):
        total += arr[i][2]
elif m == 7:
    for i in range(3):
        total += arr[i][i]
elif m == 8:
    total += arr[2][0]+arr[1][1]+arr[0][2]
print(dc[total])

L1-075 强迫症

def format_birthdate(birthdate):
    # 判断输入是4位还是6位
    if len(birthdate) == 4:
        # 如果是4位，先拆分年份后两位和月份
        year_suffix = birthdate[:2]
        month = birthdate[2:]
        # 判断是19还是20开头
        if int(year_suffix) < 22:
            year_prefix = '20'
        else:
            year_prefix = '19'
        year = year_prefix + year_suffix
        # 格式化输出，确保月份是两位数
        return f"{year}-{month.zfill(2)}"
    elif len(birthdate) == 6:
        # 如果是6位，直接拆分年份和月份
        year = birthdate[:4]
        month = birthdate[4:]
        # 格式化输出，确保月份是两位数
        return f"{year}-{month.zfill(2)}"
    else:
        # 输入不合法
        return "Invalid input"

    # 读取输入


input_birthdate = input()

# 调用函数并打印结果
output_birthdate = format_birthdate(input_birthdate)
print(output_birthdate)

L1-076 降价提醒机器人

price_record, ideal_price = input().split()
price_record = int(price_record)
ideal_price_float = float(ideal_price)

for _ in range(price_record):
    price = float(input())

    if price < ideal_price_float:
        print("On Sale! {:.1f}".format(price))
#print函数的默认行为，每次输出后都会有一个换行
#print("On Sale! {:.1f}".format(price), end=' ')  # 末尾使用空格而不是换行符

#法二，pta未试
def sale_alert(price_records, target_price):
    for price in price_records:
        if price < target_price:
            print(f"On Sale! {price:.1f}")

# 输入样例
N, M = map(int, input().split())
price_records = [float(input()) for _ in range(N)]
target_price = float(M)

sale_alert(price_records, target_price)

L1-077 大笨钟的心情