代码收藏家 NCRE全国计算机等级考试二级Python-50道基础编程题【带解析】
**
整理不易，点赞 和 关注 是我最大的动力！💪 如果觉得有帮助，记得点个赞哦！话不多说，我们开始下文吧！🚀
**
题型记录：
基础编程题：50道 包含解析
1. 输入两个整数，输出它们的和
题目描述：
编写程序，输入两个整数，输出它们的和。
答案：
a, b = map(int, input().split()) # 输入两个整数
print(a + b) # 输出它们的和
分析：
使用 map() 函数将输入的字符串转换为整数，并计算它们的和。
2. 判断一个数是否为偶数
题目描述：
编写程序，输入一个整数，判断它是否为偶数。如果是偶数，输出 “偶数”；否则输出 “奇数”。
答案：
num = int(input()) # 输入一个整数
if num % 2 == 0:
print("偶数")
else:
print("奇数")
分析：
通过取余运算判断整数是否为偶数。
3. 判断一个数是否为质数
题目描述：
编写程序，输入一个正整数，判断它是否为质数。质数是指只能被1和它本身整除的数。
答案：
n = int(input()) # 输入整数
if n < 2:
print("不是质数")
else:
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
print("不是质数")
break
else:
print("是质数")
分析：
质数只能被1和它本身整除，因此我们只需要判断从 2 到 sqrt(n) 之间的数是否能整除 n。若能整除，则 n 不是质数；否则，它是质数。
4. 计算列表中所有数字的和
题目描述：
编写程序，输入一组整数，计算并输出它们的和。
答案：
numbers = list(map(int, input().split())) # 输入一组整数
print(sum(numbers)) # 计算并输出和
分析：
使用 sum() 函数来计算列表中所有数字的和。
5. 反转一个字符串
题目描述：
编写程序，输入一个字符串，输出其反转后的字符串。
答案：
s = input() # 输入字符串
reversed_s = s[::-1] # 反转字符串
print(reversed_s)
分析：
使用 Python 的切片功能，[::-1] 可以反转字符串。
6. 统计字符串中的元音字母个数
题目描述：
编写程序，输入一个字符串，统计其中元音字母（a, e, i, o, u）的个数。
答案：
s = input() # 输入字符串
vowels = "aeiouAEIOU" # 定义元音字母
count = sum(1 for char in s if char in vowels) # 统计元音字母个数
print(count)
分析：
通过遍历字符串并检查每个字符是否是元音字母来统计元音字母的个数，使用 sum() 函数和生成器表达式进行高效统计。
7. 找出列表中的最大值
题目描述：
编写程序，输入一组整数，找出其中的最大值。
答案：
numbers = list(map(int, input().split())) # 输入一组整数
print(max(numbers)) # 输出最大值
分析：
使用 Python 内置的 max() 函数来找出列表中的最大值。
8. 判断一个年份是否为闰年
题目描述：
编写程序，输入一个年份，判断它是否为闰年。闰年的规则是：
答案：
year = int(input()) # 输入年份
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
print("是闰年")
else:
print("不是闰年")
分析：
通过判断年份是否能被 4 整除但不能被 100 整除，或者能被 400 整除来确定是否为闰年。
9. 计算一个数的阶乘
题目描述：
编写程序，输入一个整数，计算它的阶乘。
答案：
n = int(input()) # 输入整数
factorial = 1
for i in range(1, n + 1):
factorial *= i
print(factorial)
分析：
通过 for 循环计算整数的阶乘，逐步将每个数相乘。
10. 合并两个有序列表
题目描述：
编写程序，输入两个已经排好序的整数列表，合并它们并保持有序。
答案：
list1 = list(map(int, input().split())) # 输入第一个有序列表
list2 = list(map(int, input().split())) # 输入第二个有序列表
merged_list = sorted(list1 + list2) # 合并并排序
print(merged_list)
分析：
将两个列表合并后，使用 sorted() 函数对合并后的列表进行排序，输出结果。
11. 输出斐波那契数列的前n项
题目描述：
编写程序，输入一个整数n，输出斐波那契数列的前n项。斐波那契数列定义为：
F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2) (n ≥ 2)。
答案：
n = int(input()) # 输入整数n
a, b = 0, 1
for i in range(n):
print(a, end=" ")
a, b = b, a + b
分析：
斐波那契数列的递推公式是 F(n) = F(n-1) + F(n-2)，通过循环输出前n项。
12. 查找列表中最小值和最大值的差
题目描述：
编写程序，输入一组整数，计算并输出列表中最大值和最小值的差。
答案：
numbers = list(map(int, input().split())) # 输入一组整数
diff = max(numbers) - min(numbers) # 计算最大值和最小值的差
print(diff)
分析：
使用 max() 和 min() 函数分别找出列表中的最大值和最小值，然后计算它们的差。
13. 统计字符串中某个字符出现的次数
题目描述：
编写程序，输入一个字符串和一个字符，统计该字符在字符串中出现的次数。
答案：
s = input() # 输入字符串
char = input() # 输入字符
count = s.count(char) # 统计字符出现的次数
print(count)
分析：
使用字符串的 count() 方法统计某个字符在字符串中出现的次数。
14. 判断一个字符串是否是回文
题目描述：
编写程序，输入一个字符串，判断它是否是回文字符串。回文字符串是指正读和反读都相同的字符串。
答案：
s = input() # 输入字符串
if s == s[::-1]: # 判断是否是回文
print("是回文")
else:
print("不是回文")
分析：
使用切片 [::-1] 反转字符串，然后判断是否和原字符串相同。
15. 打印九九乘法表
题目描述：
编写程序，打印九九乘法表。
答案：
for i in range(1, 10):
for j in range(1, i + 1):
print(f"{j}*{i}={i*j}", end="\t")
print()
分析：
通过嵌套循环输出九九乘法表，每行打印 i 次，i 从 1 到 9。
16. 判断字符串中是否包含数字
题目描述：
编写程序，输入一个字符串，判断它是否包含数字。如果包含数字，输出 “包含数字”；否则输出 “不包含数字”。
答案：
s = input() # 输入字符串
if any(char.isdigit() for char in s): # 判断是否包含数字
print("包含数字")
else:
print("不包含数字")
分析：
使用 any() 和 isdigit() 方法检查字符串中是否有数字。
17. 计算并输出列表中所有元素的平均值
题目描述：
编写程序，输入一组整数，计算并输出它们的平均值。
答案：
numbers = list(map(int, input().split())) # 输入一组整数
average = sum(numbers) / len(numbers) # 计算平均值
print(average)
分析：
通过 sum() 函数计算总和，再通过 len() 获取元素个数，计算平均值。
18. 判断字符串中是否有重复字符
题目描述：
编写程序，输入一个字符串，判断其中是否有重复字符。如果有重复字符，输出 “有重复字符”；否则输出 “没有重复字符”。
答案：
s = input() # 输入字符串
if len(s) != len(set(s)): # 判断是否有重复字符
print("有重复字符")
else:
print("没有重复字符")
分析：
通过将字符串转换为集合（集合中的元素是唯一的），如果长度不同，则说明存在重复字符。
19. 求一个数的平方根
题目描述：
编写程序，输入一个非负数，计算它的平方根。
答案：
import math
n = float(input()) # 输入一个非负数
if n >= 0:
print(math.sqrt(n)) # 计算平方根
else:
print("输入无效")
分析：
使用 math.sqrt() 函数计算平方根，注意处理负数输入的情况。
20. 判断一个数字是否为水仙花数
题目描述：
编写程序，输入一个三位数，判断它是否为水仙花数。水仙花数是指一个三位数等于其各位数字的立方和。
答案：
num = int(input()) # 输入一个三位数
hundreds = num // 100
tens = (num // 10) % 10
ones = num % 10
if num == hundreds**3 + tens**3 + ones**3:
print("是水仙花数")
else:
print("不是水仙花数")
分析：
通过计算三位数的各位数字的立方和，判断它是否等于原数字。
21. 计算一个数的立方根
题目描述：
编写程序，输入一个非负数，计算它的立方根。
答案：
import math
n = float(input()) # 输入一个非负数
if n >= 0:
print(round(math.pow(n, 1/3), 2)) # 计算并输出立方根，保留两位小数
else:
print("输入无效")
分析：
使用 math.pow() 函数计算立方根，1/3 表示求立方根，round() 保留两位小数。
22. 打印矩阵的对角线元素
题目描述：
编写程序，输入一个n×n的矩阵，输出该矩阵的主对角线元素（即从左上角到右下角的对角线元素）。
答案：
n = int(input()) # 输入矩阵的大小
matrix = [list(map(int, input().split())) for _ in range(n)] # 输入矩阵
for i in range(n):
print(matrix[i][i], end=" ") # 打印主对角线元素
分析：
输入矩阵后，遍历每一行，输出矩阵中主对角线的位置元素，即 matrix[i][i]。
23. 找出列表中的重复元素
题目描述：
编写程序，输入一个整数列表，找出其中重复的元素。
答案：
numbers = list(map(int, input().split())) # 输入整数列表
duplicates = set([x for x in numbers if numbers.count(x) > 1]) # 找出重复元素
print(duplicates)
分析：
通过 count() 函数统计每个元素出现的次数，使用集合 set() 去重后输出重复的元素。
24. 计算列表中所有正数的和
题目描述：
编写程序，输入一组整数，计算并输出其中所有正数的和。
答案：
numbers = list(map(int, input().split())) # 输入一组整数
positive_sum = sum(x for x in numbers if x > 0) # 计算所有正数的和
print(positive_sum)
分析：
通过列表生成式和 sum() 函数筛选出正数并计算其和。
25. 生成指定范围的随机整数
题目描述：
编写程序，生成指定范围内的一个随机整数。
答案：
import random
low = int(input()) # 输入范围下限
high = int(input()) # 输入范围上限
print(random.randint(low, high)) # 生成并输出随机整数
分析：
使用 random.randint() 函数生成指定范围内的随机整数。
26. 计算一个字符串中每个字符的出现次数
题目描述：
编写程序，输入一个字符串，计算并输出每个字符在字符串中出现的次数。
答案：
from collections import Counter
s = input() # 输入字符串
count = Counter(s) # 计算每个字符的出现次数
for char, freq in count.items():
print(f"{char}: {freq}")
分析：
使用 collections.Counter 类来统计字符串中每个字符的频率，并输出结果。
27. 计算一个整数列表中的偶数和奇数个数
题目描述：
编写程序，输入一组整数，统计并输出其中偶数和奇数的个数。
答案：
numbers = list(map(int, input().split())) # 输入一组整数
even_count = sum(1 for x in numbers if x % 2 == 0) # 统计偶数个数
odd_count = len(numbers) - even_count # 统计奇数个数
print(f"偶数个数: {even_count}, 奇数个数: {odd_count}")
分析：
通过 sum() 函数统计偶数个数，奇数个数等于总数减去偶数个数。
28. 判断一个字符串是否包含特定的子字符串
题目描述：
编写程序，输入一个字符串和一个子字符串，判断子字符串是否存在于该字符串中。
答案：
s = input() # 输入字符串
substring = input() # 输入子字符串
if substring in s: # 判断子字符串是否存在
print("存在")
else:
print("不存在")
分析：
使用 in 运算符判断子字符串是否存在于主字符串中。
29. 输出数字的倒序排列
题目描述：
编写程序，输入一个数字，将该数字的各位数字按倒序输出。
答案：
num = input() # 输入数字
print(num[::-1]) # 反转并输出数字
分析：
通过字符串的切片功能 [::-1] 反转数字字符串，并输出。
30. 统计数字中各位数字之和
题目描述：
编写程序，输入一个正整数，统计该数字中各位数字之和。
答案：
num = input() # 输入数字
digit_sum = sum(int(digit) for digit in num) # 计算各位数字之和
print(digit_sum)
分析：
通过将数字转换为字符串，遍历每一位数字，并计算其和。
31. 打印九九乘法表的逆序
题目描述：
编写程序，打印九九乘法表的逆序，即从 9×9 到 1×1。
答案：
for i in range(9, 0, -1):
for j in range(i, 0, -1):
print(f"{j}*{i}={i*j}", end="\t")
print()
分析：
通过嵌套循环来输出九九乘法表，外层循环从 9 遍历到 1，内层循环也从当前值开始递减。
32. 计算一个数的阶乘
题目描述：
编写程序，输入一个整数n，计算并输出n的阶乘。
答案：
n = int(input()) # 输入整数n
factorial = 1
for i in range(1, n + 1):
factorial *= i # 计算阶乘
print(factorial)
分析：
通过循环计算阶乘，逐个相乘直到n。
33. 交换两个变量的值
题目描述：
编写程序，输入两个变量a和b，交换它们的值并输出交换后的结果。
答案：
a, b = map(int, input().split()) # 输入两个整数
a, b = b, a # 交换值
print(a, b)
分析：
使用 Python 中的多元赋值语法可以轻松实现变量交换。
34. 判断一个年份是否为闰年
题目描述：
编写程序，输入一个年份，判断它是否为闰年。闰年的条件是：
- 能被4整除，但不能被100整除；
- 能被400整除的年份也是闰年。
答案：
year = int(input()) # 输入年份
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
print("是闰年")
else:
print("不是闰年")
分析：
通过条件判断来检查年份是否符合闰年的规则。
35. 列表去重
题目描述：
编写程序，输入一个包含重复元素的列表，输出去重后的列表。
答案：
numbers = list(map(int, input().split())) # 输入列表
unique_numbers = list(set(numbers)) # 去重
print(unique_numbers)
分析：
使用 set() 去重，set 会自动去除重复的元素，之后再将其转回列表。
36. 输出指定范围内的所有素数
题目描述：
编写程序，输入一个整数n，输出从 1 到 n 之间的所有素数。
答案：
n = int(input()) # 输入整数n
for num in range(2, n + 1): # 从2到n遍历
for i in range(2, int(num**0.5) + 1):
if num % i == 0:
break
else:
print(num, end=" ") # 输出素数
分析：
通过判断每个数是否能被 2 到其平方根之间的数整除，来判断其是否为素数。
37. 列表中最大元素的索引
题目描述：
编写程序，输入一组整数，找出列表中最大元素的索引。
答案：
numbers = list(map(int, input().split())) # 输入整数列表
max_index = numbers.index(max(numbers)) # 获取最大值的索引
print(max_index)
分析：
使用 max() 获取最大元素，然后用 index() 查找该元素在列表中的索引。
38. 合并两个已排序的列表
题目描述：
编写程序，输入两个已排序的整数列表，将它们合并为一个新的已排序列表。
答案：
list1 = list(map(int, input().split())) # 输入第一个已排序列表
list2 = list(map(int, input().split())) # 输入第二个已排序列表
merged_list = sorted(list1 + list2) # 合并并排序
print(merged_list)
分析：
通过将两个列表合并后使用 sorted() 函数进行排序。
39. 查找字符串中最长的子串
题目描述：
编写程序，输入一个字符串，查找其中最长的连续子串，并输出该子串。
答案：
s = input() # 输入字符串
max_substr = ""
current_substr = ""
for i in range(1, len(s)):
if s[i] >= s[i - 1]:
current_substr += s[i - 1]
else:
if len(current_substr) > len(max_substr):
max_substr = current_substr
current_substr = s[i]
if len(current_substr) > len(max_substr):
max_substr = current_substr
print(max_substr)
分析：
通过遍历字符串并比较相邻字符，找到最长的连续子串。
40. 计算正整数的位数
题目描述：
编写程序，输入一个正整数，计算并输出它的位数。
答案：
num = int(input()) # 输入正整数
digit_count = len(str(num)) # 通过将数字转为字符串来计算位数
print(digit_count)
分析：
将数字转换为字符串，字符串的长度即为数字的位数。
41. 判断字符串是否为回文
题目描述：
编写程序，输入一个字符串，判断该字符串是否为回文字符串（即正着读和反着读都一样）。
答案：
s = input() # 输入字符串
if s == s[::-1]: # 判断是否为回文
print("是回文")
else:
print("不是回文")
分析：
通过字符串的切片功能 [::-1] 判断字符串是否等于它的反转。
42. 输出指定范围内的所有完美数
题目描述：
编写程序，输入一个整数n，输出从 1 到 n 之间的所有完美数。完美数是指一个数等于它所有真因子（不包括自身）之和。
答案：
def is_perfect(num):
divisors_sum = sum(i for i in range(1, num) if num % i == 0)
return divisors_sum == num
n = int(input()) # 输入整数n
for i in range(1, n + 1):
if is_perfect(i):
print(i, end=" ")
分析：
通过定义 is_perfect 函数判断一个数是否为完美数，遍历从 1 到 n 的数。
43. 统计单词的出现次数
题目描述：
编写程序，输入一段文字，统计并输出每个单词出现的次数。
答案：
from collections import Counter
words = input().split() # 输入并分割单词
word_count = Counter(words) # 统计每个单词的出现次数
for word, count in word_count.items():
print(f"{word}: {count}")
分析：
使用 collections.Counter 统计单词出现的频率，然后输出结果。
44. 生成斐波那契数列
题目描述：
编写程序，输入一个整数n，生成并输出前n个斐波那契数。
答案：
n = int(input()) # 输入整数n
fib = [0, 1]
for i in range(2, n):
fib.append(fib[i-1] + fib[i-2]) # 生成斐波那契数列
print(fib[:n])
分析：
通过列表存储斐波那契数列，迭代生成下一个数直到n个。
45. 判断一个数是否为完全平方数
题目描述：
编写程序，输入一个整数，判断该数是否为完全平方数（即其平方根是整数）。
答案：
import math
num = int(input()) # 输入整数
if math.isqrt(num) ** 2 == num: # 判断是否为完全平方数
print("是完全平方数")
else:
print("不是完全平方数")
分析：
使用 math.isqrt() 获取整数平方根，并判断平方后是否与原数相等。
46. 计算两个矩阵的乘积
题目描述：
编写程序，输入两个矩阵，计算并输出它们的乘积。假设矩阵的大小已经满足乘法的条件（即第一个矩阵的列数等于第二个矩阵的行数）。
答案：
def multiply_matrices(A, B):
rows_A = len(A)
cols_A = len(A[0])
cols_B = len(B[0])
C = [[0] * cols_B for _ in range(rows_A)] # 初始化结果矩阵
for i in range(rows_A):
for j in range(cols_B):
C[i][j] = sum(A[i][k] * B[k][j] for k in range(cols_A)) # 计算每个元素
return C
# 输入第一个矩阵
A = [list(map(int, input().split())) for _ in range(int(input()))]
# 输入第二个矩阵
B = [list(map(int, input().split())) for _ in range(int(input()))]
# 计算并输出矩阵乘积
C = multiply_matrices(A, B)
for row in C:
print(" ".join(map(str, row)))
分析：
通过嵌套循环计算矩阵乘积，注意矩阵乘法的条件是第一个矩阵的列数与第二个矩阵的行数相等。
47. 计算列表中出现最多的元素
题目描述：
编写程序，输入一个列表，计算并输出该列表中出现次数最多的元素。
答案：
numbers = list(map(int, input().split())) # 输入整数列表
most_common = max(set(numbers), key=numbers.count) # 获取出现次数最多的元素
print(most_common)
分析：
通过 set() 去重，并使用 max() 函数和 numbers.count 获取出现次数最多的元素。
48. 判断一个数是否为水仙花数
题目描述：
编写程序，输入一个三位数，判断该数是否为水仙花数。水仙花数是指一个三位数，其各位数字的立方和等于该数字本身。
答案：
num = int(input()) # 输入三位数
hundreds = num // 100
tens = (num // 10) % 10
ones = num % 10
if hundreds ** 3 + tens ** 3 + ones ** 3 == num:
print("是水仙花数")
else:
print("不是水仙花数")
分析：
通过分解数字的每一位并计算立方和来判断是否为水仙花数。
49. 输出杨辉三角
题目描述：
编写程序，输入一个整数n，输出杨辉三角的前n行。
答案：
def generate_pascals_triangle(n):
triangle = [[1]] # 初始化杨辉三角的第一行
for i in range(1, n):
row = [1]
for j in range(1, i):
row.append(triangle[i-1][j-1] + triangle[i-1][j])
row.append(1)
triangle.append(row)
return triangle
n = int(input()) # 输入行数
triangle = generate_pascals_triangle(n)
# 输出杨辉三角
for row in triangle:
print(" ".join(map(str, row)))
分析：
通过构建杨辉三角的每一行，前一行的数值相加得到当前行的元素。
50. 统计数字中奇数的个数
题目描述：
编写程序，输入一个数字，统计并输出该数字中奇数的个数。
答案：
num = input() # 输入数字
odd_count = sum(1 for digit in num if int(digit) % 2 != 0) # 统计奇数个数
print(odd_count)
分析：
通过遍历数字的每一位，使用 sum() 函数统计奇数的个数。
作者：温酒往事·
