devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

蓝桥杯-第十届蓝桥杯 C语言A组/B组/C组/研究生组-Python题解_python研究生组和a组题,有

作者：Monodyee | 2024-05-19 11:46:26

赞

踩

python研究生组和a组题,有

  1. #判断数字中是否含有2，0,1,9
  2. def has2019(n):
  3.     flag=False
  4.     while n!=0:
  5.         a=n%10
  6.         if a==2 or a==0 or a==1 or a==9:
  7.             flag=True
  8.             return flag
  9.         #注意python的除法机制
  10.         n//=10
  11.     return flag
  12.  
  13. sum=0
  14. for i in range(1,2019+1):
  15.     if has2019(i):
  16.         sum+=i**2
  17.  
  18. print(sum)

  1. #利用动态数组
  2. #不必申请过多空间
  3. item_list=[0 for i in range(4)]
  4. item_list[1]=1
  5. item_list[2]=1
  6. item_list[3]=1
  7. #计算每一项的值
  8. #因为每一项只和其前3项有关
  9. #计算之后需要更新列表元素值
  10. for i in range(4,20190324+1):
  11.     temp=sum(item_list[1:4])
  12.     #只需最后4位数
  13.     temp%=10000
  14.     #更新元素值
  15.     item_list[1]=item_list[2]
  16.     item_list[2]=item_list[3]
  17.     item_list[3]=temp
  18.  
  19. print(item_list[3])

 

 

  1. #读取迷宫地图
  2. file=open('E:\project_code\蓝桥杯\maze.txt','r')
  3. read_map=file.readlines()
  4. #迷宫中坐标和值的映射关系
  5. point_value_map={}
  6.  
  7. #建立迷宫
  8. #先在迷宫外面建墙，方便搜索迷宫
  9. for i in range(0,32):
  10.     point_value_map[(i,0)]='1'
  11.     point_value_map[(i,51)]='1'
  12. for i in range(0,52):
  13.     point_value_map[(0,i)]='1'
  14.     point_value_map[(31,i)]='1'
  15. x=1
  16. for line in read_map:
  17.     #读取到的迷宫每一行最后一个是\n换行符
  18.     for i in range(len(line)-1):
  19.         point_value_map[(x,i+1)]=line[i]
  20.     x+=1
  21.  
  22. #对迷宫按照题目中规定的字典序进行广度优先搜索
  23. from collections import deque
  24. bread_first_queue=deque()
  25. #当前节点是否已经遍历过
  26. has_checked=[]
  27. #遍历的起始点和终止点的坐标
  28. start_point=(1,1)
  29. end_point=(30,50)
  30. bread_first_queue.append(start_point)
  31. while bread_first_queue:
  32.     now_point=bread_first_queue.popleft()
  33.     #如果当前节点没有遍历
  34.     if now_point not in has_checked:
  35.         #如果当前节点是终点，则广度优先搜索结束
  36.         if now_point==end_point:
  37.             break
  38.         else:
  39.             #按照题目规定对四个方向进行搜索
  40.             #D<L<R<U
  41.             down_point=(now_point[0]+1,now_point[1])
  42.             left_point=(now_point[0],now_point[1]-1)
  43.             right_point=(now_point[0],now_point[1]+1)
  44.             up_point=(now_point[0]-1,now_point[1])
  45.             #标记当前节点已经被访问过
  46.             has_checked.append(now_point)
  47.  
  48.             if point_value_map.get(down_point)=='0' and (down_point not in has_checked):
  49.                 bread_first_queue.append(down_point)
  50.             if point_value_map.get(left_point)=='0' and (left_point not in has_checked):
  51.                 bread_first_queue.append(left_point)
  52.             if point_value_map.get(right_point)=='0' and (right_point not in has_checked):
  53.                 bread_first_queue.append(right_point)
  54.             if point_value_map.get(up_point)=='0' and (up_point not in has_checked):
  55.                 bread_first_queue.append(up_point)
  56. #从所有的可能路径中寻找字典序最小路径
  57. total_road=has_checked+[end_point]
  58. #最小路径坐标序列
  59. sequence_of_point=[]
  60. #最小路径的字母表示
  61. sequence_of_direction=[]
  62. #当前坐标点,从终点向起点回溯
  63. now_point=(end_point)
  64. while now_point != start_point:
  65.     down_point = (now_point[0] + 1, now_point[1])
  66.     left_point = (now_point[0], now_point[1] - 1)
  67.     right_point = (now_point[0], now_point[1] + 1)
  68.     up_point = (now_point[0] - 1, now_point[1])
  69.     if point_value_map.get(up_point)=='0' and up_point in total_road:
  70.         sequence_of_point.append(up_point)
  71.         index=total_road.index(up_point)
  72.         #删除掉其它路径
  73.         total_road=total_road[:index]
  74.         sequence_of_direction.append('D')
  75.         now_point=up_point
  76.     elif point_value_map.get(right_point)=='0' and right_point in total_road:
  77.         sequence_of_point.append(right_point)
  78.         index=total_road.index(right_point)
  79.         #删除掉其它路径
  80.         total_road=total_road[:index]
  81.         sequence_of_direction.append('L')
  82.         now_point=right_point
  83.     elif point_value_map.get(left_point)=='0' and left_point in total_road:
  84.         sequence_of_point.append(left_point)
  85.         index=total_road.index(left_point)
  86.         #删除掉其它路径
  87.         total_road=total_road[:index]
  88.         sequence_of_direction.append('R')
  89.         now_point=left_point
  90.     elif point_value_map.get(down_point)=='0' and down_point in total_road:
  91.         sequence_of_point.append(down_point)
  92.         index=total_road.index(down_point)
  93.         #删除掉其它路径
  94.         total_road=total_road[:index]
  95.         sequence_of_direction.append('U')
  96.         now_point=down_point
  97.  
  98. #结果字符串
  99. result_string=''
  100. for i in sequence_of_direction:
  101.     result_string+=i
  102. print(result_string[::-1])

  1. n=int(input())
  2. tree_list=list(map(int,input().split()))
  3. from math import log
  4. #求树深
  5. tree_depth=int(log(n,2))+1
  6. #最大节点权值和
  7. max_value=0
  8. #最大节点权值和所在的层次
  9. max_depth=0
  10. for i in range(tree_depth):
  11.     temp=sum(tree_list[2**i-1:2**(i+1)-1])
  12.     if temp>max_value:
  13.         max_value=temp
  14.         max_depth=i+1
  15.  
  16. print(max_depth)

  1. #模拟题，按照题目中的规则进行模拟
  2. n,m,t=map(int,input().split())
  3. #商家列表
  4. shop_list=[0 for i in range(n+1)]
  5. #订单信息列表
  6. order_list=[]
  7. for i in range(m):
  8.     order_time,order_id=map(int,input().split())
  9.     order_list.append([order_time,order_id])
  10. #将订单按照时间顺序进行排序
  11. order_list.sort(key=lambda x:x[0])
  12. #优先缓存队列
  13. catch=[]
  14.  
  15. #按照时间顺序进行商家优先级更新
  16. for time in range(1,t+1):
  17.     #假设time时刻所有商家都没有订单
  18.     flag=True
  19.     #遍历订单列表,寻找当前时刻订单信息
  20.     for order_item in order_list:
  21.         if order_item[0]==time:
  22.             #当前时刻存在订单
  23.             flag=False
  24.             #更新相应商家优先级
  25.             shop_list[order_item[1]]+=2
  26.             #更新其它商家优先级
  27.             for i in range(1,n+1):
  28.                 if i==order_item[1]:
  29.                     continue
  30.                 else:
  31.                     if shop_list[i]==0:
  32.                         continue
  33.                     else:
  34.                         shop_list[i]-=1
  35.     #当前时刻所有商家都没有订单
  36.     if flag:
  37.         for i in range(1,n+1):
  38.             if shop_list[i]==0:
  39.                 continue
  40.             else:
  41.                 shop_list[i]-=1
  42.     #根据商家优先级更新缓存队列
  43.     for i in range(1,n+1):
  44.         if shop_list[i]>5 and (i not in catch):
  45.             catch.append(i)
  46.         if shop_list[i]<=3 and (i in catch):
  47.             catch.remove(i)
  48.  
  49. print(len(catch))

  1. n=int(input())
  2. number_list=list(map(int,input().split()))
  3. for i in range(len(number_list)):
  4.     while number_list[i] in number_list[:i]:
  5.         number_list[i]+=1
  6.  
  7. print(number_list)

 

 

 

  1. # 深度优先搜索，寻找最优组合
  2. # 每名队员只能担任一个位置
  3.  
  4. # 最大评分
  5. max_value = -1
  6. # 编号，评分表
  7. id_score_table = [[0] * 7 for i in range(21)]
  8.  
  9. # 标记当前队员是否已经访问
  10. has_checked = []
  11.  
  12. # 读取文件
  13. file = open('E:/project_code/蓝桥杯/team.txt', 'r')
  14. read_table = file.readlines()
  15. # 建立表格,从（1,1）开始
  16. x = 1
  17. for item in read_table:
  18.     #读取到的内容是以字符串形式返回
  19.     #需要处理一下
  20.     
  21.     #将最后一个\n符号去掉
  22.     item=item[:-1]
  23.     #从字符串分割出数字
  24.     item=item.split()
  25.     for i in range(len(item)):
  26.         #这里字符串需要转换为数字
  27.         id_score_table[x][i+1] = int(item[i])
  28.     x+=1
  29.     
  30. #深度优先搜索
  31. def dfs(temp_max,depth):
  32.     global max_value
  33.     #temp_max是当前组合最大值
  34.     #depth是当前在第几列
  35.     
  36.     #已经遍历完所有的列
  37.     if depth==7:
  38.         max_value=max(temp_max,max_value)
  39.         return
  40.     
  41.     #遍历每个队员的组合
  42.     for i in range(1,21):
  43.         #如果当前队员还没有被遍历
  44.         if i not in has_checked:
  45.             has_checked.append(i)
  46.             #向下一列继续试探
  47.             dfs(temp_max+id_score_table[i][depth],depth+1)
  48.             #试探结束，回溯
  49.             has_checked.remove(i)
  50.             
  51. #寻找最大值
  52. for i in range(1,21):
  53.     has_checked.append(i)
  54.     dfs(id_score_table[i][2],3)
  55.     has_checked.remove(i)
  56.  
  57. print(max_value)

  1. x=2019
  2. ans=''
  3. while x!=0:
  4.     #A的ASCII码为65
  5.     #从64计算
  6.     ans+=chr(x%26+64)
  7.     x//=26
  8.  
  9. print(ans[::-1])

  1. #判断数字中是否含有2,4
  2. def has24(n):
  3.     #假设不含有
  4.     flag=False
  5.     while n!=0:
  6.         a=n%10
  7.         if a==2 or a==4:
  8.             flag=True
  9.             return flag
  10.         n//=10
  11.     return flag
  12. count=0
  13.  
  14. #按照i<j<k进行试探组合
  15. for i in range(1,2019+1):
  16.     if has24(i):
  17.         continue
  18.     for j in range(i+1,2019+1):
  19.         if has24(j):
  20.             continue
  21.         k=2019-i-j
  22.         #按照i<j<k顺序进行试探
  23.         if k<=i or k<=j or has24(k):
  24.             continue
  25.         else:
  26.             count+=1
  27.  
  28. print(count)

 

  1. n=int(input())
  2. number_list=list(map(int,input().split()))
  3. #将数列排序，求出等差数列的公差
  4. number_list.sort()
  5. #公差就是相邻元素的最小差值
  6. min_value=10**10
  7. for i in range(len(number_list)-1):
  8.     temp=number_list[i+1]-number_list[i]
  9.     if temp<min_value:
  10.         min_value=temp
  11. #计算等差数列的项数
  12. ans=0
  13. for i in range(number_list[0],number_list[len(number_list)-1]+1,min_value):
  14.     ans+=1
  15.  
  16. print(ans)

  1. #按照题目要求进行模拟
  2. a=2019
  3. b=324
  4. ans=0
  5. #切割最后可能有两种情况
  6. #1.有一个边长为0，完全切割，直接退出即可
  7. #2.有一个边长为1，切割数加上最后的最大边长即可
  8.  
  9. #标记边长是否为1
  10. flag=False
  11. while True:
  12.     temp=a
  13.     #进行一次切割
  14.     #从大的边长中减去小的边长
  15.     a=max(temp-b,b)
  16.     b=min(temp-b,b)
  17.     ans+=1
  18.     if a==1 or b==1:
  19.         flag=True
  20.         break
  21.     if a==0 or b==0:
  22.         break
  23. if flag:
  24.     ans+=max(a,b)
  25.  
  26. print(ans)

  1. #质数列表
  2. prime_number_list=[]
  3. #素数筛法数表
  4. number_list=[i for i in range(2,100001)]
  5. #素数筛法
  6. for i in range(len(number_list)):
  7.     if number_list[i]!=0 and number_list[i] not in prime_number_list:
  8.         #添加当前素数
  9.         prime_number_list.append(number_list[i])
  10.         if len(prime_number_list)>=2019:
  11.             break
  12.         for j in range(i+1,len(number_list)):
  13.             if number_list[j]%number_list[i]==0:
  14.                 number_list[j]=0
  15.  
  16. print(prime_number_list.pop(2018))

 

 

  1. #顺时针旋转90
  2. n,m=map(int,input().split())
  3. matrix=[[0]*m for i in range(n)]
  4. for i in range(n):
  5.     matrix[i]=list(map(int,input().split()))
  6. #先将矩阵倒序，然后行列互换
  7. matrix[::] = [[row[i] for row in matrix[::-1]] for i in range(len(matrix[0]))]
  8.  
  9. print(matrix)

 

 

 

 

  1. #字符串处理问题
  2. k=int(input())
  3. string=input()
  4. #正则匹配模块
  5. import re
  6. #将字符串按照 '.' 和空格进分割
  7. #'.+空格'将被分解成一个空字符
  8. string_list=re.split('\s+|\.',string)
  9. #总的出现次数为：
  10. #alice->bob的距离+bob->alice的距离
  11. ans=0
  12. for i in range(len(string_list)):
  13.     if string_list[i]=='Alice':
  14.         for j in range(i+1,len(string_list)):
  15.             #当前字符串后面有一个空格
  16.             #分割的时候被删掉了
  17.             #所以sum应该从1开始计数
  18.             sum=1
  19.             if string_list[j]=='Bob':
  20.                 #计算中间出现的字符数
  21.                 for k in range(i+1,j):
  22.                     #同样因为空格要+1
  23.                     sum+=(len(string_list[k])+1)
  24.         if sum<=k:
  25.             ans+=1
  26.             #只计算一次最短距离
  27.             break
  28. #bob->alice的距离
  29. for i in range(len(string_list)):
  30.     if string_list[i]=='Bob':
  31.         for j in range(i+1,len(string_list)):
  32.             #当前字符串后面有一个空格
  33.             #分割的时候被删掉了
  34.             #所以sum应该从1开始计数
  35.             sum=1
  36.             if string_list[j]=='Alice':
  37.                 #计算中间出现的字符数
  38.                 for k in range(i+1,j):
  39.                     #同样因为空格要+1
  40.                     sum+=(len(string_list[k])+1)
  41.         if sum<=k:
  42.             ans+=1
  43.             #只计算一次最短距离
  44.             break
  45.  
  46. print(ans)

  1. string=input()
  2. ans=0
  3. #26进制转为10进制
  4. for i in range(len(string)):
  5.     #字符i的ascii码
  6.     number=ord(string[i])
  7.     ans+=(number-64)*(26**(len(string)-(i+1)))
  8.  
  9. print(ans)

 

 

 

