蓝桥杯基础练习~报时助手&回形取数&龟兔赛跑预测_请你写一个程序,对于输入的一场比赛的数据v1,v2,t,s,l,预测该场比赛的结果。java

试题 基础练习 报时助手

提交此题
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
　　给定当前的时间，请用英文的读法将它读出来。
　　时间用时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

h,m=input().split()
m=str(int(m))
h=str(int(h))
map_={'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'}
if int(h)<=20:
    str1=map_[h]
elif (int(h))>20 and int(h)<30:
    str1='twenty'+' '+map_[str(int(h)%10)]
if m=='0':
    str2='o\'clock'
elif (int(m))>20 and int(m)<30:
    str2='twenty'+' '+map_[str(int(m)%10)]
elif (int(m)//10)==3:
    str2='thirty'+' '+map_[str(int(m)%10)]
elif (int(m)//10)==4:
    str2='forty'+' '+map_[str(int(m)%10)]
elif (int(m)//10)==5:
    str2='fifty'+' '+map_[str(int(m)%10)]
else:
    str2=map_[m]
print(str1,end=' ')
print(str2,end='')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

试题 基础练习 回形取数

提交此题
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
　　回形取数就是沿矩阵的边取数，若当前方向上无数可取或已经取过，则左转90度。一开始位于矩阵左上角，方向向下。
输入格式
　　输入第一行是两个不超过200的正整数m, n，表示矩阵的行和列。接下来m行每行n个整数，表示这个矩阵。
输出格式
　　输出只有一行，共mn个数，为输入矩阵回形取数得到的结果。数之间用一个空格分隔，行末不要有多余的空格。
样例输入
3 3
1 2 3
4 5 6
7 8 9
样例输出
1 4 7 8 9 6 3 2 5
样例输入
3 2
1 2
3 4
5 6
样例输出
1 3 5 6 4 2

def op(state_i,state_j,i,j):
    if state_i==1:
        i+=1
    elif state_i==2:
        i=i
    elif state_i==3:
        i-=1
    if state_j==1:
        j+=1
    elif state_j==2:
        j=j
    elif state_j==3:
        j-=1
    return [i,j]
m,n=map(int ,input().split())
map_=[]
for i in range(m):
    map_.append(list(input().split()))
i=0
j=0
statei=[1,2,3,2]
statej=[2,1,2,3]
state_i=0
state_j=0
# label=0
while True :
    print(map_[i][j],end=' ')
    map_[i][j]='#'
    t1,t2=op(statei[state_i],statej[state_j],i,j)
    if t1==m or t2==n or map_[t1][t2]=='#':#(i==m-1 and (j==0 or j==n-1))or (j==n-1and(i==0 or i==m-1))
#         print(i,j)
        state_i=(state_i+1)%4
        state_j=(state_j+1)%4
        i,j=op(statei[state_i],statej[state_j],i,j)
        if i==m or j==n or map_[i][j]=='#' :#(i==m-1 and (j==0 or j==n-1))or (j==n-1and(i==0 or i==m-1))or
            break
        else :
            continue
    i,j=op(statei[state_i],statej[state_j],i,j)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

试题 基础练习 龟兔赛跑预测

提交此题
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
　　话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先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
样例输入
10 5 5 1 20
样例输出
R
3
样例输入
10 5 5 3 20
样例输出
T
4

v1,v2,t,s,l=map(int ,input().split())

l1=0
l2=0
l1time=0
l2time=0
while True:
    dettime=(t-l1+l2)/(v1-v2)
    #print('dettime',dettime)
    detl1=dettime*v1
    #print('detl1',detl1)
    detl2=dettime*v2
    #print('detl2',detl2)
    if l1+detl1>=l or l2+detl2>=l:
        l1time+=(l-l1)/v1
        l2time+=(l-l2)/v2
        if l1time>l2time:
            print('T')
            print(int(l2time))
            print('l2',l2)
            break
        elif l1time==l2time:
            print('D')
            print(int(l1time))
            break
        else:
            print('R')
            print(int(l1time))
            break
    else:
        l1+=detl1
        if l2+detl2+s*v2>l:
            print('T')
            l2time+=dettime+(l-(l2+detl2))/v2
            #print(int(l2time))
        l2+=detl2+s*v2
        l1time+=dettime+s
        l2time+=dettime+s
        
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

个人感觉这道题是有问题的，真正精确的应该是上面第一组的代码结果却不对，把问题简化成一秒一秒的问题反而ac了，感觉这道题出的不好

import math
v1,v2,t,s,l=map(int ,input().split())
l1=0
l2=0
l1time=0
l2time=0
while True:
    if l1-l2>=t:
        l2+=s*v2
        l1time+=s
        l2time+=s
    dt1=l1time+(l-l1)/v1
    dt2=l2time+(l-l2)/v2
    l1+=v1
    l2+=v2
    l1time+=1
    l2time+=1
    if l1>=l or l2>=l:
#         if l1>l2:
#             print('R')
#             print(l1time)
#             break
#         elif l1==l2:
#             print('D')
#             print(l1time)
#             break
#         else:
#             print('T')
#             print(l2time)
#             break
        if dt1>dt2:
            print('T')
            print(math.ceil(dt2))
            #print('l2',l2)
            break
        elif dt1==dt2:
            print('D')
            print(math.ceil(dt1))
            break
        else:
            print('R')
            print(math.ceil(dt1))
            break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44