python蓝桥杯基础练习17题

矫情吗；* 2024-03-24 14:05 90阅读 0赞

> 跟学链接：[Python蓝桥杯真题——基础练习（一）][Python]

## 1.A+B问题 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 输入A、B，输出A+B。  
> 输入格式  
> 输入的第一行包括两个整数，由空格分隔，分别表示A、B。  
> 输出格式  
> 输出一行，包括一个整数，表示A+B的值。  
> 样例输入  
> 12 45  
> 样例输出  
> 57  
> 数据规模与约定  
> \-10000 <= A, B <= 10000。

知识点：  
1.[python常见input()输入形式][python_input]  
2.[python中的map函数][python_map]  
3.[关乎Python lambda你也看得懂][Python lambda]  
4.[学会Lambda，让程序Pythonic一点][Lambda_Pythonic]  
5.[Python中超好用的split()函数，详解][Python_split]  
6.[详解Python中的split()函数的使用方法][Python_split 1]  
7.[Python中的join函数][Python_join]  
源码

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

## 2.数列排序 ##

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

知识点：  
1.[Python sorted() 函数][Python sorted_]  
2.[Python输出列表(List)不带中括号和引号][Python sorted_]  
3.[Python中的排序函数–sorted()函数][Python_sorted]  
4.[Python基础之sorted（）函数用法][Python_sorted 1]  
另外：list() 方法用于将元组转换为列表，如下。

aTuple = (123, 'runoob', 'google', 'abc');
    aList = list(aTuple)
     
    print ("列表元素 : ")
    print(aList)
    #输出如下
    #列表元素 : 
    #[123, 'runoob', 'google', 'abc']

源码

n = int(input())
    li1 = list(map(int,input().split()))
    li2 = sorted(li1)
    for i in li2:
        print(i,end=" ")

## 3.十六进制转八进制 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 给定n个十六进制正整数，输出它们对应的八进制数。  
> 输入格式  
> 输入的第一行为一个正整数n （1<=n<=10）。  
> 接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。  
> 输出格式  
> 输出n行，每行为输入对应的八进制正整数。  
> 【注意】  
> 输入的十六进制数不会有前导0，比如012A。  
> 输出的八进制数也不能有前导0。  
> 样例输入  
> 2  
> 39  
> 123ABC  
> 样例输出  
> 71  
> 4435274

