读入n,m,输出 n!*m!. (1<=n,m<=100) 结果的位数不超过400. 提示：定义一个数组a[400],定义乘法运算，每次乘法结果用数组保存

### 回答1：
题目要求计算n!和m!的乘积，结果的位数不超过400。我们可以定义一个长度为400的数组a来保存乘法结果，然后按照乘法的规则进行计算。

具体来说，我们可以先将n!和m!分别计算出来，然后再将它们相乘。计算n!和m!的方法可以使用循环，从1到n或m依次乘上每个数，将结果保存在数组a中。乘法的过程可以使用竖式计算的方法，即将每个数的每一位与另一个数的每一位相乘，然后将结果相加，最后将结果保存在数组a中。

最后，我们需要将数组a中的结果转换成字符串输出。具体来说，我们可以从数组a的最高位开始，依次将每个数字转换成字符，然后拼接成一个字符串。需要注意的是，如果数组a的最高位是，我们需要将其忽略，因为在数字的最高位是没有意义的。

### 回答2：
题目描述：

输入两个数n和m，然后输出它们的阶乘之积，结果的位数不超过400。

思路分析：

本题其实是求解大数的乘积，我们定义一个数组a[400]来存储结果，再分别计算n!和m!的阶乘，最后将得到的阶乘数组进行乘法运算即可。

对于一个数n的阶乘，我们可以通过循环来计算，将结果存储到数组a中，每次循环都是从数组的高位开始计算，将计算结果存储到数组的低位中。为了方便计算，可以使用一个变量carry来表示进位，当计算出的结果超过10时，将carry置1，否则carry置0。

对于两个数的乘积，我们可以将其中一个数乘以另一个数的每一位，然后累加到结果数组中。具体实现也可以使用两层循环，外层循环遍历较小的数的每一位，内层循环遍历较大的数的每一位，并将结果累加到结果数组中。

代码实现及注释如下：

### 回答3：
这道题目要求我们计算 n! * m! ，其中 n 和 m 的范围在 1 到 100 之间，结果的位数不超过 400 ，因此我们不能简单地通过数值计算来求解。

一个朴素的解题思路是先计算出 n! 和 m! ，再相乘。但是我们会遇到同样的问题，即结果的位数可能非常大。因此，我们需要考虑如何在有限的空间内保存结果。

我们可以定义一个长度为 400 的数组 a，表示结果的每一位。然后，我们可以通过模拟竖式乘法的方式，依次计算 n! 和 m! 的每一位，最后保存在数组 a 中。具体地，我们可以将 n! 和 m! 分别拆分成各自的位数，然后按照竖式乘法的方式相乘并进位，直到计算出结果。

在具体实现过程中，我们可以使用两个数组 p 和 q，表示 n! 和 m! 的各位数字。然后，我们可以分别遍历两个数组的每一位，计算出乘积，再加上进位，最后得到结果的每一位。具体代码可以参考下面的 Python 代码。

n, m = map(int, input().split())

# 求 n! 和 m!
p = [1] # 将 p 初始化为 1
for i in range(2, n+1):
    # 计算 i 的各位数字
    digits = []
    j = i
    while j > 0:
        digits.append(j % 10)
        j //= 10

    # 计算 p *= i
    carry = 0
    for j in range(len(p)):
        if j < len(digits):
            product = p[j] * digits[j] + carry
        else:
            product = p[j] * 1 + carry
        p[j] = product % 10
        carry = product // 10
    if carry > 0:
        p.append(carry)

q = [1] # 将 q 初始化为 1
for i in range(2, m+1):
    # 计算 i 的各位数字
    digits = []
    j = i
    while j > 0:
        digits.append(j % 10)
        j //= 10

    # 计算 q *= i
    carry = 0
    for j in range(len(q)):
        if j < len(digits):
            product = q[j] * digits[j] + carry
        else:
            product = q[j] * 1 + carry
        q[j] = product % 10
        carry = product // 10
    if carry > 0:
        q.append(carry)

# 求 n! * m!
a = [0] * 400 # 将结果数组 a 初始化为 0
for i in range(len(p)):
    for j in range(len(q)):
        k = i + j
        product = p[i] * q[j]
        while product > 0:
            # 更新结果数组 a[k]
            product += a[k]
            a[k] = product % 10
            product //= 10
        k += 1

# 输出结果
i = len(a) - 1
while i >= 0 and a[i] == 0:
    i -= 1
if i < 0:
    print(0)
else:
    for j in range(i, -1, -1):
        print(a[j], end='')
    print()

值得注意的是，我们在计算 p *= i 和 q *= i 时，需要分别计算 i 的各位数字。这是因为，我们需要用到竖式乘法的每一列，而每一列的乘数可能是不同位数的数字。因此，我们需要先将 i 拆分成各位数字，再按照竖式乘法的方式计算。否则，我们将无法处理不同位数的数字相乘的情况。