OpenJudge中Python程序设计及实现答案

山川尔尔_

已于 2024-03-23 21:20:51 修改

阅读量1.5k

点赞数 29

文章标签：算法

于 2024-03-15 20:42:42 首次发布

本文链接：https://blog.csdn.net/qq_60618042/article/details/136607091

版权

测验一：

001 字符菱形

002 字符三角形

003 输出第二个整数

004求三个数的和

005 判断子串

使用 ”in“ ”not in"判断子串

006 计算(a+b)*c的值

# 006
lst = input().split()
a,b,c = int(lst[0]),int(lst[1]),int(lst[2])
res = (a+b)*c
print(res)

007 反向输出一个三位数

# 007
number = int(input())
reversed_number = str(number)[::-1]   #int(str(number)[::-1])
print(reversed_number)

[::-1] 用来逆向截取字符

008字符串交换

max_length = 4
str1 = list(str(input()))
str1 = str1[:max_length]
str2 = list(str(input()))
str2 = str2[:max_length]
l1 = str2[0] + str2[1] + str1[2] + str1[3]
l2 = str1[0] + str1[1] + str2[2] + str2[3]
print(l1)
print(l2)

009字符串中的整数求和

这个是可以通过的版本

s=input().split()
a=int(s[0][0]+s[0][1])
b=int(s[1][0]+s[1][1])
print(a+b)

注意避免这样子的写法

会出现RuntimeError

max_length = 3
str1 = list(str(input()))
str1 = str1[:max_length]
str2 = list(str(input()))
str2 = str2[:max_length]

num1 = int(str1[0] + str1[1])
num2 = int(str2[0] + str2[1])
print(num1+num2)

测验二：

010 计算2的幂

011 计算多项式的值

012 奇偶数判断

013 点和正方形的关系

014 三角形判断

015 计算邮资

weight, speed = list(input().split())
print(weight, speed)
weight = int(weight)

if weight <= 1000:
    price = 8
elif weight % 500 == 0:
    extra = (weight - 1000) // 500 * 4
    price = 8 + extra
else:
    extra = (weight - 1000) // 500 * 4 + 4
    price = 8 + extra


if speed == "n":
    price = price
else:
    price = price + 5
print(price)

016 分段函数

x = float(input())
if 0 <= x < 5:
    y = -x + 2.5
elif 5 <= x < 10:
    y = 2 - 1.5 * (x - 3) * (x - 3)
elif 10 <= x < 20:
    y = x / 2 - 1.5

y = '{:.3f}'.format(y)  # 保留三位小数
print(y)

017 简单计算器

num1, num2, op = list(input().split())
num1 = int(num1)
num2 = int(num2)
if op == '+':
    res = num1 + num2
elif op == '-':
    res = num1 - num2
elif op == '*':
    res = num1 * num2
elif op == '/':
    if num2 == 0:
        res = 'Divided by zero!'
    else:
        res = num1 // num2
else:
    res = "Invalid operator!"
print(res)

018 大象喝水

Pi = 3.14159
h, r = input().split()
h = int(h)
r = int(r)
water = r * r * Pi * h
res = 20000 // water + 1
res = int(res)
print(res)

019 苹果和虫子2


n, x, y = input().split()

n = int(n)
x = int(x)
y = int(y)