知识点：  
1.[python 进制转换][python]  
任意进制转换为十进制：int(s,n），结果为int型

十进制转换其它进制：  
转换为十六进制：hex(s)  
转换为八进制：oct(s)  
转换为二进制：bin(s)

结果都为string类型：因此oct(int(j,16))\[2:\]即s\[2:\]  
2.[python学习之列表][python 1]  
3.[【Python】Python列表基本操作][Python_Python]  
4.[python常用内置函数][python 2]  
此处有长度要求，需体现在代码中，下一题中8位数的大小要求可忽视。  
源码

n = int(input())
    li = []
    for i in range(n):
        li.append(input())
    
    for j in li:
        if len(j) <= 100000:
        print(oct(int(j,16))[2:])

## 4.十六进制转十进制 ##

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

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

## 5.十进制转十六进制 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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

知识点：  
1.[Python字符串操作][Python 1]  
2.大小写问题的函数如下：

# 将所有字符变成大写 
    "china".upper()  
    # CHINA
    
    # 将字符串的首字母变成大写 
    "china".capitalize() 
    # China
    
    # 将所有字符变成小写
    "CHINA".lower()
    # china
    
    # 将每个单词的首字母变成大写 
    "i have a dream".title()
    # I Have A Dream

源码

n = int(input())
    if n<=2147483647:
        print(hex(n)[2:].upper())

## 6.特殊回文数 ##

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

知识点：  
[二进制位运算符&| ^ ~与逻辑运算符and or not][_ _and or not]  
暴力破解。  
源码

n = int(input())
    for i in range(10000,100000):
        a1 = i % 10   #  个位数
        a2 = i // 10 % 10    #  十位数
        a3 = i // 100 % 10      #  百位数
        a4 = i // 1000 % 10      #  千位数
        a5 = i // 10000  # 万位数
        if a1+a2+a3+a4+a5 == n and a1 == a5 and a2 == a4:
            print(i)
    for i in range(100000,1000000):
        a1 = i % 10   #  个位数
        a2 = i // 10 % 10    #  十位数
        a3 = i // 100 % 10      #  百位数
        a4 = i // 1000 % 10      #  千位数
        a5 = i // 10000 % 10  # 万位数
        a6 = i // 100000    #  十万位数
        if a1+a2+a3+a4+a5+a6 == n and a1 == a6 and a2 == a5 and a3 == a4:
            print(i)

## 7.回文数 ##

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

暴力破解  
源码

for i in range(1000,10000):
        a1 = i % 10   #  个位数
        a2 = i // 10 % 10    #  十位数
        a3 = i // 100 % 10      #  百位数
        a4 = i // 1000      #  千位数
        if a1 == a4 and a2 == a3:
            print(i)

## 8.特殊的数字 ##

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

暴力破解。  
源代码

for i in range(100,1000):
        a1 = i % 10   #  个位数
        a2 = i // 10 % 10    #  十位数
        a3 = i // 100      #  百位数
        if a1*a1*a1+a2*a2*a2+a3*a3*a3 == i:
            print(i)

## 9.杨辉三角形 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 杨辉三角形又称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。

知识点  
1.[python正确创建二维列表][python 3]  
2.[Python ------技巧系列一][Python ------]  
3.[\[i for i in range(1,10)\] — 列表解析式，列表中使用 for 循环][i for i in range_1_10_ _ _ for]  
4.输出列表：

#1.输出为一行
    >>> print(li)
    [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]]
    
    #2.输出为多行
    >>> for i in range(n):
    	print(li[i])
    
    	
    [1]
    [1, 1]
    [1, 2, 1]
    [1, 3, 3, 1]
    
    #3.省去逗号、括号等符号
    >>> for i in range(n):
    	print(*li[i])
    
    	
    1
    1 1
    1 2 1
    1 3 3 1
    
    #4.省去逗号、括号等符号※
    >>>for i in range(n):
       print(" ".join(map(str,li[i])))
        
            
    1
    1 1
    1 2 1
    1 3 3 1
    """
    疑问：li[i]字符化后应该只是去掉大括号，4的print难道不是每行用“ ”连接吗？
    1
    1，1
    1, 2, 1
    1, 3, 3, 1
    """

源码

n = int(input())
    # 创建二位数组
    li =[[] for i in range(n)]
    
    for i in range(n):
        for j in range(n):
            if j == 0:
                li[i].append(1)
            elif i>j:
                 li[i].append(li[i-1][j-1]+li[i-1][j])
            elif i==j:
                li[i].append(1)
                
    for i in range(n):
            print(" ".join(map(str,li[i])))

## 10.查找整数 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。  
> 输入格式  
> 第一行包含一个整数n。  
> 第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。  
> 第三行包含一个整数a，为待查找的数。  
> 输出格式  
> 如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。  
> 样例输入  
> 6  
> 1 9 4 8 3 9  
> 9  
> 样例输出  
> 2  
> 数据规模和约定  
> 1 <= n <= 1000。

注意：如果a在数列中出现了，输出它第一次出现的位置(**位置从1开始编号**)，**否则输出-1**。要注意遍历时从1开始，否则可能扣分。

#字符串转化为列表
    li1=input().split()#单行读入含有一个空格的字符串
    li2=list(map(int,input().split()))#单行读入用空格隔开的整数

源码

re = -1
    n = int(input())
    li = input().split()       
    d = input()
    for i in range(n):
        if li[i] == d:
              re = i+1
              break
    print(re)

## 11.数列特征 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 给出n个数，找出这n个数的最大值，最小值，和。  
> 输入格式  
> 第一行为整数n，表示数的个数。  
> 第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。  
> 输出格式  
> 输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。  
> 样例输入  
> 5  
> 1 3 -2 4 5  
> 样例输出  
> 5  
> \-2  
> 11  
> 数据规模和约定  
> 1 <= n <= 10000。

