一、实操题
1、出租车费用
时间限制：1s
内存限制：128mb
（注：input()括号中不允许添加任何提示语）
根据乘坐出租车的里程，计算应该支付的费用。
出租车根据行驶里程阶梯式计价，具体规则如下表：
请补全下面程序，使程序实现如下功能：
（1）程序开始运行后，输入一个正整数，表示乘坐出租车的里程数；
（2）根据规则计算并输出乘坐出租车应该支付的费用，结果保留一位小数。
d = int(input())
if __________:
cost = d * 2
__________
cost = __________
else:
cost = __________
print('%.1f' % cost)
参考答案：```pythond = int(input())if d <= 3:cost = d * 2elif d <= 10:cost = 6 + (d - 3) * 1.5else:cost = 14.5 + (d - 10) * 2print('%.1f' % cost)```
解析：【喵呜刷题小喵解析】：
根据题目要求，我们需要根据行驶的里程数来计算出租车费用。根据题目给出的规则，行驶里程数分为三个区间，每个区间有不同的计价方式。
首先，我们需要判断里程数d是否小于等于3，如果是，则费用为d * 2。
其次，如果里程数d大于3且小于等于10，则费用为6 + (d - 3) * 1.5，即基础费用6元加上超过3公里的部分每公里1.5元。
最后，如果里程数d大于10，则费用为14.5 + (d - 10) * 2，即基础费用14.5元加上超过10公里的部分每公里2元。
根据以上规则，我们可以补全程序，实现题目要求的功能。
2、和的结果数
时间限制：1s
内存限制：128mb
（注：input()括号中不允许添加任何提示语）
请补全下面程序，使程序实现如下功能：
（1）输入n（2≤n≤100）个整数，整数之间以空格隔开，并保证n个数各不相同；
（2）从这n个数中任选两个，计算并输出任意两个数的和共有多少种不同结果。
例如：
输入一组整数1 3 4 6，任意两数和可能为4（1+3）、5（1+4）、7（1+6 或 3+4）、9（3+6）、10（4+6），因此，输出结果应为5。
ls = [int(i) for i in input().split()]
results = []
for i in range(_______):
for j in range(_______):
s = ls[i] + ls[j]
if s not in results:
_____________
print(len(results))
参考答案：```pythonls = [int(i) for i in input().split()]results = set()for i in range(len(ls)):for j in range(i+1, len(ls)):s = ls[i] + ls[j]results.add(s)print(len(results))```
解析：【喵呜刷题小喵解析】：
首先，我们需要补全代码以实现题目的要求。题目中给出了一个不完整的代码段，需要补充完整以实现题目的功能。
在给出的代码中，我们首先需要读入n个整数，并且确保n个数各不相同。题目中已经给出读入的方式，所以这部分不需要修改。
然后，我们需要从n个数中任选两个，计算并输出任意两个数的和共有多少种不同结果。这部分的代码可以通过两层循环实现，外层循环遍历每个数，内层循环遍历从当前数之后的每个数，然后计算它们的和，并将结果添加到结果集中。
由于题目要求输出不同结果的数量，所以我们需要将结果集转化为集合类型，这样可以直接使用len函数计算集合中元素的数量。
最后，我们输出集合中元素的数量即可。
根据上述分析，我们补全代码，并使用集合类型来存储结果。注意在内层循环中，j应该从i+1开始遍历，这样可以避免重复计算相同的和。
3、因数和个数
时间限制：1s
内存限制：128mb
（注：input()括号中不允许添加任何提示语）
把一个数的因数全加在一起，叫做这个数的因数和。例如，6的因数有1、2、3、6，则它的因数和为1 + 2 + 3 + 6 = 12。
请编写一段程序，输入一个正整数n（n≤1000），判断因数和为n的正整数有多少个，并依次输出这些正整数。
输入描述：
输入一个正整数n（n≤1000）
输出描述：
第一行输出一个正整数，表示因数和为n的正整数的数量，如不存在，则输出0
如果存在，则第二行由小到大输出所有符合条件的数，数字之间以空格隔开
输入样例1：
12
输出样例1：
2 6 11
样例说明1：
因数和为12的正整数有2个，分别是6和11
输入样例2：
10
输出样例2：
0
样例说明2：
因数和为10的正整数不存在，所以仅输出0
参考答案：```pythonn = int(input())count = 0for i in range(1, n+1):s = 0for j in range(1, i+1):if i % j == 0:s += jif s == n:print(i, end=' ')count += 1print(count)```
解析：【喵呜刷题小喵解析】：
本题要求判断因数和为n的正整数有多少个，并依次输出这些正整数。我们可以使用暴力枚举的方法，遍历1到n之间的所有正整数，对于每个正整数，遍历其所有因数，计算其因数和，如果等于n，则输出该正整数，并计数。最后输出计数值即可。
具体实现时，我们可以使用两个嵌套的循环，外层循环遍历1到n之间的所有正整数，内层循环遍历该正整数的所有因数，计算因数和。如果因数和等于n，则输出该正整数，并计数。最后输出计数值即可。
注意，本题中输入样例中的n是用字符串形式输入的，我们需要使用int()函数将其转换为整数形式。另外，输出时需要使用print()函数，并且需要使用end参数指定输出时以空格隔开，否则输出的数字之间会有换行符。
时间复杂度为O(n^2)，其中n为输入的正整数。由于n≤1000，因此时间复杂度可以接受。
4、单词变复数
时间限制：1s
内存限制：128mb
（注：input()括号中不允许添加任何提示语）
英语单词在变成复数形式时，有以下几种常见情况（不完全）：
（1）常规情况下结尾直接加s；
（2）以s、sh、ch、x结尾的单词，加es；
（3）以辅音字母加上y结尾的单词，去掉y加ies；
（注：英文字母中，除了a、e、i、o、u这5个元音字母外，其他都是辅音字母）
请编写一段程序，输入n（1≤n≤1000）个英文单词（单数，仅包含小写字母），并按以上规则变成复数形式。
输入描述：
输入n（1≤n≤1000）个英文单词（单数，仅包含小写字母），单词之间以空格隔开
输出描述：
输出这组单词按以上规则变成的复数形式，单词之间以空格隔开
输入样例：
teacher box butterfly
输出样例：
teachers boxes butterflies
参考答案：根据题目要求，我们需要编写一段程序，输入n（1≤n≤1000）个英文单词（单数，仅包含小写字母），并按题目中给出的规则变成复数形式。首先，我们需要读取输入的单词数量n和n个单词。由于题目中限制了input()括号中不允许添加任何提示语，因此我们需要使用其他方式读取输入。一种可行的方式是使用sys模块的stdin.readline()函数来读取输入。然后，我们需要遍历每个单词，并根据题目中给出的规则将其变成复数形式。具体实现如下：1. 如果单词以s、sh、ch、x结尾，直接在其后加上es；2. 如果单词以辅音字母加上y结尾，去掉y加上ies；3. 否则，直接在单词后加上s。最后，我们将所有复数形式的单词输出到屏幕上，单词之间以空格隔开。
解析：【喵呜刷题小喵解析】：
本题是一道英文单词复数形式的编程题目，需要编写一段程序来将输入的n个英文单词变成复数形式。题目中给出了将单词变成复数形式的规则，包括常规情况下结尾直接加s、以s、sh、ch、x结尾的单词加es、以辅音字母加上y结尾的单词去掉y加ies等。
在编写程序时，需要注意以下几点：
1. 读取输入的方式需要符合题目要求，不能使用input()函数，可以使用sys模块的stdin.readline()函数来读取输入。
2. 遍历每个单词时，需要根据题目中给出的规则将其变成复数形式。
3. 输出结果时，需要将所有复数形式的单词输出到屏幕上，单词之间以空格隔开。
需要注意的是，本题中没有给出单词长度的限制，因此在实际编写程序时，需要对输入的单词长度进行判断，避免越界等问题。另外，题目中也没有给出单词中是否包含空格、标点符号等字符的限制，因此在编写程序时，需要对输入的单词进行合法性判断，避免程序出错。
5、啤酒兑换
时间限制：1s
内存限制：128mb
（注：input()括号中不允许添加任何提示语）
某啤酒品牌正在举办一次促销优惠活动。凭3个啤酒瓶可以再换一瓶啤酒，凭5个瓶盖也可以再换一瓶啤酒，换来的啤酒可以继续换，但不允许赊账。
请编写一段程序，计算一个人初始买入n（1≤n≤100）瓶啤酒后，最终他最多能得到多少瓶啤酒，并将这个结果输出。
输入描述：
输入一个正整数n，表示初始买入的啤酒瓶数（1≤n≤100）
输出描述：
输出一个正整数，表示最终能得到的啤酒数
输入样例：
10
输出样例：
19
参考答案：br />输入n，输出最多得到的啤酒数。
解析：【喵呜刷题小喵解析】
本题是一道模拟题，需要根据题目描述的规则，模拟计算一个人初始买入n瓶啤酒后，最终最多能得到多少瓶啤酒。
我们可以使用一个循环来模拟这个过程，直到不能再换啤酒为止。每次循环，判断当前瓶数能否换成新的啤酒，如果可以，则加上新换到的啤酒数，并减去相应的瓶数或瓶盖数。
具体实现时，我们可以维护两个变量，分别表示当前拥有的瓶数和瓶盖数。初始时，瓶数和瓶盖数都为0，然后读入初始买入的啤酒瓶数。接下来，进入一个循环，直到当前拥有的瓶数或瓶盖数小于兑换啤酒所需的数量。
在每次循环中，我们判断当前拥有的瓶数能否兑换新的啤酒。如果可以，我们计算出能够兑换到的啤酒数，将瓶数减去兑换所需的数量，并加上新兑换到的啤酒数。如果当前拥有的瓶盖数能够兑换新的啤酒，我们同样进行处理。
最终，我们输出最终得到的啤酒数。
由于本题要求输出的是最多能得到的啤酒数，因此我们需要保证在每次循环中，都尽可能多地兑换啤酒。具体来说，我们应该先判断当前拥有的瓶数能否兑换新的啤酒，如果可以，则优先使用瓶数进行兑换。如果瓶数不足，再使用瓶盖进行兑换。
以下是示例代码：
```python
n = int(input())
bottles = n
caps = 0
result = n
while bottles >= 3 or caps >= 5:
if bottles >= 3:
new_bottles = bottles // 3
bottles -= 3 * new_bottles
result += new_bottles
if caps >= 5:
new_caps = caps // 5
caps -= 5 * new_caps
result += new_caps
if bottles >= 3:
new_bottles = bottles // 3
bottles -= 3 * new_bottles
result += new_bottles
if caps >= 5:
new_caps = caps // 5
caps -= 5 * new_caps
result += new_caps
print(result)
```
该代码首先读入初始买入的啤酒瓶数，然后进入一个循环，直到当前拥有的瓶数或瓶盖数不足兑换啤酒所需的数量。在每次循环中，我们先判断当前拥有的瓶数能否兑换新的啤酒，如果可以，则优先使用瓶数进行兑换。如果瓶数不足，再使用瓶盖进行兑换。最终输出最终得到的啤酒数。
6、反转递增串
时间限制：1s
内存限制：128mb
（注：input()括号中不允许添加任何提示语）
编写一段程序，输入一个n（2≤n≤1000）位正整数，将其中所有递增数字子串进行反转。
例如，正整数12387645包含两个递增数字子串1238和45，将这两部分进行反转，得到最终的83217654。
输入描述：
输入一个n（2≤n≤1000）位正整数
输出描述：
输出一行，为将输入中所有递增数字子串进行反转的结果
输入样例1：
12387645
输出样例1：
83217654
输入样例2：
87654321
输出样例2：
87654321
参考答案：```pythonn = int(input())s = str(n)res = ''inc_num = ''for i in range(len(s)):if i == 0 or s[i] > s[i-1]:inc_num += s[i]else:res += inc_num[::-1] + s[i]inc_num = ''res += inc_num[::-1]print(res)```
解析：【喵呜刷题小喵解析】：
本题要求将输入的正整数中的递增数字子串进行反转。我们可以遍历输入的每一位数字，判断当前位与前一位的大小关系，从而确定是否开始一个新的递增数字子串。
具体步骤如下：
1. 首先，将输入的整数转换为字符串，方便后续处理。
2. 初始化一个空字符串`res`用于存储最终结果，以及一个空字符串`inc_num`用于存储当前递增数字子串。
3. 遍历输入的每一位数字，如果当前位大于前一位，则将当前位加入`inc_num`中；否则，将`inc_num`反转并加入到`res`中，然后将当前位加入`res`和`inc_num`中。
4. 最后，将剩余的`inc_num`反转并加入到`res`中。
5. 输出`res`即可。
以上算法的时间复杂度为O(n)，其中n为输入整数的位数。
7、包围黑子块
时间限制：1s
内存限制：128mb
（注：input()括号中不允许添加任何提示语）
小张发明了一种新式的棋类游戏——战斗棋。在“战斗棋”中，棋子分为黑、白两色。有一条重要的规则叫做“包围败地”。即，横竖相连的同色棋子算成一块棋，一块棋被对方棋子横竖包围起来就算一块“败地”，棋盘边角也算是包围。
现有一片战斗棋区域，包含N * M（1≤N≤100，1≤M≤100）个落子点，所有落子点均摆满了棋子，其中1代表黑子、0代表白子。
请编写一段程序，计算并输出这片区域中被包围的黑色败地数量。
输入描述：
第一行输入2个正整数N和M（1≤N≤100，1≤M≤100），N表示区域的行数，M表示区域的列数，正整数之间以一个空格隔开
接下来的N行每行包括M个数字（数字只能为1或0），1表示黑子，0表示白子，数字之间以一个空格隔开
输出描述：
输出一个正整数，表示N * M的区域中被包围的黑色败地数量
输入样例：
5 3 1 0 1 0 1 0 0 1 0 1 0 1 0 0 0
输出样例：
5
参考答案：```pythondef count_black_defeated_areas(N, M, board):def dfs(i, j):if i < 0 or i >= N or j < 0 or j >= M or board[i][j] != 1:returnboard[i][j] = 2dfs(i - 1, j)dfs(i + 1, j)dfs(i, j - 1)dfs(i, j + 1)def count_defeated_areas():count = 0for i in range(N):for j in range(M):if board[i][j] == 1:dfs(i, j)if all(board[x][j] == 2 for x in range(i - 1, i + 2)) and \all(board[i][y] == 2 for y in range(j - 1, j + 2)):count += 1return countN, M = map(int, input().split())board = [list(map(int, input().split())) for _ in range(N)]return count_defeated_areas()print(count_black_defeated_areas())```
解析：【喵呜刷题小喵解析】：
本题要求计算并输出一片区域中被包围的黑色败地数量。首先，我们可以定义一个深度优先搜索（DFS）函数，用来将每个黑子的相邻格子标记为2。然后，我们可以遍历整个棋盘，统计标记为2的格子的数量，即被包围的黑子数量。
首先，我们需要读入棋盘的尺寸和每个格子上的棋子。输入样例的第一行表示棋盘的尺寸，接下来的N行每行包括M个数字，1表示黑子，0表示白子。
然后，我们定义一个二维数组board，用于存储棋盘的状态。其中，1表示黑子，0表示白子，2表示被标记的格子。
接着，我们定义DFS函数，用于将每个黑子的相邻格子标记为2。在DFS函数中，我们首先检查当前格子的坐标是否越界，以及当前格子是否为黑子。如果是，我们将当前格子标记为2，并递归地标记其相邻的格子。
最后，我们定义count_defeated_areas函数，用于统计被包围的黑子数量。我们遍历整个棋盘，如果当前格子为黑子，我们调用DFS函数将其相邻的格子标记为2。然后，我们检查当前格子的上下左右四个相邻格子是否都被标记为2，如果是，说明当前格子被包围，我们将计数器count加1。
最后，我们调用count_black_defeated_areas函数，将计算结果打印出来。
喵呜刷题：让学习像火箭一样快速，快来微信扫码，体验免费刷题服务，开启你的学习加速器！
