时间戳

首页 > 技术文章 > CCF201609-Python题解

CCF201609-Python题解

z-712 2020-09-03 19:39 原文

最大波动

原题连接：http://118.190.20.162/view.page?gpid=T47

试题编号： 201609-1
试题名称： 最大波动
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　小明正在利用股票的波动程度来研究股票。小明拿到了一只股票每天收盘时的价格，他想知道，这只股票连续几天的最大波动值是多少，即在这几天中某天收盘价格与前一天收盘价格之差的绝对值最大是多少。
输入格式
　　输入的第一行包含了一个整数n，表示小明拿到的收盘价格的连续天数。
　　第二行包含n个正整数，依次表示每天的收盘价格。
输出格式
　　输出一个整数，表示这只股票这n天中的最大波动值。
样例输入
6
2 5 5 7 3 5
样例输出
4
样例说明
　　第四天和第五天之间的波动最大，波动值为|3-7|=4。
评测用例规模与约定
　　对于所有评测用例，2 ≤ n ≤ 1000。股票每一天的价格为1到10000之间的整数。

 

题解：相邻的相减，寻找最大差值

 

1 n=int(input())
2 a=list(map(int, input().split()))
3 
4 minn=-1
5 for i in range(n-1):
6     tmp=a[i]
7     if abs(tmp-a[i+1])>minn:
8         minn=abs(tmp-a[i+1])
9 print(minn)

 

 

 

 

火车购票

原题链接：http://118.190.20.162/view.page?gpid=T46

试题编号： 201609-2
试题名称： 火车购票
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　请实现一个铁路购票系统的简单座位分配算法，来处理一节车厢的座位分配。
　　假设一节车厢有20排、每一排5个座位。为方便起见，我们用1到100来给所有的座位编号，第一排是1到5号，第二排是6到10号，依次类推，第20排是96到100号。
　　购票时，一个人可能购一张或多张票，最多不超过5张。如果这几张票可以安排在同一排编号相邻的座位，则应该安排在编号最小的相邻座位。否则应该安排在编号最小的几个空座位中（不考虑是否相邻）。
　　假设初始时车票全部未被购买，现在给了一些购票指令，请你处理这些指令。
输入格式
　　输入的第一行包含一个整数n，表示购票指令的数量。
　　第二行包含n个整数，每个整数p在1到5之间，表示要购入的票数，相邻的两个数之间使用一个空格分隔。
输出格式
　　输出n行，每行对应一条指令的处理结果。
　　对于购票指令p，输出p张车票的编号，按从小到大排序。
样例输入
4
2 5 4 2
样例输出
1 2
6 7 8 9 10
11 12 13 14
3 4
样例说明
　　1) 购2张票，得到座位1、2。
　　2) 购5张票，得到座位6至10。
　　3) 购4张票，得到座位11至14。
　　4) 购2张票，得到座位3、4。
评测用例规模与约定
　　对于所有评测用例，1 ≤ n ≤ 100，所有购票数量之和不超过100。

 

题解：回首前些日子写的第一题，代码还是要多练练，太丑了

这里就模拟一下吧 [[0,0,0,0,0],

                               [0,0,0,0,0],

                               [0,0,0,0,0],

                               .........]

 1 n=int(input())
 2 ans=list(map(int, input().split()))
 3 
 4 seats=[[0 for i in range(5)] for j in range(20)]
 5 
 6 
 7 for i in range(len(ans)):
 8     flag=1 #find
 9     for j in range(20):
10         if ans[i]<=seats[j].count(0):
11             posi=seats[j].index(0)
12             for m in range(posi,posi+ans[i]):
13                 seats[j][m]=1
14                 print(j*5+m+1,end=' ')
15             flag=0
16             break
17     if flag:
18         tmp=ans[i]
19         for j in range(20):
20             for m in range(5):
21                 if tmp==0:
22                     break
23                 if seats[j][m]==0:
24                     print(j*5+m+1, end=' ')
25                     tmp-=1
26     print()

 

 

 

炉石传说

试题编号： 201609-3
试题名称： 炉石传说
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　《炉石传说：魔兽英雄传》（Hearthstone: Heroes of Warcraft，简称炉石传说）是暴雪娱乐开发的一款集换式卡牌游戏（如下图所示）。游戏在一个战斗棋盘上进行，由两名玩家轮流进行操作，本题所使用的炉石传说游戏的简化规则如下：