源码

n = int(input())
    str_sp = list(map(int,input().split()))
    print(max(str_sp))
    print(min(str_sp))
    print(sum(str_sp))

## 12.字母图形 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 利用字母可以组成一些美丽的图形，下面给出了一个例子：  
> ABCDEFG  
> BABCDEF  
> CBABCDE  
> DCBABCD  
> EDCBABC  
> 这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。  
> 输入格式  
> 输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。  
> 输出格式  
> 输出n行，每个m个字符，为你的图形。  
> 样例输入  
> 5 7  
> 样例输出  
> ABCDEFG  
> BABCDEF  
> CBABCDE  
> DCBABCD  
> EDCBABC  
> 数据规模和约定  
> 1 <= n <= 10000。

拆分成两部分前逆序部分rear和后顺序部分front  
规律：word = words\[i:0:-1\]+words\[0,m-i\]  
知识点：  
1.[Python中的for i in range（range()函数的for循环）如何使用，详细介绍][Python_for i in range_range_for]  
2.[python之字符串逆序][python 4]  
3.倒叙输出

#打印输出10,9,8,7,6,5,4,3,2,1,0
    for i in range(10, -1, -1):
        print(i)

源码

words = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    n,m = map(int,input().split())    #  n行m列
    for i in range(n):
        word = words[i:0:-1]+words[0:m-i]	#  rear+front
        print(word[0:m])
        #如果输出为print(word)则部分错误

## 13.01字串 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：  
> 00000  
> 00001  
> 00010  
> 00011  
> 00100  
> 请按从小到大的顺序输出这32种01串。  
> 输入格式  
> 本试题没有输入。  
> 输出格式  
> 输出32行，按从小到大的顺序每行一个长度为5的01串。  
> 样例输出  
> 00000  
> 00001  
> 00010  
> 00011

知识点：  
[Python字符串的zfill函数][Python_zfill]  
源码

for i in range(1,33):
        print(bin(i)[2:].zfill(5))

## 14.闰年判断 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 给定一个年份，判断这一年是不是闰年。  
> 当以下情况之一满足时，这一年是闰年：  
> 1.年份是4的倍数而不是100的倍数；  
> 2.年份是400的倍数。  
> 其他的年份都不是闰年。  
> 输入格式  
> 输入包含一个整数y，表示当前的年份。  
> 输出格式  
> 输出一行，如果给定的年份是闰年，则输出yes，否则输出no。（说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。）  
> 样例输入  
> 2013  
> 样例输出  
> no  
> 数据规模与约定  
> 1990 <= y <= 2050。

知识点：  
比较级：and>or>not

源码

year = int(input())
    if 1990<=year<=2050:
        if year%4==0 and year%100!=0 or year%400==0:
            print("yes")
        else:
            print("no")

## 15.Fibonacci数列 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。  
> 当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。  
> 输入格式  
> 输入包含一个整数n。  
> 输出格式  
> 输出一行，包含一个整数，表示Fn除以10007的余数。  
> 样例输入  
> 10  
> 样例输出  
> 55  
> 数据规模和约定  
> 1 <= n <= 1,000,000。

知识点：  
str(li\[-1:\])输出的是字符串\[num\]，要输出num，将其转为字符串再使用切片访问\[1:-1\]从1访问到-1（下标从0开始，左闭右开区间，\[1：-1\] 代表从第二位数到倒数第二位数）；

例如输出\[55\]，两个5代表两个字符，\[1：-1\]即为55

盲点：内存超限因哪般？

源码

n = int(input())
    li=[0,1,1]
    for i in range(3,n+1):
         li.append((li[i-1]+li[i-2])%10007)
    print(str(li[-1:])[1:-1])
    #print(int(str(li[n])%10007)显示内存超限

## 16.圆的面积 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 给定圆的半径r，求圆的面积。  
> 输入格式  
> 输入包含一个整数r，表示圆的半径。  
> 输出格式  
> 输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。  
> 样例输入  
> 4  
> 样例输出  
> 50.2654825  
> 数据规模和约定  
> 1 <= r <= 10000。

