B - N! HDU - 1042

Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N!

Input

One N in one line, process to the end of file.

Output

For each N, output N! in one line.

Sample

Inputcopy	Outputcopy
1 2 3	1 2 6

翻译：

这个问题是计算给定整数 N 的阶乘 N!，其中 0 ≤ N ≤ 10000。阶乘的定义是从 1 到 N 的所有整数的乘积。

输入：

每行输入一个整数 N，直到文件结束为止。

输出：

对于每个输入的 N，输出其阶乘 N! 的结果。

示例：

输入：	输出：
1 2 3	1 2 6

C ++

#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string.h>
#include <math.h>
using namespace std;
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        int i,j,sum,digits=1;//10000进制的位数
        int a[10001]={1};
        for(i=2; i<=n; i++)
        {
            sum=0;//进位
            for(j=0; j<digits; j++)
            {
                a[j]=a[j]*i+sum;
                sum=a[j]/10000;
                a[j]%=10000;
            }
            if(sum>0)//最高位的进位
                a[digits++]=sum;
        }
        //输出高位原样输出,低位的高位补0,一位一补
        printf("%d",a[digits-1]);
        for(i=digits-2; i>=0; i--)
            printf("%04d", a[i]);
        printf("\n");
    }
    return 0;
}

 注释

1. 引入头文件：

   • 包括标准输入输出头文件<stdio.h>。
   • 包括一些C++标准库的头文件<algorithm>, <iostream>, <string.h>, <math.h>。

2. 主函数main：

   • 定义一个整数变量n用于存储输入的数字。

3. 循环读取输入：

   • while(~scanf("%d", &n))：使用按位取反运算符(~)确保读取到有效输入。这种写法等同于检查scanf的返回值是否为EOF（End of File）。

4. 初始化变量：

   • int i, j, sum, digits = 1：定义一些辅助变量，其中digits表示当前结果的位数。
   • int a[10001] = {1}：定义一个数组a用于存储每个位的计算结果，初始值为1，表示0的阶乘是1。

5. 计算阶乘：

   • for (i = 2; i <= n; i++)：从2开始循环到n，逐步计算阶乘。
   • sum = 0：初始化进位sum为0。
   • for (j = 0; j < digits; j++)：遍历当前的每一位进行乘法运算。
     • a[j] = a[j] * i + sum：当前位的值乘以i，加上前一位的进位。
     • sum = a[j] / 10000：计算新的进位。
     • a[j] %= 10000：当前位只保留低四位数字。
   • if (sum > 0)：如果最高位有进位，增加新的位数。
     • a[digits++] = sum：将进位的值存入新的最高位。

6. 输出结果：

   • printf("%d", a[digits - 1])：先输出最高位，最高位无需补0。
   • for (i = digits - 2; i >= 0; i--)：依次输出剩下的位数，每个位都用四位数字显示，不足四位的前面补0。
     • printf("%04d", a[i])：输出当前位，使用%04d格式表示前面补0。
   • printf("\n")：输出换行符，完成一行输出。

7. 返回0：

   • return 0：表示程序正常结束。

C ++

#include<iostream>
using namespace std; 

// 定义一个长整型数组来存储阶乘的中间结果，因为阶乘结果可能非常大
long long a[10001], n, i, s, j, t, d;

int main(void)
{
    // 不断从输入中读取整数 n，直到文件结束
    while(cin >> n)
    {
        // 初始化第一个元素为1，因为0!和1!都是1
        a[0] = 1;
        d = 1;  // d表示数组a的有效长度，即当前存储阶乘结果的位数
        
        // 从2开始计算到n的阶乘
        for(i = 2; i <= n; i++)
        {
            s = 0;  // s用于存储进位值
            
            // 遍历当前阶乘结果的每一位，进行乘法运算
            for(j = 0; j < d; j++)
            {
                a[j] = a[j] * i + s;  // 当前位乘以i并加上进位
                s = a[j] / 10000;  // 计算进位值，将当前位值除以10000
                a[j] %= 10000;  // 当前位值取模10000，保留低四位
            } 
            
            // 处理最后的进位，将进位的值继续存储到数组中
            while(s)
            {
                a[d++] = s % 10000;  // 取进位值的低四位存入数组
                s = s / 10000;  // 进位值右移四位
            }
        }
        
        // 输出阶乘结果
        printf("%d", a[d-1]);  // 输出最高位的值，不需要补零
        for(j = d-2; j >= 0; j--)  // 从高位到低位依次输出
            printf("%04d", a[j]);  // 每个值输出时都补足四位，前面补零
        printf("\n");  // 换行
    } 
}

  注释