　　* 玩家会控制一些角色，每个角色有自己的生命值和攻击力。当生命值小于等于 0 时，该角色死亡。角色分为英雄和随从。
　　* 玩家各控制一个英雄，游戏开始时，英雄的生命值为 30，攻击力为 0。当英雄死亡时，游戏结束，英雄未死亡的一方获胜。
　　* 玩家可在游戏过程中召唤随从。棋盘上每方都有 7 个可用于放置随从的空位，从左到右一字排开，被称为战场。当随从死亡时，它将被从战场上移除。
　　* 游戏开始后，两位玩家轮流进行操作，每个玩家的连续一组操作称为一个回合。
　　* 每个回合中，当前玩家可进行零个或者多个以下操作：
　　1) 召唤随从：玩家召唤一个随从进入战场，随从具有指定的生命值和攻击力。
　　2) 随从攻击：玩家控制自己的某个随从攻击对手的英雄或者某个随从。
　　3) 结束回合：玩家声明自己的当前回合结束，游戏将进入对手的回合。该操作一定是一个回合的最后一个操作。
　　* 当随从攻击时，攻击方和被攻击方会同时对彼此造成等同于自己攻击力的伤害。受到伤害的角色的生命值将会减少，数值等同于受到的伤害。例如，随从 X 的生命值为 HX、攻击力为 AX，随从 Y 的生命值为 HY、攻击力为 AY，如果随从 X 攻击随从 Y，则攻击发生后随从 X 的生命值变为 HX - AY，随从 Y 的生命值变为 HY - AX。攻击发生后，角色的生命值可以为负数。
　　本题将给出一个游戏的过程，要求编写程序模拟该游戏过程并输出最后的局面。
输入格式
　　输入第一行是一个整数 n，表示操作的个数。接下来 n 行，每行描述一个操作，格式如下：
　　<action> <arg1> <arg2> ...
　　其中<action>表示操作类型，是一个字符串，共有 3 种：summon表示召唤随从，attack表示随从攻击，end表示结束回合。这 3 种操作的具体格式如下：
　　* summon <position> <attack> <health>：当前玩家在位置<position>召唤一个生命值为<health>、攻击力为<attack>的随从。其中<position>是一个 1 到 7 的整数，表示召唤的随从出现在战场上的位置，原来该位置及右边的随从都将顺次向右移动一位。
　　* attack <attacker> <defender>：当前玩家的角色<attacker>攻击对方的角色 <defender>。<attacker>是 1 到 7 的整数，表示发起攻击的本方随从编号，<defender>是 0 到 7 的整数，表示被攻击的对方角色，0 表示攻击对方英雄，1 到 7 表示攻击对方随从的编号。
　　* end：当前玩家结束本回合。
　　注意：随从的编号会随着游戏的进程发生变化，当召唤一个随从时，玩家指定召唤该随从放入战场的位置，此时，原来该位置及右边的所有随从编号都会增加 1。而当一个随从死亡时，它右边的所有随从编号都会减少 1。任意时刻，战场上的随从总是从1开始连续编号。
输出格式
　　输出共 5 行。
　　第 1 行包含一个整数，表示这 n 次操作后（以下称为 T 时刻）游戏的胜负结果，1 表示先手玩家获胜，-1 表示后手玩家获胜，0 表示游戏尚未结束，还没有人获胜。
　　第 2 行包含一个整数，表示 T 时刻先手玩家的英雄的生命值。
　　第 3 行包含若干个整数，第一个整数 p 表示 T 时刻先手玩家在战场上存活的随从个数，之后 p 个整数，分别表示这些随从在 T 时刻的生命值（按照从左往右的顺序）。
　　第 4 行和第 5 行与第 2 行和第 3 行类似，只是将玩家从先手玩家换为后手玩家。
样例输入
8
summon 1 3 6
summon 2 4 2
end
summon 1 4 5
summon 1 2 1
attack 1 2
end
attack 1 1
样例输出
0
30
1 2
30
1 2
样例说明
　　按照样例输入从第 2 行开始逐行的解释如下：
　　1. 先手玩家在位置 1 召唤一个生命值为 6、攻击力为 3 的随从 A，是本方战场上唯一的随从。
　　2. 先手玩家在位置 2 召唤一个生命值为 2、攻击力为 4 的随从 B，出现在随从 A 的右边。
　　3. 先手玩家回合结束。
　　4. 后手玩家在位置 1 召唤一个生命值为 5、攻击力为 4 的随从 C，是本方战场上唯一的随从。
　　5. 后手玩家在位置 1 召唤一个生命值为 1、攻击力为 2 的随从 D，出现在随从 C 的左边。
　　6. 随从 D 攻击随从 B，双方均死亡。
　　7. 后手玩家回合结束。
　　8. 随从 A 攻击随从 C，双方的生命值都降低至 2。
评测用例规模与约定
　　* 操作的个数0 ≤ n ≤ 1000。
　　* 随从的初始生命值为 1 到 100 的整数，攻击力为 0 到 100 的整数。
　　* 保证所有操作均合法，包括但不限于：
　　1) 召唤随从的位置一定是合法的，即如果当前本方战场上有 m 个随从，则召唤随从的位置一定在 1 到 m + 1 之间，其中 1 表示战场最左边的位置，m + 1 表示战场最右边的位置。
　　2) 当本方战场有 7 个随从时，不会再召唤新的随从。
　　3) 发起攻击和被攻击的角色一定存在，发起攻击的角色攻击力大于 0。
　　4) 一方英雄如果死亡，就不再会有后续操作。
　　* 数据约定：
　　前 20% 的评测用例召唤随从的位置都是战场的最右边。
　　前 40% 的评测用例没有 attack 操作。
　　前 60% 的评测用例不会出现随从死亡的情况。
 
 
题解：判断每一次输入，可以分为三种情况：更新随从、打架、end
（1）对于每次更新，那就根据输入要求的位置插入到列表中即可
（2）对于每次打架，要判断下，一发起者有攻击力是否大于0，二打完之后要对清除死掉的随从
（3）end，翻转一下（下次谁先动手）
对于每次要看看英雄的生命情况，英雄了就End了
  1 n=int(input())
  2 red=[[0,30]]#1
  3 blue=[[0,30]]#-1
  4 
  5 def update_summon(flag,arg_summon): 
  6     #arg_summon [1, 3, 6]
  7     if flag==1: #arg[0]：pisition， arg[1]：攻击力， arg[2]：生命力
  8         red.insert(arg_summon[0],[arg_summon[1],arg_summon[2]])
  9         return red
 10     else:
 11         blue.insert(arg_summon[0],[arg_summon[1],arg_summon[2]])
 12         return blue
 13 
 14 def update_attack(arg_attack,flag):
 15     # arg_attack:[1, 2] attack life
 16     if flag==1:
 17         blue_summon_list=blue[arg_attack[1]]
 18         red_summon_list=red[arg_attack[0]]
 19         if red_summon_list[0]>0:
 20             blue_summon_list[1]=blue_summon_list[1]-red_summon_list[0]
 21             red_summon_list[1]=red_summon_list[1]-blue_summon_list[0]
 22         #print(flag)
 23         #print("blue_summon_list",blue_summon_list)
 24         #print("red_summon_list",red_summon_list)
 25         #die update
 26         if blue_summon_list[1]<=0 and arg_attack[1]!=0: #死了，要删除 但是英雄死了，不能删除
 27             del blue[arg_attack[1]]
 28         if red_summon_list[1]<=0 and arg_attack[0]!=0:
 29             del red[arg_attack[0]]
 30 
 31     elif flag==-1:
 32         blue_summon_list=blue[arg_attack[0]]
 33         red_summon_list=red[arg_attack[1]]
 34         if blue_summon_list[0]>0:
 35             blue_summon_list[1]=blue_summon_list[1]-red_summon_list[0]
 36             red_summon_list[1]=red_summon_list[1]-blue_summon_list[0]
 37         #print(flag)
 38         #print("red_summon_list",red_summon_list)
 39         #print("blue_summon_list",blue_summon_list)
 40         #die update
 41         if blue_summon_list[1]<=0 and arg_attack[0]!=0:
 42             del blue[arg_attack[0]]
 43         if red_summon_list[1]<=0 and arg_attack[1]!=0:
 44             del red[arg_attack[1]]
 45 
 46     return red,blue
 47 
 48 def end_game(): #结束游戏，把对应的英雄和随从 生命值 格式化输出
 49     print(red[0][1])
 50     print(len(red[1:]),end=" ")
 51     for k in range(1,len(red)):
 52         print(red[k][1],end=" ")
 53     print()
 54     print(blue[0][1])
 55     print(len(blue[1:]),end=" ")
 56     for k in range(1,len(blue)):
 57         print(blue[k][1],end=" ")
 58     
 59     
 60 
 61 if __name__ =="__main__": 
 62     flag=1
 63     result=1
 64     for m in range(n):
 65         tmp=input().split()
 66         lens=len(tmp)
 67         if flag==1: #先手
 68             if lens==4: #召唤随从
 69                 if len(red[1:])>7:
 70                     continue
 71                 else:
 72                     arg_summon=list(map(int, tmp[1:]))
 73                     red=update_summon(flag,arg_summon)
 74             elif lens==3: #attack
 75                 arg_attack=list(map(int, tmp[1:]))
 76                 red,blue=update_attack(arg_attack,flag) #获取此时红蓝双方 情况
 77             elif lens==1: #end，对方
 78                 flag*=-1
 79         elif flag==-1: #后手
 80             if lens==4:
 81                 if len(blue[1:])>7:
 82                     continue
 83                 else:
 84                     arg_summon=list(map(int, tmp[1:]))
 85                     blue=update_summon(flag,arg_summon)
 86             elif lens==3:
 87                 arg_attack=list(map(int, tmp[1:]))
 88                 red,blue=update_attack(arg_attack,flag)
 89             elif lens==1:
 90                 flag*=-1
 91         if red[0][1]<=0: #先手英雄死了，后手获胜 -1
 92             result=0
 93             print(-1)
 94             end_game()
 95             break
 96         elif blue[0][1]<=0: #后手英雄死了，先手获胜 1
 97             result=0
 98             print(1)
 99             end_game()
100             break
101         
102     if result==1: #还没分出胜负
103         print(0)
104         end_game()

 

 

 

 

推荐阅读