按照以下过程进行计算：

n=p*q

p，q为素数

d与（p-1）*（q-1）互素

（d*e）%（（p-1）*（q-1））=1

c=x^d%n

x=c^e%n

给定d,c,n

求x

  1. #利用素数筛法找出p，q
  2. p=891234941
  3. q=1123984201
  4. n=1001733993063167141
  5. c=20190324
  6. d=212353
  7. for i in range(1,500000):
  8.     if(((p-1)*(q-1)*i+1)%d==0):
  9.         e=((p-1)*(q-1)*i+1)//212353
  10.         print(((p-1)*(q-1)*i+1)//d)
  11.         break
  12. def quick_mod(a,b,c):
  13.     a=a%c
  14.     ans=1
  15.     while b!=0:
  16.         if b&1:
  17.             ans=(ans*a)%c
  18.         b>>=1
  19.         a=(a*a)%c
  20.     return ans
  21. x=quick_mod(c,e,n)
  22. print(x)
  23. print(quick_mod(x,d,n))

计算斐波那契数列的第N项/第N+1项的值

  1. number_list=[0 for i in range(3)]
  2. number_list[1]=1
  3. number_list[2]=1
  4. n=int(input())
  5. for i in range(3,n+1+1):
  6.     temp=number_list[1]+number_list[2]
  7.     number_list[1]=number_list[2]
  8.     number_list[2]=temp
  9.  
  10. print('%.8f'%(number_list[1]/number_list[2]))

 

 

  1. #迪杰斯特拉求最短路径
  2. def shortPath(start_point,graph):
  3.     #start_point是求最短路径的起点
  4.     #graph是领接矩阵
  5.     #已经求出最短路径的顶点
  6.     has_past=[]
  7.     #还没有求出最短路径的顶点
  8.     no_past=[]
  9.     #从start_point到其它顶点的最短距离
  10.     dis=[]
  11.     #初始化
  12.     #从起点开始算到其它顶点的最短路径
  13.     has_past.append(start_point)
  14.     #除了起点其它没有求出最短路径的顶点
  15.     no_past=[x for x in range(len(graph)) if x != start_point]
  16.     #最初的从起点到其它顶点的最短距离默认为领接矩阵顶点所在的行
  17.     dis=graph[start_point]
  18.  
  19.     #当还有没计算出最短距离的顶点时
  20.     while len(no_past):
  21.         id=no_past[0]
  22.         #寻找从起点到其它顶点的最短距离
  23.         for i in no_past:
  24.             if dis[i]<dis[id]:
  25.                 id=i
  26.         #借助第id个顶点松弛起点到其它顶点的最短距离
  27.         for i in no_past:
  28.             if dis[id]+graph[id][i]<dis[i]:
  29.                 dis[i]=dis[id]+graph[id][i]
  30.     return dis
  31.  
  32.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/592694
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号