一、阶乘计算
题目描述
输入一个正整数n，输出n!的值，其中n!=123*…*n。
算法描述
n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。
将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。
首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。
输入
输入包含一个正整数n，n< =1000。
输出
输出n!的准确值。
样例输入
10
样例输出
3628800
解法一：暴力循环
n=int(input())
num=[]
k=1
for i in range(1,n+1):
k=k*i
print(k)解法二：math库的factorical函数
import math
print(math.factorial(int(input())))解法三：数组存储 题目要求：使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。（说明数组最后要倒序输出）
n=int(input())
num=[0 for i in range(10000)]#用for循环给数组num添加10000个0值，初始化
length=1#数组长度，求阶乘添加的位数，初始化的0不算
num[0]=1
if n>=2:
for i in range(2,n+1):
jin=0#累乘num[i]后的进位
for j in range(length):
temp=num[j]*i+jin#存储一个乘之后的值，用来判断是否发生进位
jin=int(temp/10)
num[j]=temp%10
while jin>0:#产生进位，数组长度加一，循环判断，若一直产生进位，数组长度则一直加一
num[length]+=jin%10
length+=1
jin=int(jin/10)
while length>0:#倒序输出数组num
length-=1
print(num[length],end='')二、高精度加法
题目描述
输入两个整数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输出即可。
输入
输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。
输出
输出一行，表示a + b的值。
样例输入
20100122201001221234567890
2010012220100122
样例输出
20100122203011233454668012
解法一：直接求和
a=int(input())
b=int(input())
print(a+b)解法二：数组，不愧是VIP的题，有点难到我了
def trans(a):#输入的字符串遍列表输出
A=[]#定义一个列表
for i in range(len(a)):
A.append(eval（a)%10)#eval（) 函数将字符串转换为相应的对象，并返回表达式的结果
a=a[:-1]#删掉a最末尾的数字，左闭右开原则
return A
a=input()
b=input()
A=trans(a)+[0]*(100-len(a))#初始化A，B长度为100
B=trans(b)+[0]*(100-len(b))
C=[0]*101 #初始化
jin=0
length=0
for i in range(100):
temp=A[i]+B[i]+jin
C[i]=temp%10
jin=temp//10
for i in range(100,-1,-1):#倒序查找第一个不为0的C[i]值，获取两数和的位数
while C[i]!=0:
length =i+1
print(length)
break
if length != 0:
break
while length>0:#倒序输出C[i]
length =length-1
print(C[length],end='')解法三：栈结构（A和B不变，C改为栈）
#栈对象
class Stack(object):
def __init__(self, size, top=-1):
self.size = size
self.top = top # 栈顶，初始化为-1
self.stackdata = [] # 空列表，作为数据容器
# 压栈放入数据
def push(self, val):
self.stackdata.append(val)
self.top += 1
# 出栈
def pop(self):
# print(self.top)
if self.top == -1: # 判断栈是否为空
return
else:
self.top -= 1
print(self.stackdata[self.top],end='')
self.stackdata.pop(self.top)
def trans(a):#输入的字符串遍列表输出
A=[]#定义一个列表
for i in range(len(a)):
A.append(eval（a)%10)#eval（) 函数将字符串转换为相应的对象，并返回表达式的结果
a=a[:-1]#删掉a最末尾的数字，左闭右开原则
return A
a=input()
b=input()
A=trans(a)+[0]*(100-len(a))#初始化A，B长度为100
B=trans(b)+[0]*(100-len(b))
C = Stack(101) # 创建空栈C
jin = 0
for i in range(100):
temp = A[i] + B[i] + jin
jin = temp // 10
if jin==0 and temp==0 and i>len(a) and i>len(b):
break
C.push(temp % 10)
# 展示栈数据（也就是输出列表）
# print(C.stackdata,end='')
while C.top!=0:
C.pop()三、Huffuman树
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。
输入格式
输入的第一行包含一个正整数n（n<=100）。
接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。
输出格式
输出用这些数构造Huffman树的总费用。
样例输入
5
5 3 8 2 9
样例输出
59
解法：用sort排序，再用p=p[2::]重置列表p
n=int(input())
p=list(map(int,input().split()))
sum=0
#排序最方便了
for j in range(n-1):#构造次数为n-1次
p.sort()
# print(p)
sum += p[0] + p[1]
p.append(p[0] + p[1])
p=p[2::]
print(sum)四、2n皇后问题
题目描述
给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后
和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两
个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。
输入格式
输入的第一行为一个整数n，表示棋盘的大小。
接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，
如果一个整数为0，表示对应的位置不可以放皇后。
输出格式
输出一个整数，表示总共有多少种放法。
样例输入1
4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
样例输出1
2
样例输入2
4
1 0 1 1
1 1 1 1
1 1 1 1
1 1 1 1
样例输出2
0
解法：代码来自ミの为尔傾心，
n = int(input())
chess = [list(map(int, input().split(' '))) for i in range(n)] # 模拟棋盘
num = 0
def lay(row, n, s, chess): # 放置皇后的函数
global num
if row == n: # 判断是否每行都遍历了
if s == 2: # s=2表示黑皇后，s=3表示白皇后
lay(0, n, 3, chess) # 黑皇后放完开始放白皇后
if s == 3: # 白皇后也放完，计数器加一
num += 1
return
for i in range(n):
if chess[row][i] != 1: # 棋盘位置不等于1表示不能放皇后或者位置被皇后占用
continue
if check(row, i, s, chess): # 判断列和对角线是否有相同皇后
chess[row][i] = s
lay(row + 1, n, s, chess) # 遍历下一行
chess[row][i] = 1
def check(row, i, s, chess):
h = row - 1 # h,l分别是行和列
l = i - 1
for m in range(row - 1, -1, -1): # 判断同一列是否有相同皇后
if chess[m][i] == s:
return False
while h >= 0 and l >= 0: # 判断左上方对角线是否有相同皇后
if chess[h][l] == s:
return False
h -= 1
l -= 1
h = row - 1
l = i + 1
while h >= 0 and l < n: # 判断右上方对角线是否有相同皇后
if chess[h][l] == s:
return False
h -= 1
l += 1
return True
lay(0, n, 2, chess)
print(num)五、报时助手
问题描述
给定当前的时间，请用英文的读法将它读出来。
时间用时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
解答:python字典 d = {key1 : value1, key2 : value2 }
h,m=map(int,input().split(' '))
hour={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',21:'twenty-one',22:'twenty-two',23:'twenty-three'}
minu={1:'ten',2:'twenty',3:'thirty',4:'forty',5:'fifty'}
min={11:'eleven',12:'twelve',13:'thirteen',14:'fourteen',15:'fifteen',16:'sixteen',
17:'seventeen',18:'eighteen',19:'nineteen'}
if m==0:
print(hour[h]+' o’clock')
else:
k=m//10
if k>1:
print(hour[h]+' '+minu[k]+hour[m%10])
elif k==0:
print(hour[h]+' '+hour[m])
else:
print(hour[h]+' '+min[m])英文中的11-19叫法不同，故单独弄了字典min存储