if y % x != 0:
    eaten = int(y // x + 1)
else:
    eaten = int(y // x)

res = n - eaten
if res < 0: # 判断所有苹果吃完的情况
    res = 0
else:
    res = res

print(res)

测试三

*020 A+B Problem （这个不在测验中

a, b = input().split()
a = int(a)
b = int(b)

print(a+b)

021 求整数的和与均值

n = int(input())
total = 0
for i in range(n):
    total += int(input())
average = float(total / n)
average = '{:.5f}'.format(average)
print(total, average)

022 整数序列的元素最大跨度值

n = int(input())
sequence = list(map(int,input().split()))
large = max(sequence)
small = min(sequence)

res = large - small
print(res)

023 奥运奖牌计数

n = int(input())
gold_total = 0
silver_total = 0
bronze_total = 0
for i in range(n):
    gold, silver, bronze = map(int, input().split())
    gold_total += gold
    silver_total += silver
    bronze_total += bronze
total = gold_total + silver_total + bronze_total
print(gold_total, silver_total, bronze_total, total)

024 鸡尾酒疗法

注意判断语句部分
通过数组实现结果在一行输出
通过遍历数组实现结果按照规定格式输出
结果输出检验

n = int(input())
results = []
# 注意第一行为鸡尾酒的数据
total, effective = map(int, input().split())
x = effective / total
for i in range(n-1):  #range(1, n) 也可以 这里是处理剩下的n-1部分的数据
    total, effective = map(int, input().split())
    y = effective / total
    if y - x > 0.05:
        results.append('better')
    elif x - y > 0.05:
        results.append('worse')
    else:
        results.append('same')

# 输出结果
for result in results:
    print(result)

025 角谷猜想

使用while循环

print(f"{n}*3+1={n * 3 + 1}") 格式化输出，但是需要注意顺序

def collatz_conjecture(n):
    while n != 1:
        if n % 2 == 0:

            print(f"{n}/2={n // 2}")
            n = n // 2

        else:

            print(f"{n}*3+1={n * 3 + 1}")
            n = n * 3 + 1
    print("End")


# 输入一个正整数
N = int(input())
collatz_conjecture(N)

026 正常血压

注意使用一个变量记录当前的连续正常血压的小时数
再使用另外一个变量记录历史的最长连续正常小时数

n = int(input())
hour = 0
max_hour = 0
for i in range(n):
    shrink, diastolic = map(int, input().split())
    # print(shrink, diastolic)
    if 140 >= shrink >= 90 >= diastolic >= 60:

        hour += 1
        max_hour = max(max_hour, hour)
        # print('这里面的 ',hour)
    else:
        hour = 0
        # print('我在else', hour)
# print('最后的',hour)

print(max_hour)

027 数字反转

对一个整数进行反转，首先考虑符号：通过判断输入的n的值来确定反转后的符号sign 是否为负-
把整数部分转换为字符串进行反转操作
字符串的反转[::-1] 注意会出现 990 反转之后为 099 的情况
最后需要转化为 int 类型反转之后最高位的0就会去掉符合要求

num = int(input())  # int(input())
sign = 1 if num >= 0 else -1
num_reversed = int(str(abs(num))[::-1]) * sign
# print(num)
print(num_reversed)
# print(type(num_reversed))

028 求特殊自然数

Python进制转换详细介绍_进制转换python-CSDN博客

使用内置的函数divmod()

七进制转换
九进制转换
比较判断，符合条件则进行输出
注意！！注意避免出现 string类型和int类型判断是否相等的情况
在条件判断处很容易因为这个问题尽管判断逻辑是正确的但是最后找不到结果

def decimal_to_base_n(number, base):
    if number == 0:
        return '0'

    digits = []
    while number > 0:
        number, remainder = divmod(number, base)
        digits.insert(0, str(remainder))

    return ''.join(digits)

# 七进制100 对应十进制49
# 九进制100 对应十进制81

for num in range(81, 342):
    # print(num)# print('七进制', num_7)
    num_7 = decimal_to_base_n(num, 7)
    reverse_num7 = int(str(num_7)[::-1])

    num_9 = decimal_to_base_n(num, 9)
    if len(str(num_7)) == 3 and len(str(num_9)) == 3 and int(num_9) == reverse_num7:
        print(num)
        print(num_7)
        print(num_9)

进制转换函数

# number 为十进制自然数   base 为转换成为的进制数
def decimal_to_base_n(number, base):
    if number == 0:
        return '0'

    digits = []
    while number > 0:
        number, remainder = divmod(number, base)
        digits.insert(0, str(remainder))

    return ''.join(digits)

029 数字统计

思路是把输入范围中的数字进行遍历存储在列表list中再转化为字符串调用count()方法，计算2的出现次数
注意

append() 方法是 Python 列表对象的一个方法，用于向列表的末尾添加一个新元素。这个方法会修改原始列表，并将新元素添加到列表的末尾，但它不会返回任何值。这是因为它直接修改了列表对象本身，而不需要返回其他信息。

如果 append() 方法返回了添加的元素，那么每次调用该方法都会返回一个新列表，并且原始列表将被改变。这样会导致不必要的内存分配和数据复制，降低程序的效率。因此，Python 中的 append() 方法被设计成没有返回值，只修改原列表。

L, R = map(int, input().split())
arr = []
for num in range(L, R+1):
    arr.append(str(num))  # 将每个整数转换为字符串并添加到列表中

    # 将列表转化为字符串
    s = ''.join(arr)
    # s = str(arr.append(num))
    # print(s)
print(s.count('2'))

030 求最大公约数问题

辗转相除法，也称为欧几里德算法，是求两个数的最大公约数的一种常用方法。其实现步骤如下：

如果 b 等于 0，则 a 即为所求的最大公约数，算法结束。
否则，计算 a 除以 b 的余数，即 a % b，并将结果赋给 a，同时将 b 的值赋给 a，即 a = b，b = a % b。
重复步骤 1 和步骤 2，直到 b 等于 0。

x, y = map(int, input().split())

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

res = gcd(x, y)
print(res)

031 多少种取法

递归大法！！
找准边界

def ways(m, n, s):
    # 边界条件
    if m < n:
        return 0
    elif m == 0:
        return 0 if n != 0 or s != 0 else 1
    elif n == 0:
        return 1 if s == 0 else 0
    
    # 递归关系
    if m > s:
        return ways(s, n, s)
    else:
        return ways(m-1, n-1, s-m) + ways(m-1, n, s)

# 测试样例
t = int(input())  # 输入组数
for _ in range(t):
    m, n, s = map(int, input().split())  # 输入每组数据
    print(ways(m, n, s))  # 输出答案

测验四

032 石头剪刀布

# 单轮胜负判断逻辑修正
def judge(a, b):
    if a == b:
        return 0
    # 根据题目描述，0石头，2剪刀，5布
    # A胜利的条件
    elif (a == 0 and b == 2) or (a == 2 and b == 5) or (a == 5 and b == 0):
        return 1
    else:
        return -1

# 游戏主体逻辑调整
def game(A, B, N):
    win_A = 0
    win_B = 0
    
    for i in range(N):
        res = judge(A[i % NA], B[i % NB])
        if res == 1:
            win_A += 1
        elif res == -1:
            win_B += 1
    
    if win_A > win_B:
        return "A"
    elif win_B > win_A:
        return "B"
    else:
        return "draw"

print(game(A, B, N))

033 统计数字字符个数

在Python中，字符串是可迭代对象，意味着你可以直接在它上面使用循环，比如for循环，来逐一访问它包含的每个字符。当你对字符串使用for char in s:这样的循环时，Python会自动将字符串s视为一个序列，char依次成为序列中的每个元素（即字符串中的每个字符）。

s = str(input())
digit_count = 0  # 初始化计数器

# 遍历字符串中的每个字符
for char in s:
    if char.isdigit():  # 如果字符是数字
        digit_count += 1  # 增加计数器

print(digit_count)

034 大小写字母互换

注意避免出现修改字符串的错误，python中字符串是不可修改的

因此转换之后的字符串需要使用一个新的字符串来保存以及输出

# 034
s = str(input())
s2 = ''
for char in s:
    if char.isupper():
        s2 += char.lower()
    elif char.islower():
        s2 += char.upper()
    else:
        char = char
        s2 += char

print(s2)

035 过滤多余的空格

方法一：常规字符串方法解决

s = str(input())
words = s.split()
s2 = ' '.join(words)
print(s2)

方法二：正则表达式求解

注意import re 否则平台会报编译错误

import re
s = input()
s2 = re.sub(r'\s+', ' ', s)
print(s2)

036 找第一个只出现一次的字符

方法一：常规字符串方法解决

效率会比使用字典要慢，建议使用字典

s = input()
count = 0
num = []
for char in s:
    if s.count(char) == 1:
        num.append(char)
if not num:
    print('no')
else:
    print(num[0])

方法二：使用字典

# 方法二 使用字典

char_count = {}
s = input()
count = 0
# 统计每个字符出现的次数 key: 字符char  valur: 次数 count  遍历之后每到相同的key会对对应的value进行加一
# 如果字符已存在于字典中，get 方法会返回当前的计数，然后加一；
# 如果字符不存在，get 方法返回默认值0，然后加一表示该字符现在出现了一次。
for char in s:
    char_count[char] = char_count.get(char, 0) + 1

# 表示遍历字符串 s 中的每个字符，选取出现次数为 1 的字符，并将其存储在列表 target中
target = [char for char in s if char_count[char] == 1]

if target:
    print(target[0])
else:
    print('no')

037 判断字符串是否为回文

1. 使用Python字符串的切片特性

s = input()
# print(s[::-1])
if s == s[::-1]:
    print('yes')
else:
    print('no')

2. 使用双指针

双指针是一种常用于数组和字符串问题的技术，其中两个指针从两端开始向中间移动，并比较指针指向的元素。

# 2.双指针
s = input()
left, right = 0, len(s) - 1
is_palindrome = True  # 假设字符串是回文

while left < right:
    if s[left] != s[right]:
        is_palindrome = False
        break
    left += 1
    right -= 1

if is_palindrome:
    print('yes')
else:
    print('no')

3. 递归方法

递归方法检查字符串的首尾字符是否相同，并递归检查去除首尾字符后的子字符串

s[0] == s[-1]：这个表达式用于比较字符串的首尾字符是否相等。s[0] 表示字符串的第一个字符，s[-1] 表示字符串的最后一个字符。如果首尾字符相等，那么这一部分的结果为 True，否则为 False。

is_palindrome(s[1:-1])：这部分是递归调用自身，用于检查去除首尾字符后的子串是否为回文。s[1:-1] 表示去除了字符串的首尾字符之后的子串。这里使用切片操作 s[1:-1] 来获取子串，从索引1开始到倒数第二个字符为止。然后将这个子串作为参数传递给 is_palindrome 函数，继续递归调用。递归调用的目的是不断地缩小字符串的范围，直到字符串的长度为0或1时停止递归。

and 运算符：and 运算符表示逻辑与操作，用于连接两个条件。在这里，它用于同时检查当前字符是否相等以及去除首尾字符后的子串是否为回文。只有当两个条件都为 True 时，才会返回 True。


# 3.递归
s = input()
def is_pailndrome(s:str) -> bool:
    if len(s) <= 1:
        return True
    return s[0] == s[-1] and is_pailndrome(s[1:-1])

if is_pailndrome(s):
    print('yes')
else:
    print('no')

038 字符串最大跨距

# 038
# 最大间隔距离：最右边的S2的起始点与最左边的S1的终止点之间的字符数目
S, S1, S2 = map(str, input().split(','))
len1 = len(S1)
len2 = len(S2)
lenS = len(S)
max_distance = -1
if S1 in S and S2 in S:
    # 使用两个列表 positions1 和 positions2 分别存储 S1 和 S2 在字符串 S 中出现的所有位置
    position1 = [i for i in range(lenS) if S[i:i+len1] == S1]
    position2 = [i for i in range(lenS) if S[i:i+len2] == S2]
    # print(position1, position2)

    # 如果循环中的变量名pos1与列表名相同，则会导致变量覆盖了列表 使得在第二次循环时，变量无法再次使用
    for pos1 in position1:
        for pos2 in position2:
            if pos1 < pos2:
                distance = pos2 - (pos1 + len1)
                max_distance = max(max_distance, distance)

    if max_distance != -1:
        print(max_distance)
    else:
        print('-1')
else:
    print('-1')

039 找出全部子串位置

这个通过会显示答案错误QAQ

# 039
n = int(input())
for i in range(n):
    s1, s2 = map(str, input().split())
    position = []  #用于存储所有出现的位置
    for j in range(len(s1)):
        if s1[j:].startswith(s2): # 检查 s1 从位置 j 开始的子串是否以 s2 开头  //以这种方式来找到不同的位置
            position.append(str(j))
    if position:
        print(' '.join(position))

    else:
        print('no')

参考的通过对代码

n = int(input())
for i in range(n):
    s = input().split()
    m = 0
    total = 0
    for j in s[0]:
        a = s[0].find(s[1], m)
        if a == -1:
            if total == 0:
                print('no', end='')
            break
        else:
            total += 1
            m = a + len(s[1])
            print(a, "", end='')
    print("")

040 万年历

041 成绩排序

def sort(student):
    return (-student[1], student[0])


n = int(input())
students = []
for i in range(n):
    name, score = input().split()
    students.append((name, int(score)))

sorted_students = sorted(students, key=sort)

for student in sorted_students:
    print(student[0], student[1])

sort方法定义了自定义排序规则：

student 参数是一个学生信息的元组，包含学生的名字和分数。
return (-student[1], student[0]) 指定了排序的规则，首先按照分数降序排列（负号表示降序），如果分数相同，则按照名字的字典序升序排列。

042 图像模糊处理

043 向量点积计算

044 病人排队

045 矩阵乘法

046 回文子串

047 校园食宿预订系统

048 找出所有整数

049 找出所有整数和小数

050 找出小于100的整数

051 密码判断

052 寻找h3

053 找<>中的数

054 电话号码

055 时间处理

山川尔尔_

关注

29
点赞
踩
39

收藏

觉得还不错? 一键收藏
0
评论
OpenJudge中Python程序设计及实现答案

print(f"{n}*3+1={n * 3 + 1}") 格式化输出，但是需要注意顺序。，也称为欧几里德算法，是求两个数的最大公约数的一种常用方法。注意避免出现 string类型和int类型判断是否相等的情况。在条件判断处很容易因为这个问题尽管判断逻辑是正确的但是最后找不到结果。使用 ”in“ ”not in"判断子串。会出现RuntimeError。这个是可以通过的版本。注意避免这样子的写法。
复制链接

扫一扫