#等比数列求和，然后约分
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)