蓝桥杯题目讲解_Python（转载）

Fibonacci数列

问题描述
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。

当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。

输入格式
输入包含一个整数n。
输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。

样例输入
10
样例输出
55
样例输入
22
样例输出
7704
数据规模与约定
1 <= n <= 1,000,000

n=int(input())
f1=f2=f3=1
if n == 1 or n == 2:print(1)
elif n > 2:for i in range(3,n+1):f3 = (f1 + f2) % 10007f1 = f2f2 = f3print(f3)

圆的面积

问题描述
给定圆的半径r，求圆的面积。
输入格式
输入包含一个整数r，表示圆的半径。
输出格式
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
说明：在本题中，输入是一个整数，但是输出是一个实数。

对于实数输出的问题，请一定看清楚实数输出的要求，比如本题中要求保留小数点后7位，则你的程序必须严格的输出7位小数，输出过多或者过少的小数位数都是不行的，都会被认为错误。

实数输出的问题如果没有特别说明，舍入都是按四舍五入进行。

样例输入
4
样例输出
50.2654825
数据规模与约定
1 <= r <= 10000。
提示
本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。

r = int(input())
PI=3.1415926535
area = r**2 * PI
print('%.7f' % area)

序列求和

问题描述
求1+2+3+…+n的值。
输入格式
输入包括一个整数n。
输出格式
输出一行，包括一个整数，表示1+2+3+…+n的值。
样例输入
4
样例输出
10
样例输入
100
说明：有一些试题会给出多组样例输入输出以帮助你更好的做题。

一般在提交之前所有这些样例都需要测试通过才行，但这不代表这几组样例数据都正确了你的程序就是完全正确的，潜在的错误可能仍然导致你的得分较低。

样例输出
5050
数据规模与约定
1 <= n <= 1,000,000,000。
说明：请注意这里的数据规模。

本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。

本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。

如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。

def sum():n = int(input())return n*(1+n)/2 # 等差数列时间短 直接使用a+b会超时
s = int(sum())
print(s)

A+B问题

问题描述
输入A、B，输出A+B。
说明：在“问题描述”这部分，会给出试题的意思，以及所要求的目标。
输入格式
输入的第一行包括两个整数，由空格分隔，分别表示A、B。
说明：“输入格式”是描述在测试你的程序时，所给的输入一定满足的格式。

做题时你应该假设所给的输入是一定满足输入格式的要求的，所以你不需要对输入的格式进行检查。多余的格式检查可能会适得其反，使用你的程序错误。

在测试的时候，系统会自动将输入数据输入到你的程序中，你不能给任何提示。比如，你在输入的时候提示“请输入A、B”之类的话是不需要的，这些多余的输出会使得你的程序被判定为错误。

输出格式
输出一行，包括一个整数，表示A+B的值。
说明：“输出格式”是要求你的程序在输出结果的时候必须满足的格式。

在输出时，你的程序必须满足这个格式的要求，不能少任何内容，也不能多任何内容。如果你的内容和输出格式要求的不一样，你的程序会被判断为错误，包括你输出了提示信息、中间调试信息、计时或者统计的信息等。

样例输入
12 45
说明：“样例输入”给出了一组满足“输入格式”要求的输入的例子。

这里给出的输入只是可能用来测试你的程序的一个输入，在测试的时候，还会有更多的输入用来测试你的程序。

样例输出
57
说明：“样例输出”给出了一组满足“输出格式”要求的输出的例子。

样例输出中的结果是和样例输入中的是对应的，因此，你可以使用样例的输入输出简单的检查你的程序。

要特别指出的是，能够通过样例输入输出的程序并不一定是正确的程序，在测试的时候，会用很多组数据进行测试，而不局限于样例数据。有可能一个程序通过了样例数据，但测试的时候仍只能得0分，可能因为这个程序只在一些类似样例的特例中正确，而不具有通用性，再测试更多数据时会出现错误。

