python蓝桥杯基础练习vip17题

小咪咪 2024-03-24 14:44 65阅读 0赞

> 可学：  
> [Python蓝桥杯易错点整理和心得总结【一】][Python]  
> [2021年第十二届蓝桥杯大赛省赛python大学组真题加解析（更新中）][2021_python]  
> [\[蓝桥杯Python\]算法练习、算法基础、算法训练、算法模板（持续更新）][Python 1]  
> 必学：  
> [蓝桥杯试题及答案分享(Python版)][Python 2]  
> 免费提交vip练习题的网站：  
> [C语言网站][C]（题目搜索处查找vip题目提交即可）  
> 备注：4，6，8，11，14不会

## 1.阶乘计算 ##

> 输入一个正整数n，输出n!的值。  
> 其中n!=123…n。  
> 算法描述  
> n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A\[0\]表示a的个位，A\[1\]表示a的十位，  
> 依次类推。  
> 将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。  
> 首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。  
> 输入  
> 输入包含一个正整数n，n< =1000。  
> 输出  
> 输出n!的准确值。  
> 样例输入  
> 10  
> 样例输出  
> 3628800

知识点：  
1.[python中math模块的使用方法][python_math]  
2.[python 高精度整数、高精度浮点数及其相关运算][python]

import math
    print(math.factorial(int(input())))

n=int(input())
    ans=1
    for i in range(1,n+1):
        ans*=i
    print(ans)

按所要求的思路解决的较为复杂，暂置。

n=int(input())
    L=[1]#赋初值，不然无法启动
    def loop(n):
        global L
        for i in range(len(L)):#正常乘法，每位各自乘
            L[i]*=n
        for i in range(len(L)-1):#进位，但是首位进位不在此列
            L[i+1]+=int(L[i]/10)
            L[i]=L[i]%10
        L1=list(str(L[-1]))#分解首项
        L.pop()#删除首项
        for i in range(len(L1)-1,-1,-1):#倒序归入原序列，注意倒叙！！！
            L.append(int(L1[i]))
    for i in range(2,n+1):#n！定义
        loop(i)
    for i in range(len(L)):#转化形式
        L[i]=str(L[i])
    print(''.join(L[::-1]))#join（）输出

## 2. 高精度加法 ##

> 题目描述  
> 输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。  
> 算法描述  
> 由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。  
> 定义一个数组A，A\[0\]用于存储a的个位，A\[1\]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。  
> 计算c = a + b的时候，首先将A\[0\]与B\[0\]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C\[0\]，即C\[0\]等于(A\[0\]+B\[0\])%10。然后计算A\[1\]与B\[1\]相加，这时还应将低位进上来的值r也加起来，即C\[1\]应该是A\[1\]、B\[1\]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C\[1\]中。依此类推，即可求出C的所有位。  
> 最后将C输出即可。  
> 输入格式  
> 输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。  
> 输出格式  
> 输出一行，表示a + b的值。  
> 样例输入  
> 20100122201001221234567890  
> 2010012220100122  
> 样例输出  
> 20100122203011233454668012

知识点：  
python3中没有long等数据类型，其本身已具有傅里叶乘法等优化算法的功能，int类型具有无限精度，所以可以直接求解。

源码

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

## 3. Huffuman树 ##

> 时间限制: 1s 内存限制: 128MB  
> 题目描述  
> Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。  
> 给出一列数\{pi\}=\{p0, p1, …, pn-1\}，用这列数构造Huffman树的过程如下：
> 
> 1.找到\{pi\}中最小的两个数，设为pa和pb，将pa和pb从\{pi\}中删除掉，然后将它们的和加入到\{pi\}中。这个过程的费用记为pa + pb。  
> 2.重复步骤1，直到\{pi\}中只剩下一个数。 在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。 本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。 例如，对于数列\{pi\}=\{5, 3, 8, 2,  
> 9\}，Huffman树的构造过程如下：
> 
> 1.找到\{5, 3, 8, 2, 9\}中最小的两个数，分别是2和3，从\{pi\}中删除它们并将和5加入，得到\{5, 8, 9, 5\}，费用为5。  
> 2.找到\{5, 8, 9, 5\}中最小的两个数，分别是5和5，从\{pi\}中删除它们并将和10加入，得到\{8, 9, 10\}，费用为10。  
> 3.找到\{8, 9, 10\}中最小的两个数，分别是8和9，从\{pi\}中删除它们并将和17加入，得到\{10, 17\}，费用为17。  
> 4.找到\{10, 17\}中最小的两个数，分别是10和17，从\{pi\}中删除它们并将和27加入，得到\{27\}，费用为27。
> 
> 现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。
> 
> 输入格式  
> 输入的第一行包含一个正整数n（n<  
> =100）。 接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。  
> 输出格式  
> 输出用这些数构造Huffman树的总费用。  
> 样例输入  
> 5 5 3 8 2 9  
> 样例输出  
> 59