1. a[10001]：定义一个长度为10001的长整型数组，用于存储阶乘计算的中间结果。每个元素最多存储四位数，以减少溢出的风险。
2. while(cin >> n)：不断从输入中读取整数 n，直到文件结束。
3. a[0] = 1; 和 d = 1;：初始化数组的第一个元素为1，并设置有效长度为1，因为0!和1!都是1。
4. for(i = 2; i <= n; i++)：从2开始计算到n的阶乘。
5. s = 0;：用于存储每次乘法运算的进位值。
6. for(j = 0; j < d; j++)：遍历当前阶乘结果的每一位进行乘法运算。
7. a[j] = a[j] * i + s;：当前位的值乘以i并加上之前的进位值。
8. s = a[j] / 10000; 和 a[j] %= 10000;：计算新的进位值，并将当前位的值取模10000以保留低四位。
9. while(s)：处理剩余的进位值，将进位的值继续存储到数组中。
10. printf("%d", a[d-1]);：输出最高位的值，不需要补零。
11. for(j = d-2; j >= 0; j--) printf("%04d", a[j]);：从高位到低位依次输出每个值，并且每个值输出时都补足四位，前面补零。
12. printf("\n");：每次输出一个阶乘结果后换行。

 C语言

#include <stdio.h>

// 定义阶乘函数，计算并输出 n!
void factorial(int n) {
    // 定义一个数组 a 来存储每一位的结果，初始化为 {1}
    // 初始值表示 0! = 1
    int a[10000 + 1] = {1};

    // digits 表示当前数字的位数，初始为 1
    int digits = 1;
    int carry; // 进位
    int i, j;  // 循环变量

    // 从 2 乘到 n，逐步计算阶乘
    for (i = 2; i <= n; i++) {
        carry = 0; // 每次乘法前清除进位

        // 将当前的数组与 i 相乘
        for (j = 0; j < digits; j++) {
            // 计算当前位的乘积加上前一位的进位
            a[j] = a[j] * i + carry;
            // 更新进位
            carry = a[j] / 10000;
            // 保留当前位的低四位
            a[j] %= 10000;
        }

        // 如果乘法后还有进位，则增加新的高位
        if (carry > 0)
            a[digits++] = carry;
    }

    // 输出结果：从最高位开始输出，高位不需要补0
    printf("%d", a[digits - 1]);

    // 对于其他低位，如果位数不足四位，则需要补0
    for (i = digits - 2; i >= 0; i--)
        printf("%04d", a[i]);

    // 换行
    printf("\n");
}

int main() {
    int n;

    // 读取输入的整数 n，直到文件结束
    while (scanf("%d", &n) != EOF)
        // 调用阶乘函数计算并输出 n!
        factorial(n);

    return 0;
}

 注释

1. 数组定义和初始化：

   int a[10000 + 1] = {1};

   • 定义一个数组 a 用于存储大数的每一位，初始化为 {1} 表示 0! = 1。
   • 数组大小为 10001，以确保能够存储足够大的数。

2. 位数和进位变量：

   int digits = 1; int carry;

   • digits 记录当前大数的位数，初始化为 1。
   • carry 用于记录乘法过程中产生的进位。

3. 阶乘计算：

   for (i = 2; i <= n; i++) {
       carry = 0; // 每次乘法前清除进位 
       for (j = 0; j < digits; j++) {
           a[j] = a[j] * i + carry;
           carry = a[j] / 10000;
           a[j] %= 10000;
       }
       if (carry > 0)
           a[digits++] = carry;
   }

   • 外层循环 for (i = 2; i <= n; i++) 从 2 到 n 依次进行乘法操作。
   • 内层循环 for (j = 0; j < digits; j++) 对当前大数的每一位进行乘法，并处理进位。
   • 处理完所有位后，如果还有进位，则增加一个新位。

4. 结果输出：

   printf("%d", a[digits - 1]); 
   for (i = digits - 2; i >= 0; i--) 
       printf("%04d", a[i]); printf("\n");

   • 从最高位开始输出。
   • 高位直接输出，低位如果不足四位则补 0（确保每四位输出一次）。
   • 最后换行。

5. 主函数：

   int main() {
       int n;
       while (scanf("%d", &n) != EOF) factorial(n);
       return 0;
   }

   • 循环读取输入的整数 n，直到文件结束。
   • 调用 factorial 函数计算并输出 n!。