碰撞的小球
问题描述
数轴上有一条长度为L（L为偶数)的线段，左端点在原点，右端点在坐标L处。有n个不计体积的小球在线段上，开始时所有的小球都处在偶数坐标上，速度方向向右，速度大小为1单位长度每秒。
当小球到达线段的端点（左端点或右端点）的时候，会立即向相反的方向移动，速度大小仍然为原来大小。
当两个小球撞到一起的时候，两个小球会分别向与自己原来移动的方向相反的方向，以原来的速度大小继续移动。
现在，告诉你线段的长度L，小球数量n，以及n个小球的初始位置，请你计算t秒之后，各个小球的位置。
提示
因为所有小球的初始位置都为偶数，而且线段的长度为偶数，可以证明，不会有三个小球同时相撞，小球到达线段端点以及小球之间的碰撞时刻均为整数。
同时也可以证明两个小球发生碰撞的位置一定是整数（但不一定是偶数）。
输入格式
输入的第一行包含三个整数n, L, t，用空格分隔，分别表示小球的个数、线段长度和你需要计算t秒之后小球的位置。
第二行包含n个整数a1, a2, …, an，用空格分隔，表示初始时刻n个小球的位置。
输出格式
输出一行包含n个整数，用空格分隔，第i个整数代表初始时刻位于ai的小球，在t秒之后的位置。
样例输入
3 10 5
4 6 8
样例输出
7 9 9
样例说明
初始时，三个小球的位置分别为4, 6, 8。
一秒后，三个小球的位置分别为5, 7, 9。
两秒后，第三个小球碰到墙壁，速度反向，三个小球位置分别为6, 8, 10。
三秒后，第二个小球与第三个小球在位置9发生碰撞，速度反向（注意碰撞位置不一定为偶数），三个小球位置分别为7, 9, 9。
四秒后，第一个小球与第二个小球在位置8发生碰撞，速度反向，第三个小球碰到墙壁，速度反向，三个小球位置分别为8, 8, 10。
五秒后，三个小球的位置分别为7, 9, 9。
样例输入
10 22 30
14 12 16 6 10 2 8 20 18 4
样例输出
6 6 8 2 4 0 4 12 10 2
数据规模和约定
对于所有评测用例，1 ≤ n ≤ 100，1 ≤ t ≤ 100，2 ≤ L ≤ 1000，0 < ai < L。L为偶数。
保证所有小球的初始位置互不相同且均为偶数。
#思路：定义一个列表代表每个小球的位置，又定义一个列表代表小球的方向。
n, l, t = input().split()
n = int(n)
l = int(l)
t = int(t)
num = input().split()
for i in range(n):
num[i] = int(num[i])
des = []
for i in range(n):
des.append(1)
while t:
t = t - 1
for i in range(n):
if num[i] == 0 or num[i] == l:
des[i] = -des[i]
if num.count(num[i]) == 2:
for j in (i, n):
if num[j] == num[i]:
des[j] = -des[j]
break
for i in range(n):
num[i] += des[i]
for i in range(n):
print(num[i],end=" ")
公共钥匙盒
问题描述
有一个学校的老师共用N个教室，按照规定，所有的钥匙都必须放在公共钥匙盒里，老师不能带钥匙回家。每次老师上课前，都从公共钥匙盒里找到自己上课的教室的钥匙去开门，上完课后，再将钥匙放回到钥匙盒中。
钥匙盒一共有N个挂钩，从左到右排成一排，用来挂N个教室的钥匙。一串钥匙没有固定的悬挂位置，但钥匙上有标识，所以老师们不会弄混钥匙。
每次取钥匙的时候，老师们都会找到自己所需要的钥匙将其取走，而不会移动其他钥匙。每次还钥匙的时候，还钥匙的老师会找到最左边的空的挂钩，将钥匙挂在这个挂钩上。如果有多位老师还钥匙，则他们按钥匙编号从小到大的顺序还。如果同一时刻既有老师还钥匙又有老师取钥匙，则老师们会先将钥匙全还回去再取出。
今天开始的时候钥匙是按编号从小到大的顺序放在钥匙盒里的。有K位老师要上课，给出每位老师所需要的钥匙、开始上课的时间和上课的时长，假设下课时间就是还钥匙时间，请问最终钥匙盒里面钥匙的顺序是怎样的？
输入格式
输入的第一行包含两个整数N, K。
接下来K行，每行三个整数w, s, c，分别表示一位老师要使用的钥匙编号、开始上课的时间和上课的时长。可能有多位老师使用同一把钥匙，但是老师使用钥匙的时间不会重叠。
保证输入数据满足输入格式，你不用检查数据合法性。
输出格式
输出一行，包含N个整数，相邻整数间用一个空格分隔，依次表示每个挂钩上挂的钥匙编号。
样例输入
5 2
4 3 3
2 2 7
样例输出
1 4 3 2 5
样例说明
第一位老师从时刻3开始使用4号教室的钥匙，使用3单位时间，所以在时刻6还钥匙。第二位老师从时刻2开始使用钥匙，使用7单位时间，所以在时刻9还钥匙。
每个关键时刻后的钥匙状态如下（X表示空）：
时刻2后为1X345；
时刻3后为1X3X5；
时刻6后为143X5；
时刻9后为14325。
样例输入
5 7
1 1 14
3 3 12
1 15 12
2 7 20
3 18 12
4 21 19
5 30 9
样例输出
1 2 3 5 4
评测用例规模与约定
对于30%的评测用例，1 ≤ N, K ≤ 10, 1 ≤ w ≤ N, 1 ≤ s, c ≤ 30；
对于60%的评测用例，1 ≤ N, K ≤ 50，1 ≤ w ≤ N，1 ≤ s ≤ 300，1 ≤ c ≤ 50；
对于所有评测用例，1 ≤ N, K ≤ 1000，1 ≤ w ≤ N，1 ≤ s ≤ 10000，1 ≤ c ≤ 100。
代码：
#思路模拟时间，将上课时间和结束时间用两个数组装，将所有与钥匙操作的时间放在time数组排序，模拟时间，利用先还后解。
n,k=input().split()
n=int(n)
k=int(k)
L=[]
key=[i for i in range(1,n+1)]
st=[]
en=[]
time=[]
for i in range(k):
L.append(input().split())
for i in range(k):
for j in range(3):
L[i][j]=int(L[i][j])
L[i][2]=L[i][1]+L[i][2]
st.append(L[i][1])
en.append(L[i][2])
if L[i][1] not in time:
time.append(L[i][1])
if L[i][2] not in time:
time.append(L[i][2])
time.sort()
for t in time:
#还
if t in en:
return_key=[]
for i in range(len(en)):
if en[i]==t:
return_key.append(L[i][0])
return_key.sort()
for i in range(len(return_key)):
for j in range(len(key)):
if key[j]==0:
key[j]=return_key[i]
break
#借
if t in st:
lend_key=[]
for i in range(len(st)):
if st[i]==t:
lend_key.append(L[i][0])
for i in range(len(lend_key)):
for j in range(len(key)):
if key[j]==lend_key[i]:
key[j]=0
for k in key:
print(k,end=" ")
小明放学
题目背景
汉东省政法大学附属中学所在的光明区最近实施了名为“智慧光明”的智慧城市项目。具体到交通领域，通过“智慧光明”终端，可以看到光明区所有红绿灯此时此刻的状态。小明的学校也安装了“智慧光明”终端，小明想利用这个终端给出的信息，估算自己放学回到家的时间。
问题描述
一次放学的时候，小明已经规划好了自己回家的路线，并且能够预测经过各个路段的时间。同时，小明通过学校里安装的“智慧光明”终端，看到了出发时刻路上经过的所有红绿灯的指示状态。请帮忙计算小明此次回家所需要的时间。
输入格式
输入的第一行包含空格分隔的三个正整数 r、y、g，表示红绿灯的设置。这三个数均不超过 106。
输入的第二行包含一个正整数 n，表示小明总共经过的道路段数和路过的红绿灯数目。
接下来的 n 行，每行包含空格分隔的两个整数 k、t。k=0 表示经过了一段道路，将会耗时 t 秒，此处 t 不超过 106；k=1、2、3 时，分别表示出发时刻，此处的红绿灯状态是红灯、黄灯、绿灯，且倒计时显示牌上显示的数字是 t，此处 t 分别不会超过 r、y、g。
输出格式
输出一个数字，表示此次小明放学回家所用的时间。
样例输入
30 3 30
8
0 10
1 5
0 11
2 2
0 6
0 3
3 10
0 3
样例输出
46
样例说明
小明先经过第一段路，用时 10 秒。第一盏红绿灯出发时是红灯，还剩 5 秒；小明到达路口时，这个红绿灯已经变为绿灯，不用等待直接通过。接下来经过第二段路，用时 11 秒。第二盏红绿灯出发时是黄灯，还剩两秒；小明到达路口时，这个红绿灯已经变为红灯，还剩 11 秒。接下来经过第三、第四段路，用时 9 秒。第三盏红绿灯出发时是绿灯，还剩 10 秒；小明到达路口时，这个红绿灯已经变为红灯，还剩两秒。接下来经过最后一段路，用时 3 秒。共计 10+11+11+9+2+3 = 46 秒。
评测用例规模与约定
- 有些测试点具有特殊的性质：
- 前 2 个测试点中不存在任何信号灯。
- 测试点的输入数据规模：
- 前 6 个测试点保证 n ≤ 103。
- 所有测试点保证 n ≤ 105。
#每个灯没有0秒，0秒就是下一个灯了
#利用递归的思想，考虑在这个灯秒数时间内和不在这个灯秒数时间内
r, y, g = input().split()
r = int(r)
y = int(y)
g = int(g)
n = int(input())
time=0
def fun(n,k,t):
if n==0:
return k
if n==1:
if k-t>0:
return k-t
else:
return fun(3,g,t-k)
if n==2:
if k-t>0:
return k+r-t
else:
return fun(1,r,t-k)
if n==3:
if k-t>0:
return 0
else:
return fun(2,y,t-k)
for i in range(n):
n,k=input().split()
n=int(n)
k=int(k)
t=time%(r+y+g)
time+=fun(n,k,t)
print(time)
工资计算
问题描述
小明的公司每个月给小明发工资，而小明拿到的工资为交完个人所得税之后的工资。假设他一个月的税前工资（扣除五险一金后、未扣税前的工资）为S元，则他应交的个人所得税按如下公式计算：
1） 个人所得税起征点为3500元，若S不超过3500，则不交税，3500元以上的部分才计算个人所得税，令A=S-3500元；
2） A中不超过1500元的部分，税率3%；
3） A中超过1500元未超过4500元的部分，税率10%；
4） A中超过4500元未超过9000元的部分，税率20%；
5） A中超过9000元未超过35000元的部分，税率25%；
6） A中超过35000元未超过55000元的部分，税率30%；
7） A中超过55000元未超过80000元的部分，税率35%；
8） A中超过80000元的部分，税率45%；
例如，如果小明的税前工资为10000元，则A=10000-3500=6500元，其中不超过1500元部分应缴税1500×3%=45元，超过1500元不超过4500元部分应缴税(4500-1500)×10%=300元，超过4500元部分应缴税(6500-4500)×20%=400元。总共缴税745元，税后所得为9255元。
已知小明这个月税后所得为T元，请问他的税前工资S是多少元。
输入格式
输入的第一行包含一个整数T，表示小明的税后所得。所有评测数据保证小明的税前工资为一个整百的数。
输出格式
输出一个整数S，表示小明的税前工资。
样例输入
9255
样例输出
10000
评测用例规模与约定
对于所有评测用例，1 ≤ T ≤ 100000。
#90分代码，不知道错那 ？
n=int(input())
sum=3500
flag=1
if n<=3500:
sum=n
flag=0
else:
n=n-3500
if n<=1455 and flag==1:
sum+=n*100/97
elif n<=4155 and flag==1:
sum+=(n-1455)*100/90+1500
elif n<=7755 and flag==1:
sum+=(n-4155)*1.25+4500
elif n<=27255 and flag==1:
sum+=(n-7755)*100/75+9000
elif n<=41435 and flag==1:
sum+=(n-27255)*100/70+35000
elif n<=57505 and flag==1:
sum+=(n-41435)*100/65+55000
elif flag==1:
sum+=(n-57505)*100/55+80000
print(int(sum))
#100分代码
# 工资计算
r = [0.03, 0.1, 0.2, 0.25, 0.3, 0.35, 0.45] # 税率
S = [3500,3500+1500,3500+4500,3500+9000,3500+35000,3500+55000,3500+80000] # 每个税率区间的原工资最大值
A = [(i-3500) for i in S]
R = [0] # 每个税率区间最大交税值
temp = 0
for i in range(1,len(A)):
temp += (A[i]-A[i-1])*r[i-1]
R.append(temp)
T = [(S[i]-R[i]) for i in range(len(S))] # 税后工资区间
t = int(input())
for i in range(len(T)+1):
if i == len(T):
break
elif t <= T[i]:
break
if i == 0:
print(t)
else:
print(int(S[i-1]+(t-T[i-1])/(1-r[i-1])))