知识点：  
1.[【Python】Python列表基本操作][Python_Python]  
2.L\[-2\]：从右侧开始读取倒数第二个元素

源码

n = int(input())
    li = list(map(int,input().split()))
    sum = 0
    #n个数，最后只留一位,要进行n-1次循环
    for i in range(n-1):
              li.sort()#对列表进行排序
              li.append(li[0]+li[1])#将最小的两位数和加到列表末尾
              sum+=li[0]+li[1]
              #pop(0)删除列表的第一位，删除最小数后，次小数从第二位移动到第一位，故再次进行pop(0)
              li.pop(0)
              li.pop(0)
    print(sum)

n = int(input())
    l = list(map(int, input().split()))
    sum = 0
    while (len(l)>1):
        nowsum = l.pop(l.index(min(l))) + l.pop(l.index(min(l)))
        l.append(nowsum)
        sum+=nowsum
    print(sum)

## 4.2n皇后问题 ##

[https://blog.dotcpp.com/a/72869][https_blog.dotcpp.com_a_72869]

## 5.报时助手 ##

> 题目描述  
> 给定当前的时间，请用英文的读法将它读出来。  
> 时间用时h和分m表示，在英文的读法中，读一个时间的方法是：  
> 如果m为0，则将时读出来，然后加上“o’clock”，如3:00读作“three o’clock”。  
> 如果m不为0，则将时读出来，然后将分读出来，如5:30读作“five thirty”。  
> 时和分的读法使用的是英文数字的读法，其中0~20读作：  
> 0:zero, 1: one, 2:two, 3:three, 4:four, 5:five, 6:six, 7:seven, 8:eight, 9:nine, 10:ten, 11:eleven, 12:twelve, 13:thirteen, 14:fourteen, 15:fifteen, 16:sixteen, 17:seventeen, 18:eighteen, 19:nineteen, 20:twenty。  
> 30读作thirty，40读作forty，50读作fifty。  
> 对于大于20小于60的数字，首先读整十的数，然后再加上个位数。如31首先读30再加1的读法，读作“thirty one”。  
> 按上面的规则21:54读作“twenty one fifty four”，9:07读作“nine seven”，0:15读作“zero fifteen”。  
> 输入格式  
> 输入包含两个非负整数h和m，表示时间的时和分。非零的数字前没有前导0。h小于24，m小于60。  
> 输出格式  
> 输出时间时刻的英文。  
> 样例输入  
> 0 15  
> 样例输出  
> zero fifteen

源码：

time_dict={
        '0':'zero',  '1':  'one',  '2':'two',  '3':'three',  '4':'four','5':'five',  '6':'six',  '7':'seven',  '8':'eight',  '9':'nine',  '10':'ten',   '11':'eleven',  '12':'twelve',  '13':'thirteen',  '14':'fourteen',  '15':'fifteen',  '16':'sixteen',  '17':'seventeen',  '18':'eighteen',  '19':'nineteen',  '20':'twenty','30':'thirty','40':'forty','50':'fifty'}
    h,m=input().split()
    def turn_english(num):
        if num not in time_dict:
            return time_dict[num[0]+'0']+' '+time_dict[num[1]]
        else:
            return time_dict[num]
    if m=='0':
        print(turn_english(h)+' '+"o'clock")
    else:
        print(turn_english(h)+' '+turn_english(m))

## 6.回型取数 ##

[https://blog.dotcpp.com/a/84419][https_blog.dotcpp.com_a_84419]

## 7. 龟兔赛跑预测 ##

> 题目描述  
> 话说这个世界上有各种各样的兔子和乌龟，但是 研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔 子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先t米或以 上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。  
> 然而有些比赛相当漫长，全程观看会耗费大量时间，而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1（表示每秒兔子能跑v1 米），乌龟的速度v2，以及兔子对应的t，s值，以及赛道的长度l——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找 到了你——清华大学计算机系的高才生——请求帮助，请你写一个程序，对于输入的一场比赛的数据v1，v2，t，s，l，预测该场比赛的结果。  
> 输入格式  
> 输入只有一行，包含用空格隔开的五个正整数v1，v2，t，s，l，其中(v1,v2< =100;t< =300;s< =10;l< =10000且为v1,v2的公倍数)  
> 输出格式  
> 输出包含两行，第一行输出比赛结果——一个大写字母“T”或“R”或“D”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。  
> 第二行输出一个正整数，表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。  
> 样例输入  
> 10 5 5 2 20  
> 样例输出  
> D  
> 4

关键点在于，兔子休息的s秒内，乌龟是否已经到达终点

源码

v1,v2,t,s,l = map(int, input().split())
    t2 = l/v2
    l1,l2,t1=0,0,0
    while l1<l and l2<l:
        l1+=v1
        l2+=v2
        t1+=1
        if l1-l2>=t and l1<l and l2<l:
            for j in range(s):
                l2+=v2
                t1+=1
                # 用if l2>=l：也可以
                if l2>=l or l1>=l:
                    break
    if l1==l2:
        print('D')
    if l1>l2:
        print('R')
    if l1<l2:
        print('T')
    print(t1)

## 8.芯片测试 ##

> 题目描述  
> 有n块芯片，有好有坏，已知好芯片比坏芯片多。  
> 每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。  
> 给出所有芯片的测试结果，问哪些芯片是好芯片。  
> 输入格式  
> 输入数据第一行为一个整数n，表示芯片个数。  
> 第二行到第n+1行为n\*n的一张表，每行n个数据。表中的每个数据为0或1，在这n行中的第i行第j列（1≤i, j≤n）的数据表示用第i块芯片测试第j块芯片时得到的测试结果，1表示好，0表示坏，i=j时一律为1（并不表示该芯片对本身的测试结果。芯片不能对本 身进行测试）。  
> （2≤n≤20）  
> 输出格式  
> 按从小到大的顺序输出所有好芯片的编号  
> 样例输入  
> 3  
> 1 0 1  
> 0 1 0  
> 1 0 1  
> 样例输出  
> 1 3

题解：[https://blog.dotcpp.com/a/82744][https_blog.dotcpp.com_a_82744]

## 9.FJ的字符串 ##

> 题目描述  
> FJ在沙盘上写了这样一些字符串：  
> A1 = “A”  
> A2 = “ABA”  
> A3 = “ABACABA”  
> A4 = “ABACABADABACABA”  
> … …  
> 你能找出其中的规律并写所有的数列AN吗？  
> 输入格式  
> 仅有一个数：N ≤ 26。  
> 输出格式  
> 请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。  
> 样例输入  
> 3  
> 样例输出  
> ABACABA

源码

n = int(input())
    result =""
    for i in range(n):
        result = result + chr(ord('A')+i) +result
    print(result)

## 10.Sine之舞 ##

> 题目描述  
> 最近FJ为他的奶牛们开设了数学分析课，FJ知道若要学好这门课，必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏，寓教于乐，提高奶牛们的计算能力。  
> 不妨设  
> An=sin(1–sin(2+sin(3–sin(4+…sin(n))…)  
> Sn=(…(A1+n)A2+n-1)A3+…+2)An+1  
> FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式，以方便奶牛们做题。  
> 输入格式  
> 仅有一个数：N<201。  
> 输出格式  
> 请输出相应的表达式Sn，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。  
> 样例输入  
> 3  
> 样例输出  
> ((sin(1)+3)sin(1-sin(2))+2)sin(1-sin(2+sin(3)))+1

源码：

n = int(input())
    def an(n):
        for i in range(1,n+1):
            print('sin(',end='')
            print(i,end='')
            if i != n:
                if i%2!=0:
                    print('-',end='')
                else:
                    print('+',end='')
        #循环右侧括号
        for i in range(1,n+1):
            print(')',end='')
        return ''
    def sn(n):
        for i in range(1,n):
            print('(',end='')
        for i in range(1,n+1):
            print(an(i),end='')
            print('+',end='')
            print(n-i+1,end='')
            if i!=n:
                print(')',end='')
    sn(n)

## 11.数的读法 ##

## 12.完美的代价 ##

> 题目描述  
> 回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。  
> 交换的定义是：交换两个相邻的字符  
> 例如mamad  
> 第一次交换 ad : mamda  
> 第二次交换 md : madma  
> 第三次交换 ma : madam (回文！完美！)  
> 输入格式  
> 第一行是一个整数N，表示接下来的字符串的长度(N < = 8000)  
> 第二行是一个字符串，长度为N.只包含小写字母  
> 输出格式  
> 如果可能，输出最少的交换次数。  
> 否则输出Impossible  
> 样例输入  
> 5  
> mamad  
> 样例输出  
> 3

## 13.矩形面积交 ##

> 题目描述  
> 平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。  
> 输入格式  
> 输入仅包含两行，每行描述一个矩形。  
> 在每行中，给出矩形的一对相对顶点的坐标，每个点的坐标都用两个绝对值不超过10^7的实数表示。  
> 输出格式  
> 输出仅包含一个实数，为交的面积，保留到小数后两位。  
> 样例输入  
> 1 1 3 3  
> 2 2 4 4  
> 样例输出  
> 1.00

源码  
[https://blog.dotcpp.com/a/73447][https_blog.dotcpp.com_a_73447]

xy1 = list(map(float,input().split()))
    xy2 = list(map(float,input().split()))
    rx = min(max(xy1[0],xy1[2]),max(xy2[0],xy2[2]))
    lx = max(min(xy1[0],xy1[2]),min(xy2[0],xy2[2]))
    uy = min(max(xy1[1],xy1[3]),max(xy2[1],xy2[3]))
    dy = max(min(xy1[1],xy1[3]),min(xy2[1],xy2[3]))
    w,h = rx-lx,uy-dy
    if w<=0.0 or h<=0.00:
        print("0.00")
    else:
        #print((str(w*h)+"00").split(".")[0]+"."+(str(w*h)+"00").split(".")[1][:2:])    不进位输出小数点后两位
        print("%.2f"%(w*h))

## 14.矩阵乘法 ##

[https://blog.dotcpp.com/a/77575][https_blog.dotcpp.com_a_77575]

## 15.分解质因数 ##

> 题目描述  
> 求出区间\[a,b\]中所有整数的质因数分解。  
> 提示  
> 先筛出所有素数，然后再分解。  
> 数据规模和约定  
> 输入格式  
> 输入两个整数a，b。  
> 2< =a< =b< =10000  
> 输出格式  
> 每行输出一个数的分解，形如k=a1 \* a2 \* a3…(a1< =a2< =a3…，k也是从小到大的)(具体可看样例)  
> 样例输入  
> 3 10  
> 样例输出  
> 3=3  
> 4=2 \* 2  
> 5=5  
> 6=2 \* 3  
> 7=7  
> 8=2 \* 2 \* 2  
> 9=3 \* 3  
> 10=2 \* 5

注意：\*和数字之间没有空格，这里只是为了显示出来“ \* "符号

源码：

def decprime(n):
        l = []
        print(n, "=", end='', sep='')
        while n!=1:
            for i in range(2, int(n+1)):
                if n%i==0:
                    l.append(i)
                    n = n/i
                    break
        for i in range(0, len(l)-1):
            print(l[i],'*',end='',sep='')
        print(l[-1])
    a,b = map(int,input().split())
    for j in range(a,b+1):
        decprime(j)

## 16.字符串对比 ##

> 题目描述  
> 给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：  
> 1：两个字符串长度不等。比如 Beijing 和 Hebei  
> 2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing  
> 3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing  
> 4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing  
> 编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。  
> 输入格式  
> 包括两行，每行都是一个字符串  
> 输出格式  
> 仅有一个数字，表明这两个字符串的关系编号  
> 样例输入  
> BEIjing  
> beiJing  
> 样例输出  
> 3

源码：

a = input()
    b = input()
    if  len(a) != len(b):
        print(1)
    elif a == b:
        print(2)
    elif len(a) == len(b) and a.lower() == b.lower():
        print(3)
    elif len(a) == len(b):
        print(4)

## 17.时间转换 ##

> 题目描述  
> 给定一个以秒为单位的时间t，要求用 “< H> :< M> :< S> ”的格式来表示这个时间。< H> 表示时间，< M> 表示分钟， 而< S> 表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。  
> 输入格式  
> 输入只有一行，是一个整数t（0< =t< =86399）。  
> 输出格式  
> 输出只有一行，是以“< H> :< M> :< S> ”的格式所表示的时间，不包括引号。  
> 样例输入  
> 5436  
> 样例输出  
> 1:30:36

源码：

n = int(input())
    print(str(n//3600)+":"+str(n%3600//60)+":"+str(n%60))

[Python]: https://blog.csdn.net/m0_62277756/article/details/123965964
[2021_python]: https://blog.csdn.net/dlz_yhn/article/details/123370170
[Python 1]: https://blog.csdn.net/Callme_TeacherPi/article/details/123330603
[Python 2]: https://blog.csdn.net/weixin_45377629/article/details/125220044
[C]: https://www.dotcpp.com/oj/problemset.php?page=1
[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
[python]: https://blog.csdn.net/qq_51184727/article/details/129971145
[Python_Python]: https://blog.csdn.net/weixin_43896318/article/details/102619098
[https_blog.dotcpp.com_a_72869]: https://blog.dotcpp.com/a/72869
[https_blog.dotcpp.com_a_84419]: https://blog.dotcpp.com/a/84419
[https_blog.dotcpp.com_a_82744]: https://blog.dotcpp.com/a/82744
[https_blog.dotcpp.com_a_73447]: https://blog.dotcpp.com/a/73447
[https_blog.dotcpp.com_a_77575]: https://blog.dotcpp.com/a/77575