蓝桥杯个人总结（入门练习-VIP题）

我不是女神ヾ 2022-10-26 14:18 141阅读 0赞

### 给定一个以秒为单位的时间t，要求用“<H>:<M>:<S>” 的格式来表示这个时间。<H>表示时间，表示分钟，而<S>表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。 ###

##### 样例输入 #####

##### 样例输出 #####

0:0:0

num_input = int(input())
    
    hour, compute_num = divmod(num_input, 3600)
    minute, second = divmod(compute_num, 60)
    print('%d:%d:%d' % (hour, minute, second))
    # print('{}:{}:{}'.format(hour, minute, second)) 也可以

这里要注意print函数若要使用格式化且有多个参数，则需要把多个参数括起来

### 给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一： ###

*  1：两个字符串长度不等。比如 Beijing 和 Hebei
 *  2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
 *  3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
 *  4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing  
    编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。

##### 样例输入 #####

BEIjing  
beiJing

##### 样例输出 #####

str_input1 = input()
    str_input2 = input()
    
    if str_input1 == str_input2:
        print('2')
    elif str_input2.upper() == str_input1.upper():
        print('3')
    elif len(str_input1) == len(str_input2):
        print('4')
    else:
        print('1')

### 求出区间\[a,b\]中所有整数的质因数分解。 ###

##### 样例输入 #####

3 10

##### 样例输出 #####

3=3  
4=2\*2  
5=5  
6=2\*3  
7=7  
8=2\*2\*2  
9=3\*3  
10=2\*5

input_num1, input_num2 = [int(v) for v in input().split()]		# 获得输入的两个值
     
    # 下面操作为获得所有的质数
    list_z = []							# 存放质数的列表
    for n in range(2, input_num2 + 1):		# 获得截至到b（包含b）的质数
        flag = True						# 标志位
        for m in range(2, n):			
            if n % m == 0:				# 如果有其他的因子则不为质数
                flag = False			# 不是质数，置为假
                break
        if flag:				# 如果为真则在列表内添加该值
            list_z.append(n)
    
    # 下面的操作为分解因子
    for n in range(input_num1, input_num2 + 1):		# 开始遍历
        if n in list_z:				# 若该数为质数，则直接输出
            print('{}={}'.format(n, n))
        else:						# 不位质数则分解因子
            print('{}='.format(n), end='')
            f = 0				# 列表的标志位
            while True:			# 获得因子
                if n % list_z[f] == 0:			# 能整除
                    print('{}*'.format(list_z[f]), end='')
                    n = int(n / list_z[f])		# 注意类型转换
                    if n in list_z:				# 若为最后一值则直接输出，注意这里的if位置（为了减小开支）
                        print('{}'.format(n))
                        break					# 退出循环
                else:							# 若不能整除则换下一个列表值
                    f += 1

如果出现太多的if-else则会增加系统的资源消耗

### 给定一个N阶矩阵A，输出A的M次幂（M是非负整数） ###

例如：  
　　A =  
　　1 2  
　　3 4  
　　A的2次幂  
　　7 10  
　　15 22

##### 样例输入 #####

2 2  
1 2  
3 4

##### 样例输出 #####

7 10  
15 22

from functools import reduce
    input_num1, input_num2 = map(lambda x: int(x), input().split())				# 获得第一行的数据
    
    matrix_old = []				
    matrix_new = []
    for x in range(input_num1):				# 获得矩阵的值并创建两个二维列表
        input_matrix = input().split()
        matrix_old.append([int(x) for x in input_matrix])
        matrix_new.append([int(x) for x in input_matrix])
    
    
    if input_num2 == 0:						# 当次方为0时，输出与他同型单位矩阵
        matrix_res = [[0 for x in range(input_num1)] for y in range(input_num1)]
        for n in range(input_num1):	
            matrix_res[n][n] = 1
    
    for o in range(input_num2 - 1):			# 当次方为其他时，矩阵的乘法
        matrix_res = [[0 for x in range(input_num1)] for y in range(input_num1)]		# 注意这里的位置，它只能在里面
        for n in range(input_num1):				# 遍历矩阵的行
            for m in range(input_num1):			# 遍历矩阵的列
                for k in range(input_num1):		# 开始乘法：对应位置一一相乘然后相加
                    matrix_res[n][m] += matrix_new[n][k] * matrix_old[k][m]		# 这里的三个矩阵各不相同
        matrix_new = matrix_res					# 矩阵的赋值，要注意python里面的赋值都赋得是地址，着刚好解释了上面的matrix_res的位置
    
    matrix_res = list(map(lambda x: ' '.join(list(map(lambda y: str(y), x))) + '\n', matrix_res))	# 对该二维列表里的每个值都变成字符类型
    
    print(reduce(lambda n, m: n + m, matrix_res, ''))		# 输出结果，注意这里的lambda函数一定要有两个参数