比如，对于本题，如果你写一个程序不管输入是什么都输入57，则样例数据是对的，但是测试其他数据，哪怕输入是1和2，这个程序也输出57，则对于其他数据这个程序都不正确。

数据规模与约定
-10000 <= A, B <= 10000。
说明：“数据规模与约定”中给出了试题中主要参数的范围。

这个范围对于解题非常重要，不同的数据范围会导致试题需要使用不同的解法来解决。比如本题中给的A、B范围不大，可以使用整型(int)来保存，如果范围更大，超过int的范围，则要考虑其他方法来保存大数。

有一些范围在方便的时候是在“问题描述”中直接给的，所以在做题时不仅要看这个范围，还要注意问题描述。

a,b=map(int,input().split())
print(a+b)

对列表每个元素应用函数# 将列表中的每个数字转换为字符串
numbers = [1, 2, 3, 4, 5]
str_numbers = list(map(str, numbers))
print(str_numbers)  # ['1', '2', '3', '4', '5']# 计算每个数字的平方
squares = list(map(lambda x: x**2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

# 将温度从摄氏度转换为华氏度
celsius = [0, 10, 20, 30, 40]
fahrenheit = list(map(lambda c: c * 9/5 + 32, celsius))
print(fahrenheit)  # [32.0, 50.0, 68.0, 86.0, 104.0]

# 处理学生成绩
scores = [85, 92, 78, 90, 88]# 给每个成绩加5分（平时分）
adjusted_scores = list(map(lambda x: min(100, x + 5), scores))
print(adjusted_scores)  # [90, 97, 83, 95, 93]# 转换为等级
def score_to_grade(score):if score >= 90: return 'A'elif score >= 80: return 'B'elif score >= 70: return 'C'else: return 'D'grades = list(map(score_to_grade, scores))
print(grades)  # ['B', 'A', 'C', 'A', 'B']

数列排序

问题描述
　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
　　第一行为一个整数n。
　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
　　输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9

n = int(input())
list = list(map(int, input().split()))
list = sorted(list)
for i in range(len(list)):print(list[i], end= ' ')

十六进制转八进制

问题描述
　　给定n个十六进制正整数，输出它们对应的八进制数。

输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。
　　接下来n行，每行一个由0_{9、大写字母A}F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

输出格式
　　输出n行，每行为输入对应的八进制正整数。

【注意】
　　输入的十六进制数不会有前导0，比如012A。
　　输出的八进制数也不能有前导0。

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

【提示】
　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

n = int(input())for line in range(n):num = input()ans = format(int(num, 16), 'o')print(ans)

# 整数格式化
num = 42
result = "十进制: {0:d}, 二进制: {0:b}, 八进制: {0:o}, 十六进制: {0:x}".format(num)
# 结果: '十进制: 42, 二进制: 101010, 八进制: 52, 十六进制: 2a'# 浮点数格式化
price = 123.4567
results = ["默认: {:.2f}".format(price),           # '默认: 123.46'"科学计数法: {:.2e}".format(price),     # '科学计数法: 1.23e+02'"百分比: {:.1%}".format(0.456),         # '百分比: 45.6%'"总宽度8位: {:8.2f}".format(price),     # '总宽度8位:   123.46'"左对齐: {:<8.2f}".format(price),       # '左对齐: 123.46  '"右对齐: {:>8.2f}".format(price),       # '右对齐:   123.46'"居中对齐: {:^8.2f}".format(price),     # '居中对齐:  123.46 '"前导零: {:08.2f}".format(price),       # '前导零: 00123.46'"千分位: {:,}".format(1234567.89),      # '千分位: 1,234,567.89'
]

十六进制转十进制

问题描述
　　从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
　　注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
样例输入
FFFF
样例输出
65535

n = input()
print(int(n, 16))

十进制转十六进制

问题描述
　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。
　　给出一个非负整数，将它表示成十六进制的形式。
输入格式
　　输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647
输出格式
　　输出这个整数的16进制表示
样例输入
30
样例输出
1E

n = int(input())
print(format(n, 'X')) #X为大写,x是小写

特殊回文数

问题描述
　　123321是一个非常特殊的数，它从左边读和从右边读是一样的。
　　输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
输入格式
　　输入一行，包含一个正整数n。
输出格式
　　按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998
989989
998899
数据规模和约定
　　1<=n<=54。

# 判断是否为回文数
def is_pal(num):num = str(num)  # 将数字转为字符串if num == num[::-1]:  # 判断字符串是否与其反转后相同return True  # 如果是回文数，返回Trueelse:return False  # 如果不是回文数，返回False# 计算数字各位的和
def sum_num(num):sum = 0  # 初始化和为0num = str(num)  # 将数字转为字符串，方便逐位访问for i in range(len(num)):  # 遍历每一位sum += int(num[i])  # 将当前位的字符转为整数，并加到和上return sum  # 返回数字的各位和# 主函数
if __name__ == '__main__':n = int(input())  # 输入一个整数n，表示数字各位之和需要等于nfor num in range(10000, 1000000):  # 遍历所有从10000到999999的数if is_pal(num) and sum_num(num) == n:  # 判断是否是回文数且各位和为nprint(num)  # 如果满足条件，打印该数字

is_pal(num)：将数字 num 转换为字符串，然后检查字符串是否等于其反转后的字符串。回文数的特点是正反读一样。

sum_num(num)：将数字转换为字符串后，逐位取数字，将其转换为整数并求和，最终返回各位数字的和。

main函数：从 10000 到 999999 遍历每个数字，判断其是否为回文数且各位之和是否为输入的 n。如果满足条件，则打印该数字。

回文数

问题描述
　　1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
输出格式
　　按从小到大的顺序输出满足条件的四位十进制数。

# 判断是否为回文数
def is_pal(num):num = str(num)  # 将数字转为字符串if num == num[::-1]:  # 判断字符串是否与其反转后相同return True  # 如果是回文数，返回Trueelse:return False  # 如果不是回文数，返回False# 主函数
if __name__ == '__main__':for i in range(1000, 10000):  # 遍历所有从1000到9999的数if is_pal(i):  # 判断当前数是否是回文数print(i)  # 如果是回文数，打印该数字

is_pal(num)：该函数将数字 num 转换为字符串，并检查它是否等于其反转后的字符串。回文数的特点是正读和反读都一样。

main函数：从 1000 到 9999 遍历每个数字，调用 is_pal() 判断当前数字是否是回文数。如果是回文数，则打印该数字。

特殊的数字

问题描述
　　153是一个非常特殊的数，它等于它的每位数字的立方和，即153=111+555+333。编程求所有满足这种条件的三位十进制数。
输出格式
　　按从小到大的顺序输出满足条件的三位十进制数，每个数占一行

# 判断一个数字是否满足各位数立方和等于数字本身
def is_ans(num):# 计算数字各位的立方和num_sum = pow(int(str(num)[0]), 3) + pow(int(str(num)[1]), 3) + pow(int(str(num)[2]), 3)if num == num_sum:  # 如果数字等于立方和，则返回Truereturn True# 主程序
for ans in range(100, 1000):  # 遍历所有3位数，从100到999if is_ans(ans):  # 如果当前数字满足条件print(ans)  # 打印该数字

题目要求：找出所有符合条件的3位数，其中每个数字的立方和等于该数字本身。这是一个经典的 “阿姆斯特朗数” 或 “水仙花数” 的问题。对每个数字，检查其各位数的立方和是否等于该数字。

步骤分析：

立方和判断：对于3位数 num，我们需要计算该数每一位数的立方和，然后判断是否等于原数字。

遍历：遍历所有3位数（从100到999），判断每个数字是否满足立方和等于数字本身。

程序流程：

对于每一个数字，取其每一位数，计算每一位数的立方和。

如果立方和等于该数字，则输出该数字。

is_ans(num)：

将数字 num 转换为字符串，逐位提取每一位数字。

使用 pow(int(str(num)[0]), 3) 计算每一位数字的立方，pow() 是计算某个数的幂函数，pow(x, 3) 表示 x 的三次方。

将每一位的立方加在一起，得到 num_sum。

如果 num_sum 等于原数字 num，返回 True，表示满足条件。

主程序：

遍历从100到999的所有数字。

对每个数字，调用 is_ans() 判断其是否满足条件。

如果满足条件，则输出该数字。

# 这里使用了str转换字符串取位数,或者可以直接用除法取位数
def is_ans(num):a = num % 10b = (num // 10) % 10c = (num // 100) % 10if num == pow(a, 3) + pow(b, 3) + pow(c, 3):return Truefor ans in range(100, 1000):if is_ans(ans):print(ans)

杨辉三角形

杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。

它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。

下面给出了杨辉三角形的前4行：

1

1 1

1 2 1

1 3 3 1

给出n，输出它的前n行。

输入格式
输入包含一个数n。

输出格式
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。
样例输入
4
样例输出
1
1 1
1 2 1
1 3 3 1
数据规模与约定
1 <= n <= 34。

题目要求：给定一个整数 n，输出 n 行杨辉三角（也称为帕斯卡三角）。杨辉三角的构造规则是：第 0 行为 [1]。第 1 行为 [1, 1]。从第 2 行开始，任何一行的第 i 个元素（对于 1 <= i <= n-2）等于上一行的第 i-1 和第 i 个元素的和。行的两端元素始终为 1。步骤分析：使用一个列表 n 来存储当前行的元素。从第一行开始，依次计算每一行元素，直到输出 n 行。每一行的元素可以通过上一行的元素计算得到，使用列表解析式来生成新的行。程序流程：初始化一个列表 n = [1]，表示第一行。输出当前行，并根据上一行计算出新一行。继续输出直到打印完 n 行。# 打印杨辉三角
def triangles(num):n = [1]  # 第一行是[1]while num > 0:  # 当num大于0时，继续打印for i in range(len(n)):  # 遍历当前行的每个元素print(n[i], end=' ')  # 打印每个元素，end=' '表示元素间有空格n = [1] + [n[i] + n[i+1] for i in range(len(n) - 1)] + [1]  # 计算下一行num -= 1  # 行数减1，直到打印完n行print()  # 换行，开始打印下一行# 主程序
if __name__ == '__main__':n = int(input())  # 输入行数triangles(n)  # 调用函数打印杨辉三角

查找整数

问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。

输入格式
第一行包含一个整数n。

第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。

第三行包含一个整数a，为待查找的数。

输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000。

# 查找num在列表中的位置，若找不到输出-1
def is_ans(num, list):for i in range(len(list)):  # 遍历列表的每个元素if num == list[i]:  # 如果num等于当前元素print(i+1)  # 输出位置，注意是1-based索引break  # 找到后跳出循环if num not in list:  # 如果num不在列表中print(-1)  # 输出-1表示未找到# 主程序
if __name__ == '__main__':n = int(input())  # 输入列表的长度list = list(map(int, input().split()))  # 输入列表的元素，并转为整数列表num = int(input())  # 输入目标数字numis_ans(num, list)  # 调用is_ans函数，查找num在列表中的位置

闰年判断

给定一个年份，判断这一年是不是闰年。

当以下情况之一满足时，这一年是闰年：

1. 年份是4的倍数而不是100的倍数；

2. 年份是400的倍数。

其他的年份都不是闰年。

输入格式
输入包含一个整数y，表示当前的年份。
输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。

def is_leapyear(num):if num % 4 == 0 and num % 100 != 0 or num % 400 == 0:return Truereturn Falseif __name__ == '__main__':num = int(input())if is_leapyear(num):print('yes')else:print('no')