1026 程序运行时间
问题描述：
要获得一个 C 语言程序的运行时间，常用的方法是调用头文件 time.h，其中提供了 clock() 函数，可以捕捉从程序开始运行到 clock() 被调用时所耗费的时间。这个时间单位是 clock tick，即“时钟打点”。同时还有一个常数 CLK_TCK，给出了机器时钟每秒所走的时钟打点数。于是为了获得一个函数 f 的运行时间，我们只要在调用 f 之前先调用 clock()，获得一个时钟打点数 C1；在 f 执行完成后再调用 clock()，获得另一个时钟打点数 C2；两次获得的时钟打点数之差 (C2-C1) 就是 f 运行所消耗的时钟打点数，再除以常数 CLK_TCK，就得到了以秒为单位的运行时间。
这里不妨简单假设常数 CLK_TCK 为 100。现给定被测函数前后两次获得的时钟打点数，请你给出被测函数运行的时间。
输入说明：
输入在一行中顺序给出 2 个整数 C1 和 C2。注意两次获得的时钟打点数肯定不相同，即 C1 < C2，并且取值在 [0,10^7]。
输出说明：
在一行中输出被测函数运行的时间。运行时间必须按照 hh:mm:ss（即2位的 时:分:秒）格式输出；不足 1 秒的时间四舍五入到秒。
输入样列：
123 4577973
输出样列：
12:42:59
代码：
round() 方法返回浮点数x的四舍五入值。
a, b = map(int, input().split())
x = b - a
y = round(x / 100)
hour = str(y // 3600)
minute = str(y // 60 % 60)
second = str(y % 60)
print(hour.rjust(2, '0') + ':' + minute.rjust(2, '0') + ':' + second.rjust(2, '0'))
1037 在霍格沃茨找零钱
问题描述：
如果你是哈利·波特迷，你会知道魔法世界有它自己的货币系统 —— 就如海格告诉哈利的：“十七个银西可(Sickle)兑一个加隆(Galleon)，二十九个纳特(Knut)兑一个西可，很容易。”现在，给定哈利应付的价钱 P 和他实付的钱 A，你的任务是写一个程序来计算他应该被找的零钱。
输入说明：
输入在 1 行中分别给出 P 和 A，格式为 Galleon.Sickle.Knut，其间用 1 个空格分隔。这里 Galleon 是 [0, 10^7] 区间内的整数，Sickle 是 [0, 17) 区间内的整数，Knut 是 [0, 29) 区间内的整数。
输出说明：
在一行中用与输入同样的格式输出哈利应该被找的零钱。如果他没带够钱，那么输出的应该是负数。
输入样列：
样例1：
10.16.27 14.1.28
样例2：
14.1.28 10.16.27
输出样列：
样例1：
3.2.1
样例2：
-3.2.1
代码：
题目要求如果他没带够钱，那么输出的应该是负数，所以可以通过交换把a变成值较大的
p, a = input().split()
p = list(map(int, p.split('.')))
a = list(map(int, a.split('.')))
ans = [0, 0, 0]
if p[0] > a[0]:
p, a = a, p
print('-', end='')
if p[2] > a[2]:
a[1] -= 1
ans[2] = str(a[2] + 29 - p[2])
else:
ans[2] = str(a[2] - p[2])
if p[1] > a[1]:
a[0] -= 1
ans[1] = str(a[1] + 17 - p[1])
else:
ans[1] = str(a[1] - p[1])
ans[0] = str(a[0] - p[0])
print('.'.join(ans))
1046 划拳
问题描述：
划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就赢了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。
下面给出甲、乙两人的划拳记录，请你统计他们最后分别喝了多少杯酒。
输入说明：
输入第一行先给出一个正整数 N（≤100），随后 N 行，每行给出一轮划拳的记录，格式为：
甲划 甲喊 乙划 乙喊
其中喊是喊出的数字，划是划出的数字，均为不超过 100 的正整数（两只手一起划）。
输出说明：
在一行中先后输出甲、乙两人喝酒的杯数，其间以一个空格分隔。
输入样列：
5
8 10 9 12
5 10 5 10
3 8 5 12
12 18 1 13
4 16 12 15
输出样列：
1 2
代码：
n = int(input())
cnt1, cnt2 = 0, 0,
for i in range(n):
lst = list(map(int, input().split()))
sum = lst[0] + lst[2]
if lst[1] == lst[3]:
continue
if lst[1] == sum:
cnt2 += 1
elif lst[3] == sum:
cnt1 += 1
else:
continue
print(cnt1, cnt2)
1056 组合数的和
问题描述：
给定 N 个非 0 的个位数字，用其中任意 2 个数字都可以组合成 1 个 2 位的数字。要求所有可能组合出来的 2 位数字的和。例如给定 2、5、8，则可以组合出：25、28、52、58、82、85，它们的和为330。
输入说明：
输入在第一行中给出 N（1 < N < 10），随后一行给出 N 个不同的非 0 个位数字。数字间以空格分隔。
输出说明：
输出所有可能组合出来的2位数字的和。
输入样列：
3
2 8 5
输出样列：
330
代码：
n, *num = map(int, input().split())
sum = 0
for i in num:
for j in num:
if i != j:
sum += 10 * i + j
print(sum)
1063 计算谱半径
问题描述：
在数学中，矩阵的“谱半径”是指其特征值的模集合的上确界。换言之，对于给定的 n 个复数空间的特征值 { a1+b1i, ⋯, an+bni }，它们的模为实部与虚部的平方和的开方，而“谱半径”就是最大模。
现在给定一些复数空间的特征值，请你计算并输出这些特征值的谱半径。
输入说明：
输入第一行给出正整数 N（≤ 10 000）是输入的特征值的个数。随后 N 行，每行给出 1 个特征值的实部和虚部，其间以空格分隔。注意：题目保证实部和虚部均为绝对值不超过 1000 的整数。
输出说明：
在一行中输出谱半径，四舍五入保留小数点后 2 位。
输入样列：
5
0 1
2 0
-1 0
3 3
0 -3
输出样列：
4.24
代码：
import math
n = int(input())
mx = 0
for i in range(n):
a, b = map(int, input().split())
mx = max(mx, math.sqrt(a * a + b * b))
print("%.2f" % mx)
1067 试密码
问题描述：
当你试图登录某个系统却忘了密码时，系统一般只会允许你尝试有限多次，当超出允许次数时，账号就会被锁死。本题就请你实现这个小功能。
输入说明：
输入在第一行给出一个密码（长度不超过 20 的、不包含空格、Tab、回车的非空字符串）和一个正整数 N（≤ 10），分别是正确的密码和系统允许尝试的次数。随后每行给出一个以回车结束的非空字符串，是用户尝试输入的密码。输入保证至少有一次尝试。当读到一行只有单个 # 字符时，输入结束，并且这一行不是用户的输入。
输出说明：
对用户的每个输入，如果是正确的密码且尝试次数不超过 N，则在一行中输出 Welcome in，并结束程序；如果是错误的，则在一行中按格式输出 Wrong password: 用户输入的错误密码；当错误尝试达到 N 次时，再输出一行 Account locked，并结束程序。
输入样列：
样例1：
Correct%pw 3
correct%pw
Correct@PW
whatisthepassword!
Correct%pw
样例2：
cool@gplt 3
coolman@gplt
coollady@gplt
cool@gplt
try again
输出样列：
样例1：
Wrong password: correct%pw
Wrong password: Correct@PW
Wrong password: whatisthepassword!
Account locked
样例2：
Wrong password: coolman@gplt
Wrong password: coollady@gplt
Welcome in
代码：
s = input().split()
word = s[0]
n = int(s[1])
cnt = 0
while True:
st = input()
if st == '#':
break
cnt += 1
if st == word:
print("Welcome in")
break
else:
print("Wrong password: " + st)
if cnt == n:
print("Account locked")
break
1071 小赌怡情
问题描述：
常言道“小赌怡情”。这是一个很简单的小游戏：首先由计算机给出第一个整数；然后玩家下注赌第二个整数将会比第一个数大还是小；玩家下注 t 个筹码后，计算机给出第二个数。若玩家猜对了，则系统奖励玩家 t 个筹码；否则扣除玩家 t 个筹码。
注意：玩家下注的筹码数不能超过自己帐户上拥有的筹码数。当玩家输光了全部筹码后，游戏就结束。
输入说明：
输入在第一行给出 2 个正整数 T 和 K（≤ 100），分别是系统在初始状态下赠送给玩家的筹码数、以及需要处理的游戏次数。随后 K 行，每行对应一次游戏，顺序给出 4 个数字：
n1 b t n2
其中 n1 和 n2 是计算机先后给出的两个[0, 9]内的整数，保证两个数字不相等。b 为 0 表示玩家赌小，为 1 表示玩家赌大。t 表示玩家下注的筹码数，保证在整型范围内。
输出说明：
对每一次游戏，根据下列情况对应输出（其中 t 是玩家下注量，x 是玩家当前持有的筹码量）：
• 玩家赢，输出 Win t! Total = x.；
• 玩家输，输出 Lose t. Total = x.；
• 玩家下注超过持有的筹码量，输出 Not enough tokens. Total = x.；
• 玩家输光后，输出 Game Over. 并结束程序。
输入样列：
样例1：
100 4
8 0 100 2
3 1 50 1
5 1 200 6
7 0 200 8
样例2：
100 4
8 0 100 2
3 1 200 1
5 1 200 6
7 0 200 8
输出样列：
样例1：
Win 100! Total = 200.
Lose 50. Total = 150.
Not enough tokens. Total = 150.
Not enough tokens. Total = 150.
样例2：
Win 100! Total = 200.
Lose 200. Total = 0.
Game Over.
代码：
(n1-n2)和b的关系可以直接用(n1-n2)*(b-0.5)的正负号来表示
T, K = map(int, input().split())
for i in range(K):
n1, b, t, n2 = map(int, input().split())
if T < t:
print("Not enough tokens. Total = %d." % T)
elif (n1 - n2) * (b - 0.5) > 0:
T -= t
print("Lose %d. Total = %d." % (t, T))
elif (n1 - n2) * (b - 0.5) < 0:
T += t
print("Win %d! Total = %d." % (t, T))
if T == 0:
print("Game Over.")
break
1082 射击比赛
问题描述：
本题目给出的射击比赛的规则非常简单，谁打的弹洞距离靶心最近，谁就是冠军；谁差得最远，谁就是菜鸟。本题给出一系列弹洞的平面坐标(x,y)，请你编写程序找出冠军和菜鸟。我们假设靶心在原点(0,0)。
输入说明：
输入在第一行中给出一个正整数 N（≤ 10 000）。随后 N 行，每行按下列格式给出：
ID x y
其中 ID 是运动员的编号（由 4 位数字组成）；x 和 y 是其打出的弹洞的平面坐标(x,y)，均为整数，且 0 ≤ |x|, |y| ≤ 100。题目保证每个运动员的编号不重复，且每人只打 1 枪。
输出说明：
输出冠军和菜鸟的编号，中间空 1 格。题目保证他们是唯一的。
输入样列：
3
0001 5 7
1020 -1 3
0233 0 -1
输出样列：
0233 0001
代码：
0xffffffff表示int类型的最大值，用于初始化mn
n = int(input())
mn, mx = 0xffffffff, -1
for i in range(n):
lst = input().split()
x, y = int(lst[1]), int(lst[2])
t = x * x + y * y
if t > mx:
mx = t
ans2 = lst[0]
if t < mn:
mn = t
ans1 = lst[0]
print(ans1, ans2)