注意这里的join函数是针对数组里面的字符串参数，而不是整型类型。还有注意这里的矩阵乘法

### 平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。 ###

##### 样例输入 #####

1 1 3 3  
2 2 4 4

##### 样例输出 #####

1.00

x1, y1, x2, y2 = [float(x) for x in input().split()]
    x3, y3, x4, y4 = [float(x) for x in input().split()]
    
    n1 = max(min(x1, x2), min(x3, x4))	# 第一个点的横纵坐标
    m1 = min(max(y1, y2), max(y3, y4))
    
    n2 = min(max(x1, x2), max(x3, x4))	# 第二个点的横纵坐标
    m2 = max(min(y1, y2), min(y3, y4))
    
    res = abs(float((n2 - n1) * (m2 - m1)))		# 消去负号
    
    if n1 < n2 and m1 > m2:				# 若第一个点在第二个点的左上方则输出计算结果
        print('%.02f' % res)
    else:					# 这里的条件可以写成n1 > n2 and m1 > m2
        print('0.00')			# 若第一个点在第二个点的右上方则输出计算结果0.00

这里的矩形只有三种情况：相交，重叠，不相交。其中第一个点在第二个点的左上方包含了相交于重叠，而第一个点在第二个点的右上方包含了不相交

### 回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。 ###

交换的定义是：交换两个相邻的字符  
　　例如mamad  
　　第一次交换 ad : mamda  
　　第二次交换 md : madma  
　　第三次交换 ma : madam (回文！完美！)

##### 样例输入 #####

5  
mamad

##### 样例输出 #####

