1002 写出这个数
问题描述：
读入一个正整数 n，计算其各位数字之和，用汉语拼音写出和的每一位数字。
输入说明：
每个测试输入包含 1 个测试用例，即给出自然数 n 的值。这里保证 n 小于 10100。
输出说明：
在一行内输出 n 的各位数字之和的每一位，拼音数字间有 1 空格，但一行中最后一个拼音数字后没有空格。
输入样列：
1234567890987654321123456789
输出样列：
yi san wu
代码：
mp = ['ling', 'yi', 'er', 'san', 'si', 'wu', 'liu', 'qi', 'ba', 'jiu']
list1 = list(input())
sum = 0
for i in list1:
sum += int(i)
res = []
for i in list(str(sum)):
res.append(mp[int(i)])
print(' '.join(res))
1005 继续(3n+1)猜想
问题描述：
卡拉兹(Callatz)猜想已经在1001中给出了描述。在这个题目里，情况稍微有些复杂。
当我们验证卡拉兹猜想的时候，为了避免重复计算，可以记录下递推过程中遇到的每一个数。例如对 n=3 进行验证的时候，我们需要计算 3、5、8、4、2、1，则当我们对 n=5、8、4、2 进行验证的时候，就可以直接判定卡拉兹猜想的真伪，而不需要重复计算，因为这 4 个数已经在验证3的时候遇到过了，我们称 5、8、4、2 是被 3“覆盖”的数。我们称一个数列中的某个数 n 为“关键数”，如果 n 不能被数列中的其他数字所覆盖。
现在给定一系列待验证的数字，我们只需要验证其中的几个关键数，就可以不必再重复验证余下的数字。你的任务就是找出这些关键数字，并按从大到小的顺序输出它们。
输入说明：
每个测试输入包含 1 个测试用例，第 1 行给出一个正整数 K (<100)，第 2 行给出 K 个互不相同的待验证的正整数 n (1<n≤100)的值，数字间用空格隔开。
输出说明：
每个测试用例的输出占一行，按从大到小的顺序输出关键数字。数字间用 1 个空格隔开，但一行中最后一个数字后没有空格。
输入样列：
6
3 5 6 7 8 11
输出样列：
7 6
代码：
n = int(input())
a = list(map(int, input().split()))
for i in a:
t = i
while t > 1:
if t % 2 == 1:
t = 3 * t + 1
t //= 2
if t in a:
a[a.index(t)] = -1
a.sort(reverse=True)
print(' '.join(str(i) for i in a if i > 0))
1007 素数对猜想
问题描述：
让我们定义dn为：dn=pn+1−pn，其中pi是第i个素数。显然有d1=1，且对于n>1有dn是偶数。“素数对猜想”认为“存在无穷多对相邻且差为2的素数”。
现给定任意正整数N(<105)，请计算不超过N的满足猜想的素数对的个数。
输入说明：
输入在一行给出正整数N
输出说明：
在一行中输出不超过N的满足猜想的素数对的个数。
输入样列：
20
输出样列：
4
代码：
防止超时就直接用埃筛了
def prime(n, result):
primes = [True] * (n + 2)
p = 2
while p <= n:
if primes[p]:
result.append(p)
for i in range(p * 2, n + 1, p):
primes[i] = False
p += 1
a = int(input())
result = []
prime(a, result)
num = 0
for i in range(len(result) - 1):
if (result[i + 1] - result[i] == 2):
num += 1
print(num)
1019 数字黑洞
问题描述：
给定任一个各位数字不完全相同的 4 位正整数，如果我们先把 4 个数字按非递增排序，再按非递减排序，然后用第 1 个数字减第 2 个数字，将得到一个新的数字。一直重复这样做，我们很快会停在有“数字黑洞”之称的 6174，这个神奇的数字也叫 Kaprekar 常数。
例如，我们从6767开始，将得到
7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174
7641 - 1467 = 6174
… …
现给定任意 4 位正整数，请编写程序演示到达黑洞的过程。
输入说明：
输入给出一个 (0,104) 区间内的正整数 N。
输出说明：
如果 N 的 4 位数字全相等，则在一行内输出 N - N = 0000；否则将计算的每一步在一行内输出，直到 6174 作为差出现，输出格式见样例。注意每个数字按 4 位数格式输出。
输入样列：
样例1：
6767
样例2：
2222
输出样列：
样例1：
7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174
样例2：
2222 - 2222 = 0000
代码：
注意前导
num = input().rjust(4, '0')
while True:
a = ''.join(sorted(num)).rjust(4, '0')
b = ''.join(sorted(num, reverse=True)).rjust(4, '0')
num = str(int(b) - int(a)).rjust(4, '0')
print("%s - %s = %s" % (b, a, num))
if num in ('0000', '6174'):
break
1022 D进制的A+B
问题描述：
输入两个非负 10 进制整数 A 和 B (≤230−1)，输出 A+B的 D (1<D≤10)进制数。
输入说明：
输入在一行中依次给出 3 个整数 A、B 和 D。
输出说明：
输出 A+B 的 D 进制数。
输入样列：
123 456 8
输出样列：
1103
代码：
A, B, D = map(int, input().split())
C = A + B
res = []
while C >= D:
res.append(str(C % D))
C //= D
res.append(str(C))
res = res[::-1]
print(''.join(res))
1035 插入与归并
问题描述：
根据维基百科的定义：
插入排序是迭代算法，逐一获得输入数据，逐步产生有序的输出序列。每步迭代中，算法从输入序列中取出一元素，将之插入有序序列中正确的位置。如此迭代直到全部元素有序。
归并排序进行如下迭代操作：首先将原始序列看成 N 个只包含 1 个元素的有序子序列，然后每次迭代归并两个相邻的有序子序列，直到最后只剩下 1 个有序的序列。
现给定原始序列和由某排序算法产生的中间序列，请你判断该算法究竟是哪种排序算法？
输入说明：
输入在第一行给出正整数 N (≤100)；随后一行给出原始序列的 N 个整数；最后一行给出由某排序算法产生的中间序列。这里假设排序的目标序列是升序。数字间以空格分隔。
输出说明：
首先在第 1 行中输出Insertion Sort表示插入排序、或Merge Sort表示归并排序；然后在第 2 行中输出用该排序算法再迭代一轮的结果序列。题目保证每组测试的结果是唯一的。数字间以空格分隔，且行首尾不得有多余空格。
输入样列：
样例1：
10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0
样例2：
10
3 1 2 8 7 5 9 4 0 6
1 3 2 8 5 7 4 9 0 6
输出样列：
样例1：
Insertion Sort
1 2 3 5 7 8 9 4 6 0
样例2：
Merge Sort
1 2 3 8 4 5 7 9 0 6
代码：
比较插入和归并的区别就可以很容易判断是插入还是归并了，插入是保证前几个数有序，归并是每组内的数有序
def check(lst1, lst2):
idx = 0
for i in range(len(lst2) - 1):
if lst2[i] > lst2[i + 1]:
idx = i + 1
break
if lst1[idx:] == lst2[idx:]:
result = sorted(lst1[:idx + 1]) + lst2[idx + 1:]
return True, result
else:
cnt = 2
result = lst2
while result == lst2:
sub_lst = [sorted(lst2[i:i + cnt]) for i in range(0, len(lst2), cnt)]
result = [num for sub in sub_lst for num in sub]
cnt *= 2
return False, result
num = int(input())
lst1 = [int(i) for i in input().split()]
lst2 = [int(i) for i in input().split()]
result = []
flag, result = check(lst1, lst2)
if flag:
print("Insertion Sort")
else:
print("Merge Sort")
print(" ".join([str(i) for i in result]))
1044 火星数字
问题描述：
火星人是以 13 进制计数的：
- 地球人的 0 被火星人称为 tret。
- 地球人数字 1 到 12 的火星文分别为：jan, feb, mar, apr, may, jun, jly, aug, sep, oct, nov, dec。
- 火星人将进位以后的 12 个高位数字分别称为：tam, hel, maa, huh, tou, kes, hei, elo, syy, lok, mer, jou。
例如地球人的数字 29 翻译成火星文就是 hel mar；而火星文 elo nov 对应地球数字 115。为了方便交流，请你编写程序实现地球和火星数字之间的互译。
输入说明：
输入第一行给出一个正整数 N（<100），随后 N 行，每行给出一个 [0, 169) 区间内的数字 —— 或者是地球文，或者是火星文。
输出说明：
对应输入的每一行，在一行中输出翻译后的另一种语言的数字。
输入样列：
4
29
5
elo nov
tam
输出样列：
hel mar
may
115
13
代码：
x = ['tret', 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jly', 'aug', 'sep', 'oct', 'nov', 'dec']
y = ['', 'tam', 'hel', 'maa', 'huh', 'tou', 'kes', 'hei', 'elo', 'syy', 'lok', 'mer', 'jou']
def earth(num):
y_ = num // 13
x_ = num % 13
if y_ == 0:
print(x[x_])
else:
if x_ == 0:
print(y[y_])
else:
print(y[y_], x[x_])
def huo(string):
lst = string.split()
if len(lst) == 1:
if lst[0] in x:
num = x.index(lst[0])
else:
num = y.index(lst[0]) * 13
print(num)
else:
y_, x_ = lst[0], lst[1]
num = y.index(y_) * 13 + x.index(x_)
print(num)
n = eval(input())
for i in range(n):
string = input()
if string.isdigit():
earth(int(string))
else:
huo(string)
1077 互评成绩计算
问题描述：
在浙大的计算机专业课中，经常有互评分组报告这个环节。一个组上台介绍自己的工作，其他组在台下为其表现评分。最后这个组的互评成绩是这样计算的：所有其他组的评分中，去掉一个最高分和一个最低分，剩下的分数取平均分记为 G1；老师给这个组的评分记为 G2。该组得分为 (G1+G2)/2，最后结果四舍五入后保留整数分。本题就要求你写个程序帮助老师计算每个组的互评成绩。
输入说明：
输入第一行给出两个正整数 N（> 3）和 M，分别是分组数和满分，均不超过 100。随后 N 行，每行给出该组得到的 N 个分数（均保证为整型范围内的整数），其中第 1 个是老师给出的评分，后面 N−1 个是其他组给的评分。合法的输入应该是 [0,M] 区间内的整数，若不在合法区间内，则该分数须被忽略。题目保证老师的评分都是合法的，并且每个组至少会有 3 个来自同学的合法评分。
输出说明：
为每个组输出其最终得分。每个得分占一行。
输入样列：
6 50
42 49 49 35 38 41
36 51 50 28 -1 30
40 36 41 33 47 49
30 250 -25 27 45 31
48 0 0 50 50 1234
43 41 36 29 42 29
输出样列：
42
33
41
31
37
39
代码：
注意四舍五入即可
n, m = map(int, input().split())
for i in range(n):
score_lst = input().split()
g2 = int(score_lst[0])
con = 0
max, min = 0, m
sum = 0.0
for i in range(1, n):
s = int(score_lst[i])
if s in range(0, m + 1):
con += 1
sum += s
if s < min:
min = s
if s > max:
max = s
sum = sum - min - max
g1 = sum / (con - 2)
score = (g1 + g2) / 2
print("%d" % (int(score + 0.5)))
1079 延迟的回文数
问题描述：
给定一个 k+1 位的正整数 N，写成 ak ⋯a1 a0 的形式，其中对所有 i 有 0≤ai <10 且 ak >0。N 被称为一个回文数，当且仅当对所有 i 有 ai =ak−i 。零也被定义为一个回文数。非回文数也可以通过一系列操作变出回文数。首先将该数字逆转，再将逆转数与该数相加，如果和还不是一个回文数，就重复这个逆转再相加的操作，直到一个回文数出现。如果一个非回文数可以变出回文数，就称这个数为延迟的回文数。（定义翻译自 https://en.wikipedia.org/wiki/Palindromic_number ）
给定任意一个正整数，本题要求你找到其变出的那个回文数。
输入说明：
输入在一行中给出一个不超过1000位的正整数。
输出说明：
对给定的整数，一行一行输出其变出回文数的过程。每行格式如下
A + B = C
其中 A 是原始的数字，B 是 A 的逆转数，C 是它们的和。A 从输入的整数开始。重复操作直到 C 在 10 步以内变成回文数，这时在一行中输出 C is a palindromic number.；或者如果 10 步都没能得到回文数，最后就在一行中输出 Not found in 10 iterations.。
输入样列1：
97152
输出样列1：
97152 + 25179 = 122331
122331 + 133221 = 255552
255552 is a palindromic number.
输入样列2：
196
输出样列2：
196 + 691 = 887
887 + 788 = 1675
1675 + 5761 = 7436
7436 + 6347 = 13783
13783 + 38731 = 52514
52514 + 41525 = 94039
94039 + 93049 = 187088
187088 + 880781 = 1067869
1067869 + 9687601 = 10755470
10755470 + 07455701 = 18211171
Not found in 10 iterations.
代码：
last = input()
i = 0
while True:
a = last
b = a[::-1]
if a == b:
print('%s is a palindromic number.' % last)
break
if i == 10:
print('Not found in 10 iterations.')
break
last = str(int(a) + int(b))
print(a, '+', b, '=', last)
i += 1