知识点:  
1.[Python的format用法详解][Python_format]  
2.[python中math模块的使用方法][python_math]  
3.python中的两个常数pi和e的调用：  
import math  
math.pi  
math.e

重点截取：

#正号表示正数
    print("{:+2f}".format(3.14))
    #+3.140000
    print("{:-2f}".format(-1))
    #-1.000000
    #不带小数的
    print("{:.0f}".format(3.23123131))
    #3
    #以逗号为分隔符的
    print("{:,}".format(100000))
    #100,000
    #表示一个百分比
    print("{:.2%}".format(0.25))
    #25%

#将数字转换成二进制
    
    s = "{:b}".format(8)
    print(s) # 1000
    1
    2
    
    #将数字转换成八进制
    
    s = "{:o}".format(8)
    print(s) # 10
    1
    2
    #将数字转换成十六进制
    
    s = "{:X}".format(12)
    print(s) # C

源码

import math
    r = int(input())
    if 1<=r<=10000:
      s = math.pi*r*r
      print("{:.7f}".format(s))

## 17.序列求和 ##

> 资源限制  
> Python时间限制：5.0s  
> 问题描述  
> 求1+2+3+…+n的值。  
> 输入格式  
> 输入包括一个整数n。  
> 输出格式  
> 输出一行，包括一个整数，表示1+2+3+…+n的值。  
> 样例输入  
> 4  
> 样例输出  
> 10  
> 数据规模和约定  
> 1 <= n <= 1,000,000,000。  
> 说明：请注意这里的数据规模。  
> 本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。  
> 本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。  
> 如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。

知识点：  
注意输出整数可以使用"\{:.0f\}".format(x），输出0位小数。

源码

n = int(input())
    print("{:.0f}".format((1+n)*n/2))

[Python]: https://blog.csdn.net/Insight__/article/details/128561990
[python_input]: https://blog.csdn.net/goodgoodstudy___/article/details/123043590
[python_map]: https://blog.csdn.net/quanlingtu1272/article/details/95482253
[Python lambda]: https://zhuanlan.zhihu.com/p/56100507
[Lambda_Pythonic]: https://www.yuanrenxue.cn/python/python-lambda-usage.html
[Python_split]: https://blog.csdn.net/weixin_44793743/article/details/126572303
[Python_split 1]: https://www.jb51.net/article/63592.htm
[Python_join]: https://cloud.tencent.com/developer/article/1694327
[Python sorted_]: https://blog.csdn.net/XreqcxoKiss/article/details/108637403
[Python_sorted]: https://blog.csdn.net/liujingwei8610/article/details/121299626
[Python_sorted 1]: https://blog.csdn.net/chaojishuike/article/details/124049419
[python]: https://blog.csdn.net/weixin_45659364/article/details/116501695
[python 1]: https://blog.csdn.net/qq_51184727/article/details/125664852
[Python_Python]: https://blog.csdn.net/weixin_43896318/article/details/102619098
[python 2]: https://blog.csdn.net/zhangyi0626/article/details/122779595
[Python 1]: https://blog.csdn.net/qq_44186838/article/details/122742758
[_ _and or not]: https://www.runoob.com/python/python-operators.html#ysf4
[python 3]: https://blog.csdn.net/weixin_42105882/article/details/127028721
[Python ------]: https://blog.csdn.net/qq_23900685/article/details/86769660
[i for i in range_1_10_ _ _ for]: https://blog.csdn.net/qq_36759224/article/details/104724999
[Python_for i in range_range_for]: https://blog.csdn.net/hanhanwanghaha/article/details/105901052
[python 4]: https://blog.csdn.net/weixin_41980474/article/details/80065652
[Python_zfill]: https://blog.csdn.net/m0_48978908/article/details/119189964
[Python_format]: https://blog.csdn.net/qq_45726327/article/details/115042863
[python_math]: https://blog.csdn.net/lijiahong2012/article/details/52416400?biz_id=102&utm_term=python%E4%B8%ADmath.factorial&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-52416400&spm=1018.2118.3001.4449