input_num = int(input())
    input_str = list(input())
    
    temp_test = list(set(input_str))		# 将字符串列表化，因为不可以对字符串的索引进行操作
    
    exist = True				# 如果存在则计算次数，不存在则直接结束
    if input_num % 2 == 0:		# 对于字符串长度是偶数的字符串，每个字符的数目都是偶数，一旦出现奇数，则输出impossible。
        for x in temp_test:
            if input_str.count(x) % 2 != 0:
                exist = False
                print('Impossible')
                break
    else:
        flag = 0			# 判断字符串内的奇数字符的个数
        for x in temp_test:		# 对于字符串长度是奇数的字符串，只能有一个字符的数目是奇数，一旦出现两个，则输出impossible。
            if input_str.count(x) % 2 != 0:
                flag += 1
            if flag > 1:		# 如果个数>=2不存在
                exist = False
                print('Impossible')
                break
    
    if exist:		# 计算次数
        count = 0		# 标记量
        temp_list = input_str
        for x in range(input_num // 2):		# 遍历次数
    
            if temp_list.count(temp_list[0]) != 1:	# 如果首字符在字符串内出现的次数大于等于2
                distance = temp_list[::-1].index(temp_list[0])			# 计算距离
                count += distance
                temp_list.pop(len(temp_list) - distance - 1)
                temp_list = temp_list[1::]	# 对进行操作的列表的长度进行改变（减去列表的第一个元素）
            else:			# 如果首字符在字符串内出现的次数等于1
                distance = len(temp_list) // 2
                temp_list.pop(0)			
                # 上面的这一步至关重要，因为当单字符的元素（次数只能是1，如果是3则不会进到这个else里面来）出现
                # 在第一位时而后面的找不到与他相匹配的。我们则先把他拿出来，想象着等所有其他的非单字符（上面的if）都排列好之后再把单字符插进去
                # 而再这里面我们提前了这一动作，提前到我们遇到这单字符的时候就开始操作
                count += distance
        print(count)

python里面的for和if里面没有域的说法，也就是说在for和if里面定义的变量是全局变量  
注意这里的字符串是可以用索引，但是不可通过索引来给某个位置赋值

> 贪心算法（greedy algorithm），又称贪婪算法，是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择， 从而希望导致结果是最好或最优的算法。比如在旅行推销员问题中，如果旅行员每次都选择最近的城市，那这就是一种贪心算法。  
> —————— 摘自维基百科
> 
> 注释：可以理解为贪心算法每一步都做出当前最正确的决定（局部最优解），通过堆叠局部最优解得到全局最优解。它只是一个想法并不是具体的算法，在实际应用中需要我们来选择合适贪心算法
> 
> > 贪心策略:  
> > 对于偶数的字符串，我们在倒置的字符串内查找第一个字符，算出的值为需要移动的距离，接下来就需要修改数组了再将数组赋值。因为一头一尾两个字符已被排好就可以不用管了，可直接删除了  
> > 对于奇数的字符串，其实贪心策略和偶数的时候大体一致，只是需要将只出现一次的字符以到中间即可

### Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。 ###

比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。  
　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法：  
　　十二亿三千四百五十六万七千零九  
　　用汉语拼音表示为  
　　shi er yi san qian si bai wu shi liu wan qi qian ling jiu  
　　这样他只需要照着念就可以了。  
　　你的任务是帮他设计这样一个系统：给定一个阿拉伯数字串，你帮他按照中文读写的规范转为汉语拼音字串，相邻的两个音节用一个空格符格开。  
　　注意必须严格按照规范，比如说“10010”读作“yi wan ling yi shi”而不是“yi wan ling shi”，“100000”读作“shi wan”而不是“yi shi wan”，“2000”读作“er qian”而不是“liang qian”。

##### 样例输入 #####

1234567009

##### 样例输出 #####

shi er yi san qian si bai wu shi liu wan qi qian ling jiu

from functools import reduce
    input_str = list(input())		# 将输入的字符串列表化
    
    check_list1 = ['ling', 'yi', 'er', 'san', 'si', 'wu', 'liu', 'qi', 'ba', 'jiu']		# 数字对应
    check_list2 = ['qian', '', 'shi', 'bai']	# 进位对应
    put_list = [' ' for x in range(len(input_str))]		# 创建与输入字符串相等长度的列表
    flag = 1	# 用于判断进位
    
    for x in range(len(input_str) - 1, -1, -1):		# 给put_list具体赋值
        put_list[x] = check_list1[int(input_str[x])]	# 数字与拼音对应
        put_list[x] += ' ' + check_list2[flag % 4]		# 进位与位数对应
        flag += 1		# 用于标记位数
    
    for x in range(1, len(input_str)):		# 从第二个开始循环，因为第一个定不为0
        if input_str[x] == '0':			# 若在原数组发现一个0
            if input_str[x - 1] == '0':	# 而又在上一位也是0
                put_list[x] = ' '		# 则忽略该0，将他赋值为空格
            else:
                put_list[x] = 'ling'	# 上一位没有0，则赋值ling
    
    # 此时的put_list长度为原字符串长度，但经过下面的操作后数组长度改变
    if len(input_str) >= 9:			# 长度大于等于为9，加入万，亿
        put_list.insert(len(input_str) - 4, 'wan')	
        put_list.insert(len(input_str) - 8, 'yi')
    elif len(input_str) >= 5:		# 长度大于等于为5
        put_list.insert(len(input_str) - 4, 'wan')
    
    if put_list[0] == 'yi shi':			# 当第一位为一十
        put_list[0] = 'shi'
    
    while put_list[len(put_list) - 1] == 'ling' or  put_list[len(put_list) - 1].strip() == '':		# 用与检查末尾多余的0和空格
        put_list.pop()		# 则删除
    
    print(reduce(lambda x, y: x.strip() + ' ' + y.strip(), put_list))		# 利用strip函数来脱出字符串两边多余的空格

在里要注意给空数组赋值时无法通过索引赋值，具体如下

put_list = []
    put_list[0] = 1			# 这样无法赋值

### 最近FJ为他的奶牛们开设了数学分析课，FJ知道若要学好这门课，必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏，寓教于乐，提高奶牛们的计算能力。 ###

不妨设  
　　An=sin(1–sin(2+sin(3–sin(4+…sin(n))…)  
　　Sn=(…(A1+n)A2+n-1)A3+…+2)An+1  
　　FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式，以方便奶牛们做题。

##### 样例输入 #####

##### 样例输出 #####

((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1

input_int = int(input())
    
    def An(s, i):			# An函数递归
        if i == 1:		# 到一则退出
            return 'sin(' + s + ')'
        if i % 2 == 0:		# 用于正负号的判断
            return An(str(i - 1) + '-sin(' + s + ')', i - 1)
        else:
            return An(str(i - 1) + '+sin(' + s + ')', i - 1)
    
    def Sn(s, i):			# Sn函数递归
        if i == 1:		# 到一则退出
            return s + '+1'
        return Sn('(' + s + '+' + str(i) + ')' + An(str(input_int + 2 - i), input_int + 2 - i), i - 1)
    print(Sn(An('1', 1), input_int))

注意递归函数要有递归出口，函数调用（注意return的使用）

### FJ在沙盘上写了这样一些字符串： ###

A1 = “A”  
　　A2 = “ABA”  
　　A3 = “ABACABA”  
　　A4 = “ABACABADABACABA”  
　　… …  
　　你能找出其中的规律并写所有的数列AN吗？

##### 样例输入 #####

##### 样例输出 #####

ABACABA

input_int = int(input())
    
    def An(s, i):
        if i == input_int:		# 是从小到大开始迭代
            return s
        return An(s + chr(ord('A') + i) + s, i + 1)		# 注意chr函数和ord函数的作用
    
    
    print(An('A', 1))

### 有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。 ###

每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。  
　　给出所有芯片的测试结果，问哪些芯片是好芯片。

##### 样例输入 #####

3  
1 0 1  
0 1 0  
1 0 1

##### 样例输出 #####

1 3

input_int = int(input())
    matrix = ['' for x in range(input_int)]
    for x in range(input_int):
        matrix[x] = input().split()
    
    for x in range(input_int):
        if matrix.count(matrix[x]) > x / 2:
            flag = 0
            for y in range(matrix.count(matrix[x])):
                flag = matrix.index(matrix[x], flag) + 1
                print(flag, end=' ')
            break

主要思路是因为好的比坏的多，而不管是那个好的芯片测试那个好的芯片结果都是一样的，所以在矩阵中相同的行有很多，且最多的行所代表的索引就是好的芯片

### 话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先t米或以上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。 ###

然而有些比赛相当漫长，全程观看会耗费大量时间，而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1（表示每秒兔子能跑v1米），乌龟的速度v2，以及兔子对应的t，s值，以及赛道的长度l——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找到了你——清华大学计算机系的高才生——请求帮助，请你写一个程序，对于输入的一场比赛的数据v1，v2，t，s，l，预测该场比赛的结果。

##### 样例输入 #####

10 5 5 2 20

##### 样例输出 #####

D  
4

v1, v2, t, s, l = map(lambda x: int(x), input().split())
    
    already_go1 = already_go2 = 0	# 两者分别走的路程
    time = 0				# 计时表
    flag = False
    
    while True:
        already_go1 += v1			# 一次轮回：兔子走一次，乌龟走一次
        already_go2 += v2			# 一次轮回判断一次
        time += 1				# 时间加一
    
        if already_go1 == already_go2 >= l:		# 若同时大于等于总路程
            print('D')
            print(time)
            break
        elif already_go1 >= l:			# 若兔子大于等于总路程
            print('R')
            print(time)
            break
        elif already_go2 >= l:			# 若乌龟大于等于总路程
            print('T')
            print(time)
            break
    
        if already_go1 >= already_go2 + t:		# 若出现兔子休息，则出现了第二轮
            for x in range(1, s + 1):			# 兔子休息的秒数当做次数用于乌龟每次跑步
                already_go2 += v2
                time += 1
                if already_go2 >= l:			# 判断乌龟是否在兔子休息的时候已大目的地
                    print('T')
                    print(time)
                    flag = True					# 通知外层结束循环
                    break
        
        if flag:			# 收到通知，结束循环
            break

### 回形取数就是沿矩阵的边取数，若当前方向上无数可取或已经取过，则左转90度。一开始位于矩阵左上角，方向向下。 ###

##### 样例输入 #####

3 3  
1 2 3  
4 5 6  
7 8 9

##### 样例输出 #####

1 4 7 8 9 6 3 2 5

import math
    from functools import reduce
    input_x, input_y = map(lambda x: int(x), input().split())
    matrix = []
    for x in range(input_x):	# 获得矩阵
        matrix.append(list(map(lambda m: int(m), input().split())))
    
    output_list = []	# 输出列表
    circle = math.ceil(min(input_x, input_y) / 2)	# 判断圈数
    
    for x in range(circle):		# 循环一定的圈数
        w = s = e = n = 0		# 获得每个方向最后循环的值
        for w in range(x, input_x - x):		# 西，列不变
            output_list.append(matrix[w][x])	
        for s in range(x + 1, input_y - x):	# 南，行不变
            output_list.append(matrix[w][s])
        for e in range(input_x - x - 2, x - 1, -1):	# 东，列不变
            if x == circle - 1 and input_y % 2 == 1:	# 当到最后一次且列为单数
                break
            output_list.append(matrix[e][s])
        for n in range(input_y - x - 2, x, -1):	# 北，行不变
            if x == circle - 1 and input_x % 2 == 1:	# 当到最后一次且行为单数
                break
            output_list.append(matrix[e][n])
    
    print(reduce(lambda x, y: str(x) + ' ' + str(y), output_list))	# 输出列表结果

思路：先算出每个矩阵的层数，再循环一定的次数。在每一次里面从东，南，西，北开始获得数据。但要注意最后一次是‘一’字，还是‘l’，若是前两种则需要判断西，北是否有遍历的需要

*  注意for-else在有break时无法触发

### 给定当前的时间，请用英文的读法将它读出来。 ###

时间用时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”。

##### 样例输入 #####

0 15

##### 样例输出 #####

zero fifteen

input_x, input_y = map(lambda x: int(x), input().split())
    
    time_list = { '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'}
     # 上面的是为了让数字与英语一一对应
    out_put = { 'hour': '', 'minute': ''}	# 输出的字典
    
    
    def get_time(param):		# 输入一个值，并把它转化为英语
        if param <= 20:		# 小于等于20是直接输出
            return time_list[str(param)]
        else:	# 大于20时，获得十位的值 + 个位的值
            return time_list[str((param // 10) * 10)] + ' ' + time_list[str(param % 10)]
    
    if input_y == 0:		# 当第一位时0时
        out_put['hour'] = get_time(input_x)
        out_put['minute'] = "o'clock"
    else:		# 其他情况
        out_put['hour'] = get_time(input_x)
        out_put['minute'] = get_time(input_y)
    
    print('%s %s' % (out_put["hour"], out_put['minute']))	# 输出格式化
    # print('{} {}'.format(out_put["hour"], out_put['minute']))

注意对字典使用out\_put\[x\]方法来获得值要小心x的类型（只能为字符型）。另外的对输出进行格式化时要把**参数都括起来**

### Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。 ###

给出一列数\{pi\}=\{p0, p1, …, pn-1\}，用这列数构造Huffman树的过程如下：  
　　1. 找到\{pi\}中最小的两个数，设为pa和pb，将pa和pb从\{pi\}中删除掉，然后将它们的和加入到\{pi\}中。这个过程的费用记为pa + pb。  
　　2. 重复步骤1，直到\{pi\}中只剩下一个数。  
　　在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。  
　　本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。

例如，对于数列\{pi\}=\{5, 3, 8, 2, 9\}，Huffman树的构造过程如下：  
　　1. 找到\{5, 3, 8, 2, 9\}中最小的两个数，分别是2和3，从\{pi\}中删除它们并将和5加入，得到\{5, 8, 9, 5\}，费用为5。  
　　2. 找到\{5, 8, 9, 5\}中最小的两个数，分别是5和5，从\{pi\}中删除它们并将和10加入，得到\{8, 9, 10\}，费用为10。  
　　3. 找到\{8, 9, 10\}中最小的两个数，分别是8和9，从\{pi\}中删除它们并将和17加入，得到\{10, 17\}，费用为17。  
　　4. 找到\{10, 17\}中最小的两个数，分别是10和17，从\{pi\}中删除它们并将和27加入，得到\{27\}，费用为27。  
　　5. 现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。

##### 样例输入 #####

5  
5 3 8 2 9

##### 样例输出 #####

input_int = int(input())
    input_list = [int(x) for x in input().split()]	# 获得数组
    
    num_sum = 0		# 总和
    for x in range(len(input_list) - 1):		# Huffman树构造次数
        min_value = 0		# 最小值
        for y in range(2):		# 寻找两次最小值
            min_value += min(input_list)	# 寻找最小值并求和
            input_list.remove(min(input_list))	# 删除该最小值
        input_list.append(min_value)	# 添加最小值和
        num_sum += min_value	# 相加每次的最小值和
    
    print(num_sum)

### 问题描述 ###

输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。

### 算法描述 ###

由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。  
　　定义一个数组A，A\[0\]用于存储a的个位，A\[1\]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。  
　　计算c = a + b的时候，首先将A\[0\]与B\[0\]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C\[0\]，即C\[0\]等于(A\[0\]+B\[0\])%10。然后计算A\[1\]与B\[1\]相加，这时还应将低位进上来的值r也加起来，即C\[1\]应该是A\[1\]、B\[1\]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C\[1\]中。依此类推，即可求出C的所有位。  
　　最后将C输出即可。

##### 样例输入 #####

20100122201001221234567890  
2010012220100122

##### 样例输出 #####

20100122203011233454668012

input_max = list(input())[::-1]		# 将输入的字符串转化为列表并倒序
    input_min = list(input())[::-1]		# （倒序）因为需要从各位开始时相加
    
    if len(input_max) < len(input_min):		# 先获得两个数组的长度，并对应赋值
        input_max, input_min = input_min, input_max
    
    for x in range(len(input_min)):		# 只遍历最小的数组
        input_max[x] = int(input_max[x]) + int(input_min[x])	# 这里注意类型的转换，python为强类型语言无法类型转换
    
    input_max = list(map(lambda x: int(x), input_max))	# 对每个值进行类型转换
    for l in range(len(input_max)):		# 遍历数组，用于进位
        if input_max[l] >= 10:		# 大于10才需要进位
            try:
                input_max[l + 1] += input_max[l] // 10	# l不是最后一位则不报错，如果是的话则报错
            except:
                input_max.append(input_max[l] // 10)	# 最后一位还需要进位时则添加（这步好像有点多余，只需将遍历对象-1也可达到相同的结果）
            finally:
                input_max[l] = input_max[l] % 10	# 个位赋值
    
    for x in range(len(input_max) - 1, -1, -1):	# 从最后一位开始来连接数字
        print(input_max[x], end='')
    # print(str(reduce(lambda x, y: str(x) + str(y), output_list))[::-1])

提出一种解决超出精度数字问题的方法：数组

### 问题描述 ###

输入一个正整数n，输出n!的值。  
　　其中n!=1*2*3\*…\*n。

### 算法描述 ###

n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A\[0\]表示a的个位，A\[1\]表示a的十位，依次类推。  
　　将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。  
　　首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。

##### 样例输入 #####

##### 样例输出 #####

3628800

input_int = int(input())
    
    output_list = [1]	# 初始值为1
    for x in range(1, input_int + 1):	
        output_list = [v * x for v in output_list]	# 将每个值对应相乘
        for l in range(len(output_list)):		# 作用同上
            if output_list[l] >= 10:
                try:
                    output_list[l + 1] += output_list[l] // 10
                except:
                    output_list.append(output_list[l] // 10)
                finally:
                    output_list[l] = output_list[l] % 10
    
    for x in range(len(output_list) - 1, -1, -1):	# 作用同上
        print(output_list[x], end='')
    # print(str(reduce(lambda x, y: str(x) + str(y), output_list))[::-1])
    # 这里注意不可使用str函数直接转换int类型数据，因为上面逻辑有误，如最后一位为20时

### 蓝桥杯的手算题攻略 ###

来源：CSDN——罗勇军  
网址：[https://blog.csdn.net/weixin\_43914593/article/details/115795620][https_blog.csdn.net_weixin_43914593_article_details_115795620]

本人只用于个人学习与记录

[https_blog.csdn.net_weixin_43914593_article_details_115795620]: https://blog.csdn.net/weixin_43914593/article/details/115795620