蓝桥杯-第九届蓝桥杯C语言A组/B组/C组-Python题解_python蓝桥杯的abc组

#等比数列求和，然后约分
temp=pow(2,20)
a=2*(temp-1)
b=temp
 
#求最大公约数
def gcd(a,b):
    return gcd(b,a%b) if b!=0 else a
 
number=gcd(a,b)
print(str(a//number)+'/'+str(b//number))

 

#判断闰年
def isLeapYear(n):
    if (n%4==0 and n%100!=0) or (n%400==0):
        return True
    return False
 
#计算一共有多少天
total_day=0
for i in range(1901,2001):
    if isLeapYear(i):
        total_day+=366
    else:
        total_day+=365
 
#计算一共有多少周,就有多少个星期一
print(total_day//7)

 

matrix=[[0]*10 for i in range(10)]
for i in range(10):
    matrix[i]=list(map(int,input().split()))
 
sum=1
#求乘积
for i in range(10):
    for j in range(10):
        sum*=matrix[i][j]
#求sum末尾有多少个0
ans=0
while sum!=0:
    a=sum%10
    if a==0:
        ans+=1
        sum//=10
    else:
        break
 
print(ans)

 

#数字的3^i*5^j*7^k分解
count=0
n=59084709587505
 
for i in range(30):
    for j in range(30):
        for k in range(30):
            if pow(3,i)*pow(5,j)*pow(7,k)<=n:
                count+=1
#排除i=j=k=0情况              
print(count-1)

标题：航班时间

【问题背景】

小h前往美国参加了蓝桥杯国际赛。小h的女朋友发现小h上午十点出发，上午十二点到达美国，于是感叹到“现在飞机飞得真快，两小时就能到美国了”。

小h对超音速飞行感到十分恐惧。仔细观察后发现飞机的起降时间都是当地时间。由于北京和美国东部有12小时时差，故飞机总共需要14小时的飞行时间。

不久后小h的女朋友去中东交换。小h并不知道中东与北京的时差。但是小h得到了女朋友来回航班的起降时间。小h想知道女朋友的航班飞行时间是多少。

【问题描述】

对于一个可能跨时区的航班，给定来回程的起降时间。假设飞机来回飞行时间相同，求飞机的飞行时间。

【输入格式】

从标准输入读入数据。

一个输入包含多组数据。

输入第一行为一个正整数T，表示输入数据组数。

每组数据包含两行，第一行为去程的 起降 时间，第二行为回程的 起降 时间。

起降时间的格式如下

h1:m1:s1 h2:m2:s2

或

h1:m1:s1 h3:m3:s3 (+1)

或

h1:m1:s1 h4:m4:s4 (+2)

表示该航班在当地时间h1时m1分s1秒起飞，

第一种格式表示在当地时间 当日 h2时m2分s2秒降落

第二种格式表示在当地时间 次日 h3时m3分s3秒降落。

第三种格式表示在当地时间 第三天 h4时m4分s4秒降落。

对于此题目中的所有以 h:m:s 形式给出的时间, 保证 ( 0<=h<=23, 0<=m,s<=59 ).

【输出格式】

输出到标准输出。

对于每一组数据输出一行一个时间hh:mm:ss，表示飞行时间为hh小时mm分ss秒。

注意，当时间为一位数时，要补齐前导零。如三小时四分五秒应写为03:04:05。

【样例输入】

3

17:48:19 21:57:24

11:05:18 15:14:23

17:21:07 00:31:46 (+1)

23:02:41 16:13:20 (+1)

10:19:19 20:41:24

22:19:04 16:41:09 (+1)

【样例输出】

04:09:05

12:10:39

14:22:05

#设输入的每组数据为
#a b
#c d
#设航班飞行时间是Time,时差是T
#则有：
#a+Time=b-T
#c+Time=d+T
#联立解Time
#处理时间一般是转换为秒方便计算
 
#分割读入的字符串
import re
#数据组数
t=int(input())
#去程和回程总时间
total_time=0
for i in range(t):
    total_time=0
    string=input()
    #去程起降时间
    time_list=re.split('\s+|:',string)
 
    #计算去程所用秒数
    #当日降落
    if len(time_list)==6:
        total_time+=int(time_list[3])*3600+int(time_list[4])*60+int(time_list[5])-(int(time_list[0])*3600+int(time_list[1])*60+int(time_list[2]))
    #非当日降落
    else:
        total_time+=int(time_list[6][2])*24*3600+int(time_list[3])*3600+int(time_list[4])*60+int(time_list[5])-(int(time_list[0])*3600+int(time_list[1])*60+int(time_list[2]))
 
    #回程起降时间
    string=input()
    time_list=re.split('\s+|:',string)
    if len(time_list)==6:
        total_time+=int(time_list[3])*3600+int(time_list[4])*60+int(time_list[5])-(int(time_list[0])*3600+int(time_list[1])*60+int(time_list[2]))
    else:
        total_time+=int(time_list[6][2])*24*3600+int(time_list[3])*3600+int(time_list[4])*60+int(time_list[5])-(int(time_list[0])*3600+int(time_list[1])*60+int(time_list[2]))
 
    total_time//=2
    #输出结果
    ans=''
    #注意python中的除法
    h=total_time//3600
    m=total_time//60%60
    s=total_time%60
 
    if h<10:
        ans+='0'
        ans+=str(h)
        ans+=':'
    else:
        ans+=str(h)
        ans+=':'
 
    if m<10:
        ans+='0'
        ans+=str(m)
        ans+=':'
    else:
        ans+=str(m)
        ans+=':'
 
    if s<10:
        ans+='0'
        ans+=str(s)
    else:
        ans+=str(s)
    
    print(ans)

标题：三体攻击

【题目描述】

三体人将对地球发起攻击。为了抵御攻击，地球人派出了 A × B × C 艘战舰，在太空中排成一个 A 层 B 行 C 列的立方体。其中，第 i 层第 j 行第 k 列的战舰（记为战舰 (i, j, k)）的生命值为 d(i, j, k)。

三体人将会对地球发起 m 轮“立方体攻击”，每次攻击会对一个小立方体中的所有战舰都造成相同的伤害。具体地，第 t 轮攻击用 7 个参数 lat, rat, lbt, rbt, lct, rct, ht 描述；

所有满足 i ∈ [lat, rat],j ∈ [lbt, rbt],k ∈ [lct, rct] 的战舰 (i, j, k) 会受到 ht 的伤害。如果一个战舰累计受到的总伤害超过其防御力，那么这个战舰会爆炸。

地球指挥官希望你能告诉他，第一艘爆炸的战舰是在哪一轮攻击后爆炸的。

【输入格式】

从标准输入读入数据。

第一行包括 4 个正整数 A, B, C, m；

第二行包含 A × B × C 个整数，其中第 ((i − 1)×B + (j − 1)) × C + (k − 1)+1 个数为 d(i, j, k)；

第 3 到第 m + 2 行中，第 (t − 2) 行包含 7 个正整数 lat, rat, lbt, rbt, lct, rct, ht。

【输出格式】

输出到标准输出。

输出第一个爆炸的战舰是在哪一轮攻击后爆炸的。保证一定存在这样的战舰。

【样例输入】

2 2 2 3

1 1 1 1 1 1 1 1

1 2 1 2 1 1 1

1 1 1 2 1 2 1

1 1 1 1 1 1 2

【样例输出】

2

【样例解释】

在第 2 轮攻击后，战舰 (1,1,1) 总共受到了 2 点伤害，超出其防御力导致爆炸。

#按照题目进行模拟
A,B,C,m=map(int,input().split())
#战舰生命值列表
life_list=list(map(int,input().split()))
#战舰生命值和编号映射
d={}
 
#建立生命值和编号映射
for i in range(1,A+1):
    for j in range(1,B+1):
        for k in range(1,C+1):
            d[(i,j,k)]=life_list[((i-1)*B+(j-1))*C+(k-1)]
 
print(d)
flag=False
#进行战舰攻击模拟
for times in range(1,m+1):
    number_list=list(map(int,input().split()))
    li=number_list[0]
    ri=number_list[1]
    lj=number_list[2]
    rj=number_list[3]
    lk=number_list[4]
    rk=number_list[5]
    #遍历战舰集合，进行生命值更新
    for key in d.keys():
        if li<=key[0]<=ri and lj<=key[1]<=rj and lk<=key[2]<=rk:
            d[key]-=number_list[6]
            #按照题意是生命值小于0算作爆炸
            if d[key]<0:
                print(times)
                flag=True
                break
    if flag:
        break

标题：倍数问题

【题目描述】

众所周知，小葱同学擅长计算，尤其擅长计算一个数是否是另外一个数的倍数。但小葱只擅长两个数的情况，当有很多个数之后就会比较苦恼。现在小葱给了你 n 个数，希望你从这 n 个数中找到三个数，使得这三个数的和是 K 的倍数，且这个和最大。数据保证一定有解。

【输入格式】

从标准输入读入数据。

第一行包括 2 个正整数 n, K。

第二行 n 个正整数，代表给定的 n 个数。

【输出格式】

输出到标准输出。

输出一行一个整数代表所求的和。

【样例入】

4 3

1 2 3 4

【样例输出】

9

【样例解释】

选择2、3、4。

n,k=map(int,input().split())
number_list=list(map(int,input().split()))
 
#最大值
max_value=-10**10
#当前数字是否已经被遍历
has_checked=[]
#深度优先搜索
def dfs(temp_sum,count):
    global max_value
    if count==3:
        max_value=max(max_value,temp_sum)
        return
    for i in range(len(number_list)):
        if i not in has_checked:
            has_checked.append(i)
            dfs(temp_sum+number_list[i],count+1)
            #试探结束后回退，进行下一次试探
            has_checked.remove(i)
dfs(0,0)
print(max_value)

标题：第几天

2000年的1月1日，是那一年的第1天。

那么，2000年的5月4日，是那一年的第几天？

：31+29+31+30+4

标题：明码

汉字的字形存在于字库中，即便在今天，16点阵的字库也仍然使用广泛。

16点阵的字库把每个汉字看成是16x16个像素信息。并把这些信息记录在字节中。

一个字节可以存储8位信息，用32个字节就可以存一个汉字的字形了。

把每个字节转为2进制表示，1表示墨迹，0表示底色。每行2个字节，

一共16行，布局是：

第1字节，第2字节

第3字节，第4字节

....

第31字节, 第32字节

这道题目是给你一段多个汉字组成的信息，每个汉字用32个字节表示，这里给出了字节作为有符号整数的值。

题目的要求隐藏在这些信息中。你的任务是复原这些汉字的字形，从中看出题目的要求，并根据要求填写答案。

这段信息是（一共10个汉字）：

4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0

16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16

4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0

0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4

4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64

16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128

0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0

2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0

1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0

0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0

#每一行代表了一个汉字
#每一行有32个数字，代表了32个字节
#两个字节排成一行
#将每个数字转换为二进制补码，
#如果是0输出空格
#是1输出*
#最终可显示所有的汉字图形
n=10
m=32
matrix=[[0]*m for i in range(n)]
 
#将十进制数字转换为8位二进制补码
def intToBin8(i):
    return (bin(((1 << 8) - 1) & i)[2:]).zfill(8)
 
for i in range(n):
    matrix[i]=list(map(int,input().split()))
    
for i in range(n):
    count=0
    for j in range(m):
        #按照字节处理
        part=intToBin8(matrix[i][j])
        for item in part:
            if item=='0':
                print('  ',end='')
            if item=='1':
                print('* ',end='')
        count+=1
        #两个字节为一层
        if count%2==0:
            print()
    #处理完了一个汉字
    print()

标题：测试次数

x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。

各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。

x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。

如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。

特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。

如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n

为了减少测试次数，从每个厂家抽样3部手机参加测试。

某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？

请填写这个最多测试次数。

注意：需要填写的是一个整数，不要填写任何多余内容。

#动态规划
dp=[[0]*1001 for i in range(4)]
#dp[i][j]代表共有i部手机，j层的最坏运气下最多测试次数
#先初始化为层数
for i in range(1,4):
    for j in range(1,1001):
        dp[i][j]=j
#在第k层摔手机分为两种情况
#1.没有摔坏，向楼上走，去剩余的j-k层测试,则dp[i][j]=dp[i][j-k]+1,+1是因为此次没有摔坏
#2.摔坏了，向楼下走，手机数量-1，去剩下的k-1层测试 dp[i][j]=dp[i-1][k-1]
#综上在第k层dp[i][j]=max(dp[i][j-k]+1,dp[i-1][k-1]),max是保证两种情况都能发生
#则总的转移方程为dp[i][j]=min(dp[i][j],max(dp[i][j-k]+1,dp[i-1][k-1])),1<=k<j,k取
#不同的值代表在不同的层进行摔手机尝试
for i in range(2,4):
    for j in range(1,1001):
        for k in range(1,j):
            dp[i][j]=min(dp[i][j],max(dp[i][j-k]+1,dp[i-1][k-1]))
 
print(dp[3][1000])

 

标题：递增三元组

给定三个整数数组

A = [A1, A2, ... AN],

B = [B1, B2, ... BN],

C = [C1, C2, ... CN]，

请你统计有多少个三元组(i, j, k) 满足：

1. 1 <= i, j, k <= N

2. Ai < Bj < Ck

【输入格式】

第一行包含一个整数N。

第二行包含N个整数A1, A2, ... AN。

第三行包含N个整数B1, B2, ... BN。

第四行包含N个整数C1, C2, ... CN。

对于30%的数据，1 <= N <= 100

对于60%的数据，1 <= N <= 1000

对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000

【输出格式】

一个整数表示答案

【样例输入】

3

1 1 1

2 2 2

3 3 3

【样例输出】

27

ans=0
number_list1=[]
number_list2=[]
number_list3=[]
n=int(input())
number_list1=list(map(int,input().split()))
number_list2=list(map(int,input().split()))
number_list3=list(map(int,input().split()))
for i in range(n):
    for j in range(n):
        for k in range(n):
            if number_list1[i]<number_list2[j]<number_list3[k]:
                ans+=1
 
print(ans)

标题：日志统计

小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有N行。其中每一行的格式是：

ts id

表示在ts时刻编号id的帖子收到一个"赞"。

现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是"热帖"。

具体来说，如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞，该帖就曾是"热帖"。

给定日志，请你帮助小明统计出所有曾是"热帖"的帖子编号。

【输入格式】

第一行包含三个整数N、D和K。

以下N行每行一条日志，包含两个整数ts和id。

对于50%的数据，1 <= K <= N <= 1000

对于100%的数据，1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000

【输出格式】

按从小到大的顺序输出热帖id。每个id一行。

【输入样例】

7 10 2

0 1

0 10

10 10

10 1

9 1

100 3

100 3

【输出样例】

1

3

#日志id集合
id_set=set()
#每个id的点赞时间
id_time_list=[[]*100001 for i in range(100001)]
n,d,k=map(int,input().split())
#判断id的日志是否是热帖
def isHot(id):
    global n,d,k
    total_number=len(id_time_list[id])
    if total_number<k:
        return False
    id_time_list[id].sort()
    #sum是时间[l,r)内的点赞数量
    l,r,sum=0,0,0
    while l<=r<total_number:
        sum+=1
        if sum>=k:
            if id_time_list[id][r]<d+id_time_list[id][l]:
                #点赞数量大于k，并且时间间隔小于d
                return True
            else:
                #取下一个时间段
                sum-=1
                l+=1
        r+=1
 
for i in range(n):
    time,id=map(int,input().split())
    id_set.add(id)
    id_time_list[id].append(time)
 
for i in id_set:
    if isHot(i):
        print(i)

标题：哪天返回

小明被不明势力劫持。后莫名其妙被扔到x星站再无问津。小明得知每天都有飞船飞往地球，但需要108元的船票，而他却身无分文。

他决定在x星战打工。好心的老板答应包食宿，第1天给他1元钱。

并且，以后的每一天都比前一天多2元钱，直到他有足够的钱买票。

请计算一下，小明在第几天就能凑够108元，返回地球。

要求提交的是一个整数，表示第几天。请不要提交任何多余的内容。

day=1
money=1
sum=1
while sum<108:
    money+=2
    day+=1
    sum+=money
print(day)

标题：猴子分香蕉

5只猴子是好朋友，在海边的椰子树上睡着了。这期间，有商船把一大堆香蕉忘记在沙滩上离去。

第1只猴子醒来，把香蕉均分成5堆，还剩下1个，就吃掉并把自己的一份藏起来继续睡觉。

第2只猴子醒来，重新把香蕉均分成5堆，还剩下2个，就吃掉并把自己的一份藏起来继续睡觉。

第3只猴子醒来，重新把香蕉均分成5堆，还剩下3个，就吃掉并把自己的一份藏起来继续睡觉。

第4只猴子醒来，重新把香蕉均分成5堆，还剩下4个，就吃掉并把自己的一份藏起来继续睡觉。

第5只猴子醒来，重新把香蕉均分成5堆，哈哈，正好不剩！

请计算一开始最少有多少个香蕉。

需要提交的是一个整数，不要填写任何多余的内容。

#香蕉的数量，迭代尝试解
banana_number=5
monkey1,monkey2,monkey3,monkey4,monkey5=0,0,0,0,0
#寻找满足条件的解
while True:
    banana_number+=1
    monkey1=banana_number
    if monkey1%5==1 and monkey1>1:
        monkey2=(monkey1-1)//5*4
        if monkey2%5==2 and monkey2>2:
            monkey3=(monkey2-2)//5*4
            if monkey3%5==3 and monkey3>3:
                monkey4=(monkey3-3)//5*4
                if monkey4%5==4 and monkey4>4:
                    monkey5=(monkey4-4)//5*4
                    if monkey5%5==0 and monkey5>0:
                        break
 
print(banana_number)

标题：次数差

x星球有26只球队，分别用a~z的26个字母代表。他们总是不停地比赛。

在某一赛段，哪个球队获胜了，就记录下代表它的字母，这样就形成一个长长的串。

国王总是询问：获胜次数最多的和获胜次数最少的有多大差距？（当然，他不关心那些一次也没获胜的，认为他们在怠工罢了）

输入，一个串，表示球队获胜情况（保证串的长度<1000）

要求输出一个数字，表示出现次数最多的字母比出现次数最少的字母多了多少次。

比如：

输入：

abaabcaa

则程序应该输出：

4

解释：a出现5次，最多；c出现1次，最少。5-1=4

再比如：

输入：

bbccccddaaaacccc

程序应该输出：

6

char_set={}
string=input()
for i in string:
    if i not in char_set:
        char_set[i]=1
    else:
        char_set[i]+=1
max_value=-10**10
min_value=10**10
for item in char_set.values():
    if item>max_value:
        max_value=item
    if item<min_value:
        min_value=item
print(max_value-min_value)