n的阶乘高精度算法解析
阶乘的概念与计算方法知识点总结
阶乘的概念与计算方法知识点总结阶乘，又称阶乘函数，是数学中一个常见的运算符号，通常用符号"!"表示。
它是指从1乘到给定的数，并将各个乘积相加的运算。
阶乘的概念与计算方法是数学学习的基础知识之一，在不同的领域和问题中有着广泛的应用。
本文将对阶乘的概念、计算方法以及相关注意事项进行总结。
一、阶乘的概念阶乘是指对一个正整数n，乘以比它小的所有正整数的乘积。
以n!表示，其中n为要进行阶乘的数。
阶乘可以简单地理解为从1到n的所有正整数相乘的结果。
二、阶乘的计算方法1. 递归法：阶乘的计算可以通过递归的方式实现。
递归是一种函数自己调用自己的方法。
对于n的阶乘，可通过以下递归定义：n! = n * (n-1)!通过递归调用n-1的阶乘来计算n的阶乘。
递归法适用于较小的阶乘计算，但对于大数阶乘计算会产生较大的计算量和时间复杂度。
2. 循环法：阶乘的计算还可以通过循环的方式实现。
循环法是通过从1到n的循环累乘的方式计算n的阶乘，具体步骤如下：将阶乘的初始值设置为1；从1到n进行循环，每次循环将当前的数与阶乘的值相乘，并将结果更新为新的阶乘值；循环结束后，阶乘的值即为所求的结果。
三、注意事项1. 阶乘的结果可能会非常大，当计算的阶乘数较大时，可能会超出数据类型的表示范围。
因此，在计算大数阶乘时，需要考虑使用高精度计算方法或应用特殊的算法进行计算。
2. 阶乘运算是一个递增的过程，即随着n的增大，阶乘的结果会呈现出爆炸式的增长。
在实际应用中，需要根据具体问题的要求和计算资源的限制，合理选择计算阶乘的方法。
3. 阶乘通常只适用于正整数，对于负数和小数，阶乘运算没有定义。
综上所述，阶乘的概念与计算方法是数学学习中的重要内容。
通过递归法和循环法，可以计算得到给定数的阶乘。
在实际应用中，需要注意计算结果溢出的问题和阶乘运算的局限性。
阶乘的概念和计算方法在概率统计、组合数学、算法设计等领域中有着广泛的应用，对于理解和解决相关问题具有重要意义。
高精度计算
高精度计算由于计算机具有运算速度快，计算精度高的特点，许多过去由人来完成的烦琐、复杂的数学计算，现在都可以由计算机来代替。
计算机计算结果的精度，通常要受到计算机硬件环境的限制。
例如，pascal 要计算的数字超过19位，计算机将按浮点形式输出；另一方面，计算机又有数的表示范围的限制，在一般的微型计算机上，实数的表示范围为l0-38 -l038。
例如，在计算N!时，当N=21时计算结果就超过了这个范围，无法计算了。
这是由计算机的硬件性质决定的，但是，我们可以通过程序设计的方法进行高精度计算（多位数计算）。
学习重点1、掌握高精度加、减、乘、除法。
3、理解高精度除法运算中被除数、除数、商和余数之间的关系。
4、能编写相应的程序，解决生活中高精度问题。
学习过程一、高精度计算的基本方法用free pascal程序进行高精度计算，首先要处理好以下几个基本问题：【数据的输入与保存】（1）一般采用字符串变量存储数据，然后用length函数测量字符串长度确定其位数。
（2）分离各位数位上的数字分离各数位上的数通常采用正向存储的方法。
以“163848192”为例，见下表：A[9] A[8] A[7] A[6] A[5] A[4] A[3] A[2] A[1]1 6 3 8 4 8 1 9 2基本原理是A[1]存放个位上的数字，A[2]存放十位上的数字，……依此类推。
即下标小的元素存低位上的数字，下标大的元素存高位上的数字，这叫“下标与位权一致”原则。
【计算结果位数的确定】（1）高精度加法：和的位数为两个加数中较大数的位数+1。
（2）高精度减法：差的位数为被减数和减数中较大数的位数。
（3）高精度乘法：积的位数为两个相乘的数的位数之和。
（4）高精度除法：商的位数按题目的要求确定。
【计算顺序与结果的输出】高精度加、减、乘法，都是从低位到高位算起，而除法相反。
输出结果都是从高位到低位的顺序，注意：高位上的零不输出（整数部分是零除外）。
阶乘运算
//阶乘各算法的 C++ 类实现#include <iostream>#include <cstring>#include <iomanip>#include <cmath>using namespace std;class Factorial {static const int MAXN = 5001; // 最大阶乘数，实际用不到这么大int *data[MAXN]; // 存放各个数的阶乘int *nonzero; // 从低位数起第一个非0数字int maxn; // 存放最大已经计算好的n的阶乘int SmallFact(int n); // n <= 12的递归程序void TransToStr(int n, int *s); // 将数n倒序存入数组中void Multply (int* A, int* B, int* C, int totallen); // 执行两个高精度数的乘法public:Factorial();~Factorial();void Calculate(int n); // 调用计算阶乘int FirstNonZero(int n); // 返回阶乘末尾第一个非0数字int CountZeros(int n); // 返回阶乘末尾有多少个0int SecondNum(int n); // 返回阶乘左边的第二个数字bool CanDivide(int m, int n); // 判断数值 m 是否可以整除 n!void Output(int n) const;};int Factorial::SmallFact(int n) {if (n == 1 || n == 0) return 1;return SmallFact(n-1)*n;}void Factorial::TransToStr(int n, int *tmp) {int i = 1;while (n) {tmp[i++] = n%10;n /= 10;}tmp[0] = i-1;}void Factorial::Multply (int* A, int* B, int* C, int totallen){int i, j, len;memset(C, 0, totallen*sizeof(int));for (i = 1; i <= A[0]; i++)for (j = 1; j <= B[0]; j++) {C[i+j-1] += A[i]*B[j]; // 当前i+j-1位对应项 + A[i] * B[j]C[i+j] += C[i+j-1]/10; // 它的后一位 + 它的商（进位）C[i+j-1] %= 10; // 它再取余即可}len = A[0] + B[0];while (len > 1 && C[len] == 0 ) len--; // 获得它的实际长度C[0] = len;}Factorial::Factorial() { // 构造函数，先把<=12的阶乘计算好maxn = 12; data[0] = new int [2];data[0][0] = 1; data[0][1] = 1;int i, j = 1;for (i = 1; i <= 12; i++) {data[i] = new int [12];j = j*i;TransToStr(j, data[i]);}nonzero = new int [10*MAXN];nonzero[0] = 1; nonzero[1] = 1; // nonzero[0]存储已经计算到的n!末尾非0数}Factorial::~Factorial() {for (int i = 0; i <= maxn; i++)delete [] data[i];delete [] nonzero;}void Factorial::Calculate(int n) {if (n > MAXN) return;if (n <= maxn) return; // <= maxn的，已经在计算好的数组中了int i, j, len;int tmp[12];for (i = maxn+1; i <= n; i++) {TransToStr(i, tmp);len = data[i-1][0] + tmp[0] + 1;data[i] = new int [len+1];Multply(data[i-1], tmp, data[i], len+1);}maxn = n;}int Factorial::FirstNonZero(int n) {if (n >= 10*MAXN) {cout << "Super Pig, your input is so large, cannot Calculate. Sorry! ";return -1;}if (n <= nonzero[0]) return nonzero[n]; //已经计算好了，直接返回int res[5][4] = {{0,0,0,0}, {2,6,8,4}, {4,2,6,8}, {6,8,4,2}, {8,4,2,6}};int i, five, t;for (i = nonzero[0]+1; i <= n; i++) {t = i;while (t%10 == 0) t /= 10; // 先去掉 i 末尾的 0，这是不影响的if (t%2 == 0) { // t是偶数直接乘再取模10即可nonzero[i] = (nonzero[i-1]*t)%10;}else { // 否则转换成 res 数组来求five = 0;while (t%5 == 0) {if (five == 3) five = 0;else five++;t /= 5;}nonzero[i] = res[((nonzero[i-1]*t)%10)/2][five];// (nonzero[i-1]*t)%10/2 正好序号为：1, 2, 3, 4 中的一个}}nonzero[0] = n;return nonzero[n];}/* 阶乘末尾有多少个0，实际上只与5的因子数量有关，即求 n/5+n/25+n/625+...... */ int Factorial::CountZeros(int n) {if (n >= 2000000000) {cout << "Super Pig, your input is so large, cannot Calculate. Sorry! ";return -1;}int cnt = 0;while (n) {n /= 5;cnt += n;}return cnt;}/* 输出N!左边第二位的数字：用实数乘，超过100就除以10，最后取个位即可 */int Factorial::SecondNum(int n) {if (n <= 3) return 0;int i;double x = 6;for (i = 4; i <= n; i++) {x *= i;while (x >= 100) x /= 10;}return (int(x))%10;}bool Factorial::CanDivide(int m, int n) {if (m == 0) return false;if (n >= m) return true;int nn, i, j, nums1, nums2;bool ok = true;j = (int)sqrt(1.0*m);for (i = 2; i <= j; i++) {if (m%i == 0) {nums1 = 0; // 除数m的素因子i的数量while (m%i == 0) {nums1++;m /= i;}nums2 = 0; nn = n;while (nn) { // 求 n 含有 i 因子的数量nn /= i;nums2 += nn;}if (nums2 < nums1) { // 少于m中所含i的数量，则m肯定无法整除n! ok = false;break;}j = (int)sqrt(1.0*m); // 调整新的素因子前进范围}}if (!ok || m > n || m == 0) return false;else return true;}void Factorial::Output(int n) const {if (n > MAXN) {cout << "Super Pig, your input is so large, cannot Calculate. Sorry! ";return;}int i, len = 8;cout << setw(4) << n << "! = "; // 格式控制输出for (i = data[n][0]; i >= 1; i--) {cout << data[n][i];if (++len == 58) { // 实际每输出50个字符就换行len = 8;cout << " ";}}if (len != 8) cout << endl;}int main() {int n, m, i;Factorial f;while (cin >> n) {f.Calculate(n);f.Output(n);cout << "该阶乘末尾第一个非0数字是: " << f.FirstNonZero(n) << endl; cout << "该阶乘总共拥有数字0的个数：" << f.CountZeros(n) << endl; cout << "该阶乘的左边的第2位数字是：" << f.SecondNum(n) << endl; cin >> m;if (f.CanDivide(m, n)) cout << m << " 可以整除 " << n << "! ";else cout << m << " 不能整除 " << n << "! ";}return 0;}//第2部分第(5)个算法的单独实现#include<stdio.h>int A[10] = {1,1,2,6,24,120,720,5040,40320,362880};int ans[1024];int sum;void insert(int* a, int x) { // 插入排序，插成有序表int i, j;for (i = 1; i <= a[0]; i++)if (a[i] >= x) break;if (i <= a[0] && a[i] == x) return; // 如果相等，则不用插入if (i > a[0]) {a[++a[0]] = x;}else {for (j = a[0]++; j >= i; j--)ans[j+1] = ans[j];ans[i] = x;}if (a[0] == 1023) printf(" Array Overflow! ");}void search(int n){for (int i = n; i <= 9; i++){sum += A[i]; if (sum > 1) insert(ans, sum);if (i < 9) search(i+1);sum -= A[i];}}int main(){int n,i;ans[0] = 1; ans[1] = 1; //初始化ans数组，ans[0]表示表长search(0);//printf("len = %d ", ans[0]);while(1){scanf("%d",&n);if(n < 0)break;if(n > 409114){ printf("NO ");continue;}for (i = 1; i <= ans[0]; i++)if (ans[i] == n) {printf("YES "); break;}else if (ans[i] > n) {printf("NO "); break;}}return 0;}//阶乘相关算法及程序有关阶乘的算法，不外乎两个方面：一是高精度计算；二是与数论相关。
n的阶乘斯特林公式
n的阶乘斯特林公式阶乘斯特林公式是一个很重要的数学定理，可以用来求解阶乘等问题。
它最初是由斯特林在1778年提出的，并被公认为是类似于阶乘的定理，并被持续使用至今。
在19世纪末，发现了一种改进的斯特林公式可以用来求解n的阶乘，也就是n的阶乘斯特林公式，公式如下：n!=e^(nlnn)其中，e是欧拉的自然常数，lnn表示自然对数的底数为e的n 次方，也可表示为ln n!。
在给定n的情况下，n的阶乘斯特林公式可以用来求解n的阶乘。
首先，我们从定义出发，可以知道，n的阶乘是指将一个数乘以其他比它小的正整数的乘积，即n!=n*(n-1)*(n-2)*...*2*1。
例如，3的阶乘可以表示为3!=3*2*1=6。
假设n为4，4的阶乘则可以表示为4!=4*3*2*1=24。
接下来，我们看一下斯特林公式如何用来求解n的阶乘。
斯特林公式认为，n的阶乘可以用e^(nlnn)表示，这里e为欧拉的自然常数，lnn表示自然对数的底数为e的n次方，也可表示为ln n!。
这是一种比定义法更为简便的方法，可以大大减少时间和工作量。
例如，如果我们使用计算机程序来求解7的阶乘，可以将7的阶乘表示为e^(7ln7)=e^(7*ln7)=5040。
在上述公式中，e意味着自然常数，ln7意味着自然对数的底数为7，因此7的阶乘就是5040。
此外，斯特林公式还可用来计算更大阶乘的数值。
例如，对于25的阶乘，可以使用斯特林公式表示为e^(25ln25)，这里e=2.7182818284，ln25=3.2188758248，因此25的阶乘等于2.7182818284的25次方乘以3.2188758248的次方，即：25!=2.7182818284^25*3.2188758248^25=3.28541*10^40 由此可见，斯特林公式是一种可以快速求解阶乘的有效方法。
它不仅大大简化了计算的步骤，而且可以计算出更大的阶乘数值。
在实际工作中，n的阶乘斯特林公式可实现更快的计算速度，可以用来求解通常需要消耗大量时间以及工作量的大量计算。
高精度计算(二)
高精度计算(二)【例3】高精度乘法。
从键盘读入两个正整数，求它们的积。
分析：（1）、乘法运算a←a*c(a为高精度类型,c为字节型)按照乘法规则,从a的第l位开始逐位与c相乘。
在第i位乘法运算中(1≤i≤la),a的i位与c的乘积必须加上i-1位的进位(i-1位的乘积除以10的整商),然后规整积的i-l位(取i-1位的乘积对10的余数)。
procedure multiply(var a:numtype; c:byte);vari:byte；begina[1] ←a[l]*c；{第1位初始化}for i←2 to la do {逐位相乘}begina[i] ←a[i]*c；a[i] ←a[i]+a[i-l] div 10；a[i-1] ←a[i-l] mod 10end:{for}while a[1a]>=10 do {积的最高位进位}beginla←la+1;a[la] ←a[la-1] div 10;a[la-1] ←a[la-1]mod 10;end; {while}end;{multiply}（2）、乘法运算c←a*b(a,b为高精度类型,)类似加法，可以用竖式求乘法。
在做乘法运算时，同样也有进位，同时对每一位进乘法运算时，必须进行错位相加，如图3, 图4。
分析C 数组下标的变化规律，可以写出如下关系式：C i= C 'i +C ''i +…由此可见，C i跟A[i]*B[j]乘积有关，跟上次的进位有关，还跟原C i的值有关，分析下标规律，有x:= A[i]*B[j]+ x DIV 10+ C[i+j-1];C[i+j-1] := x mod 10;类似，高精度乘法的参考程序：program exam3;constmax=200;vara,b,c:array[1..max] of 0..9;n1,n2:string;lena,lenb,lenc,i,j,x:integer;beginwrite(’Input multiplier:’); readln(n1);write(’Input multiplicand:’); readln(n2);lena:=length(n1); lenb:=length(n2);for i:=1 to lena do a[lena-i+1]:=ord(n1[i])-ord(’0’);for i:=1 to lenb do b[lenb-i+1]:=ord(n2[i])-ord(’0’);for i:=1 to lena do beginx:=0;for j:=1 to lenb do begin {对乘数的每一位进行处理}x := a[i]*b[j] + x div 10 + c[i+j-1]; {当前乘积+上次乘积进位+原数}c[i+j-1] := x mod 10;end;c[i+j]:= x div 10; {进位}end;lenc:=i+j;while (c[lenc]=0) and (lenc>1) do dec(lenc);for i:=lenc downto 1 do write(c[i]);writelnend.【例4】高精度除法。
n的阶乘的近似计算公式
n的阶乘的近似计算公式在我们数学的奇妙世界里，有一个概念叫做“n 的阶乘”。
这玩意儿可有意思啦！啥是 n 的阶乘呢？简单说，就是从 1 开始，一直乘到 n 这么多个数。
比如说 5 的阶乘，就是 1×2×3×4×5，算出来是 120 。
那为啥我们要研究 n 的阶乘的近似计算公式呢？这就好比你去超市买东西，你不想一件一件地数，而是想有个大概的估计，心里有个底儿。
给大家讲讲我之前碰到的一件事儿。
有一次我去参加一个数学竞赛的培训，老师在黑板上出了一道超大数字的阶乘计算，让我们想办法算出个大概结果。
当时大家都傻眼了，这要一个一个乘，得算到啥时候啊！后来老师就给我们讲了 n 的阶乘的近似计算公式，大家顿时有种恍然大悟的感觉。
咱们先来说说斯特林公式（Stirling's approximation），这可是个很厉害的近似计算公式。
它长这样：n! ≈ √(2πn) (n / e)^n 。
这里的“e”是一个很神奇的数，约等于 2.71828 。
这个公式看起来有点复杂，是吧？但其实用起来还是挺方便的。
比如说，你要算 10 的阶乘的近似值，把 n = 10 带进去，就能算出一个和真正的 10 阶乘很接近的结果。
不过呢，这个近似公式也不是完美的。
在 n 比较小的时候，可能误差会稍微大一点。
但当 n 变得很大很大，比如说几百几千的时候，那这个近似值就非常非常接近真正的阶乘值啦。
再给大家举个例子。
假如我们要估算50 的阶乘，按照斯特林公式，先算√(2π×50) ，再算 (50 / e)^50 ，最后把这两个乘起来，就能得到一个大概的数。
那这个近似计算公式是咋来的呢？这背后可是有很深的数学原理的。
涉及到微积分、概率论等等高深的知识。
咱们普通人不用深究那么多，会用就行啦。
除了斯特林公式，还有一些其他的近似计算方法，不过都没有斯特林公式这么常用和准确。
在实际应用中，n 的阶乘的近似计算公式用处可大了。
c语言高精度计算n的阶乘
c语言高精度计算n的阶乘高精度计算是指在计算机中进行大数运算时，能够精确表示和计算超过计算机位数范围的整数或小数。
在计算n的阶乘时，如果n很大，传统的计算方法可能会导致溢出或精度丢失，因此需要使用高精度计算的方法。
C语言是一种广泛应用于系统软件和应用软件开发的高级程序设计语言。
它支持对内存的直接访问，并提供了丰富的库函数，可以方便地进行高精度计算。
本文将介绍如何使用C语言实现高精度计算n的阶乘。
我们需要明确阶乘的定义。
阶乘是指从1到n的连续整数的乘积，表示为n!。
例如，5的阶乘为5! = 5 ×4 × 3 × 2 × 1 = 120。
传统的计算n的阶乘的方法是使用循环结构，从1到n依次相乘。
但是，当n很大时，结果可能会超出计算机能够表示的范围。
为了避免这个问题，我们可以使用数组来表示大数，并模拟手工计算的过程。
具体实现时，我们可以使用一个整型数组来存储大数的每一位。
数组的每个元素表示一个位数，例如，数组的第一个元素表示最低位，最后一个元素表示最高位。
为了方便计算，我们可以将大数按照逆序存储，即最低位存储在数组的最后一个元素中。
我们需要定义一个函数来实现大数的乘法。
该函数接受两个大数作为参数，并返回它们的乘积。
具体实现时，我们可以使用两层循环遍历两个大数的每一位，并将结果保存在一个新的大数中。
在计算过程中，需要注意进位的处理。
接下来，我们可以定义一个函数来计算n的阶乘。
该函数接受一个整数n作为参数，并返回n的阶乘。
具体实现时，我们可以使用一个循环从2到n，依次计算每个数的阶乘，并将结果与之前的乘积相乘。
在计算过程中，为了避免溢出，我们可以使用前面提到的大数乘法函数。
我们可以在主函数中调用阶乘函数，并输出结果。
为了方便观察，我们可以将大数按照正常顺序输出，即从最高位到最低位。
具体实现时，可以使用一个循环从最高位到最低位遍历大数数组，并将每一位转换为字符型后输出。
阶乘的规律
阶乘的规律阶乘是数学中一个非常重要的概念，它在各个领域都有广泛的应用。
阶乘的规律可以通过以下几个方面来解释和理解。
首先，什么是阶乘？阶乘是从1乘到一个给定的正整数n的连乘积。
用符号n!表示，即n! = n * (n-1) * (n-2) * ... * 2 * 1。
例如，4! = 4 * 3 * 2 * 1 = 24。
阶乘的规律可以从多个角度来观察和理解。
首先，我们可以看到阶乘的结果随着n的增大而迅速增长。
当n较小时，阶乘的结果是相对较小的数，例如3! = 6。
但是当n增大到10以上时，阶乘的结果就会变得非常大，例如10! = 3,628,800。
这说明阶乘的增长速度是非常快的。
其次，阶乘的规律还可以从组合的角度来解释。
例如，我们可以将n个物体排成一列，那么有多少种不同的排列方式呢？这个问题可以通过计算n的阶乘来回答。
因为在第一个位置上有n种选择，第二个位置上有n-1种选择，以此类推，所以总共有n!种不同的排列方式。
这在组合数学和概率论中有着重要的应用。
此外，阶乘的规律还可以被递归地定义和理解。
我们可以将n的阶乘定义为n乘以(n-1)的阶乘，以此类推，直到n等于1时，阶乘的结果为1。
这种递归的定义帮助我们更好地理解阶乘的概念，并可以应用于编程和算法设计中。
阶乘的规律也可以通过数学公式来表示。
数学家发现了一种称为Gamma函数的特殊函数，可以用来计算任意实数的阶乘。
Gamma函数的定义比较复杂，但它将阶乘的概念扩展到了实数域上，为数学研究提供了更广阔的领域。
阶乘的规律在实际问题中有许多应用。
例如，在概率论中，我们可以使用阶乘来计算排列和组合的数量，从而计算事件的概率。
在计算机科学中，阶乘的概念经常出现在递归算法和动态规划中，用于解决各种复杂的问题。
在统计学中，阶乘可以用于计算概率分布和估计参数。
总而言之，阶乘是数学中一个重要的概念，它有着广泛的应用和深刻的规律。
通过观察阶乘的增长速度、理解组合的性质、递归地定义和使用数学公式，我们可以更好地理解和应用阶乘的规律。
n的阶乘斯特林公式
n的阶乘斯特林公式斯特林公式是求n的阶乘的有效方法，它是18th世纪瑞典数学家斯特林提出的，它已经成为数学历史上最伟大的发明之一。
它的准确性非常高，可以用来解决任何大规模的阶乘计算问题，成为求解n 的阶乘的一种有效的方法。
斯特林公式表达式如下：n! = n ( n -1 ) ( n -2 ) 3*2*1。
其中： n! 代表 n阶乘，其他数字都是从 n始，直到 1 为止，每个数字都是 n去某个数字，也就是前面数字减去后面数字。
斯特林公式的数学定义如下：n阶乘是所有小于等于n的正整数的积，即n! = n(n-1)(n-2)...21。
若 n=0，则 n!=1。
通过定义可以看出，n阶乘是一个数目较大的数，用笔算来求这种阶乘的乘积，既耗时又容易出错，而斯特林公式可以让我们在不费力的情况下求出n的阶乘。
斯特林公式的应用：1.解决很多的排列组合问题中，斯特林公式都可以使用，例如：求在 n 个数里选取 k 个数的组合数 C(n, k)。
C(n, k) = n! / (k! *(n-k)!)，其中 n!是 n阶乘，以斯特林公式计算比较方便；2.概率论中，斯特林公式也可以得到应用，例如：求在 n 个元素中取出 m 个元素放到 k 个相同容器中的概率，可以用斯特林公式来求解；3.特林公式也可以用来求解大矩阵的行列式值；4.特林公式在数值拟合中也有应用，它可以帮助我们在求解多元函数的极值时减少计算量；5.特林公式还可以用于分形研究，例如：利用斯特林公式，可以求出螺旋线、曲线和等值线的参数化表达式；6.特林公式还可以应用在数论和密码学等领域。
斯特林公式的一个最重要的作用就是求解n的阶乘，其实还经常应用于日常的数学计算当中，这一方法是值得信赖的，而且计算简单，不必花费大量的时间来求解。
斯特林公式的准确性非常高，可以比笔算运算准确性更高，但随着n越大，计算量也会变大，运算也会变慢，所以斯特林公式不能用于解决更大规模的阶乘计算问题。
n的阶乘的公式
n的阶乘的公式n的阶乘是指从1乘到n的连续整数相乘的结果，通常用符号n!表示。
在数学中，n的阶乘是一个非常重要的概念，它在组合数学、概率论、微积分等领域都有广泛的应用。
本文将介绍n的阶乘的公式及其应用。
首先，我们来看n的阶乘的公式。
n的阶乘可以用递归或迭代的方式来计算。
递归的公式如下：n! = n * (n-1)!其中，n!表示n的阶乘，n-1!表示n-1的阶乘。
这个公式的意思是，n的阶乘等于n乘以n-1的阶乘。
递归的终止条件是n=0或n=1，此时n的阶乘为1。
另一种计算n的阶乘的方法是迭代。
迭代的公式如下：n! = 1 * 2 * 3 * ... * n这个公式的意思是，n的阶乘等于从1到n的连续整数相乘的结果。
迭代的过程中，我们从1开始，每次乘以下一个整数，直到乘到n为止。
n的阶乘的公式在实际应用中有很多用途。
首先，它在组合数学中被广泛使用。
组合数学研究的是集合的组合和排列问题，而n的阶乘正是用来计算排列的数量。
例如，如果有n个物体，要从中选取k个进行排列，那么排列的数量就是n的阶乘除以(n-k)的阶乘。
这个公式在排列组合问题的解决中起到了重要的作用。
其次，n的阶乘的公式在概率论中也有应用。
在概率论中，我们经常需要计算事件的可能性。
如果有n个事件，每个事件发生的概率相等且互不影响，那么这n个事件同时发生的概率就是它们各自发生概率的乘积。
而n的阶乘正好可以用来计算这个乘积。
例如，如果有6个骰子，每个骰子的点数是1到6之间的整数，那么同时掷出6个骰子，出现某个特定的点数的概率就是(1/6)^6，其中1/6是每个骰子出现特定点数的概率。
最后，n的阶乘的公式在微积分中也有应用。
在微积分中，我们经常需要计算函数的导数和积分。
而n的阶乘可以用来表示多项式函数的导数和积分。
例如，如果有一个多项式函数f(x) = a_n * x^n + a_(n-1) * x^(n-1) + ... + a_1 * x + a_0，其中a_i是常数，那么f(x)的n次导数就可以表示为f^(n)(x) = n! * a_n，其中f^(n)(x)表示f(x)的n次导数。
C++阶乘计算(高精度)
C++ 阶乘计算（高精度）题目：输入一个正整数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!的值。
输入：输入包含一个正整数n，n<=1000。
输出：输出n!的准确值。
提示：本题所求n会很大，int，long long 范围有限，故要用数组代码：#include<iostream>#include<stdio.h>#include<string.h>using namespace std;int A[10000 + 1];//求阶乘void factorial(int n) {A[0] = 1;for (int i = 1; i <= n; i++){for (int j = 0; j <= 10000; j++){if (A[j] != 0)A[j] *= i;}for (int j = 0; j <= 10000; j++) {if (A[j] >= 10){//进位操作A[j + 1] += (A[j] % 100) / 10;A[j + 2] += (A[j] % 1000) / 100;A[j + 3] += (A[j] % 10000) / 1000;A[j] = A[j] % 10;}}}}int main() {int n;cin >> n;memset(A, 0, sizeof(A));factorial(n);int sign;for(int i=10000;i>=0;i--)if (A[i] == 0 && A[i - 1] != 0) //去除最高位前面的0{sign = i - 1; //找到最高位的位置break;}for (int i = sign; i >=0; i--)printf("%d", A[i]);return 0;}。
n的阶乘斯特林公式
n的阶乘斯特林公式
：
斯特林（Stirling）公式是一种著名的非常有效的用来计算阶乘n！的方法。
它可以比传统的阶乘得出的值稍微大一点、准确且运算速度快，是一种极其有效的方法。
斯特林公式的主体公式有这样一种形式：n!≈(n/e)^n×sqrt(2nπ)，其中e为自然对数的底数。
斯特林公式的工作原理是通过在假设关于n的数学发展，并建立一种势能函数表示n！，从而得到较精准的n!的初步计算结果。
比如说，当n很大时，它就可以代替传统的阶乘算法，以精确度更高的结果来计算n！
斯特林公式也常常被用于统计学上大量的抽样分析。
在这类分析的计算中，斯特林公式能够为用户提供准确的计算结果，并且精确度更高。
从上面的讲解可以看出，斯特林公式是一种用于计算n!的有效方法，它能够提供准确精确的计算结果，而且在统计学方面也有着广泛的应用。
1005 最少余料问题 1007 计算n的阶乘
最少余料问题Time Limit:10000MS Memory Limit:65536KTotal Submit:83 Accepted:14Description建筑师designer要将一根长度为s米的木材，截成长度规格分别为A米和B 米两种短木料（S＞A＋B），每种木料至少截一根，为了节约起见，要求所剩余料最少。
现在designer请你帮忙解决这个问题。
要求输入木材的长度，和两种规格的单位长度，求出所剩余料最少情况下的最少余料值和两种规格各应截多少根。
数据输入输出：Input三行，分另为：木料的长度S，两种规格的单位长度A和B。
Output一行，为最少余料值。
Sample Input10564536Sample Output3Source∙var∙ i,j,k,n,s,a,b:longint;∙ min,x,y:longint;∙begin∙ readln(s);∙ readln(a,b);∙ s:=s-a-b; min:=maxlongint; ∙ for i:=0 to s div a do begin ∙ j:=s-a*i; k:=j div b;∙ j:=j-k*b;∙ if min>j then begin∙ min:=j; x:=i; y:=k;∙ end;∙ end;∙ writeln(min);∙end.计算n的阶乘Time Limit:10000MS Memory Limit:65536KTotal Submit:23 Accepted:11Description用高精度计算出：s=1！+2！+3！+…+n！（n≤50）。
其中“！”表示阶乘，例如：5！=5*4*3*2*1。
Input输入正整数n.Output计算结果s。
Sample Input2Sample Output3Source∙var∙ i,j,l1,l2,n:longint;∙ a,b:array[1..100] of longint;∙begin∙ readln(n);∙ a[1]:=1; l1:=1; b[1]:=1; l2:=1;∙ for i:=2 to n do begin∙ for j:=1 to l2 do b[j]:=b[j]*i;∙ for j:=1 to l2+2 do begin∙ b[j+1]:=b[j+1]+b[j] div 10;∙ b[j]:=b[j] mod 10;∙ end;∙ l2:=l2+3;∙ while b[l2]=0 do dec(l2);∙ for j:=1 to l2 do a[j]:=a[j]+b[j];∙ for j:=1 to l2 do if a[j]>9 then begin ∙ a[j+1]:=a[j+1]+1; a[j]:=a[j] mod 10; ∙ end;∙ if l2>l1 then l1:=l2;∙ end;∙ for i:=l1 downto 1 do write(a[i]);∙ writeln;∙end.。
阶乘算法
高精度算法的基本思想，就是将无法直接处理的大整数，分割成若干可以直接处理的小整数段，把对大整数的处理转化为对这些小整数段的处理数据结构的选择每个小整数段保留尽量多的位使用Comp类型采用二进制表示法每个小整数段保留尽量多的位一个例子：计算两个15位数的和Ø方法一•分为15个小整数段，每段都是1位数，需要15次1位数加法Ø方法二•分为5个小整数段，每段都是3位数，需要5次3位数加法Ø方法三•Comp类型可以直接处理15位的整数，故1次加法就可以了Ø比较•用Integer计算1位数的加法和3位数的加法是一样快的•故方法二比方法一效率高•虽然对Comp的操作要比Integer慢，但加法次数却大大减少•实践证明，方法三比方法二更快使用Comp类型高精度运算中，每个小整数段可以用Comp类型表示Comp有效数位为19～20位求两个高精度数的和，每个整数段可以保留17位求高精度数与不超过m位整数的积，每个整数段可以保留18–m位求两个高精度数的积，每个整数段可以保留9位如果每个小整数段保留k位十进制数，实际上可以认为其只保存了1位10k进制数，简称为高进制数，称1位高进制数为单精度数采用二进制表示法采用二进制表示，运算过程中时空效率都会有所提高，但题目一般需要以十进制输出结果，所以还要一个很耗时的进制转换过程。
因此这种方法竞赛中一般不采用，也不在本文讨论之列.算法的优化高精度乘法的复杂度分析连乘的复杂度分析设置缓存分解质因数求阶乘二分法求乘幂分解质因数后的调整高精度乘法的复杂度分析计算n位高进制数与m位高进制数的积Ø需要n*m次乘法Ø积可能是n+m–1或n+m位高进制数连乘的复杂度分析（1）一个例子：计算5*6*7*8Ø方法一：顺序连乘•5*6=30，1*1=1次乘法•30*7=210，2*1=2次乘法•210*8=1680，3*1=3次乘法共6次乘法Ø方法二：非顺序连乘•5*6=30，1*1=1次乘法•7*8=56，1*1= 1次乘法•30*56=1680，2*2=4次乘法共6次乘法连乘的复杂度分析（2）若“n位数*m位数=n+m位数”，则n个单精度数，无论以何种顺序相乘，乘法次数一定为n(n-1)/2次Ø证明：•设F(n)表示乘法次数，则F(1)=0，满足题设•设k<n时，F(k)=k(k-1)/2，现在计算F(n)•设最后一次乘法计算为“k位数*(n-k)位数”，则•F(n)=F(k)+F(n-k)+k (n-k)=n(n-1)/2（与k的选择无关）设置缓存（1）一个例子：计算9*8*3*2Ø方法一：顺序连乘•9*8=72，1*1=1次乘法•72*3=216，2*1=2次乘法•216*2=432，3*1=3次乘法Ø方法二：非顺序连乘•9*8=72，1*1=1次乘法•3*2=6，1*1=1次乘法•72*6=432，2*1=2次乘法共6次乘法特点：n位数*m位数可能是n+m-1位数特点：n位数*m位数可能是n+m-1位数设置缓存（2）考虑k+t个单精度数相乘a1*a2*…*ak*ak+1*…*ak+tØ设a1*a2*…*ak结果为m位高进制数（假设已经算出）Øak+1*…*ak+t结果为1位高进制数Ø若顺序相乘，需要t次“m位数*1位数”，共mt次乘法Ø可以先计算ak+1*…*ak+t，再一起乘，只需要m+t次乘法在设置了缓存的前提下，计算m个单精度数的积，如果结果为n位数，则乘法次数约为n(n–1)/2次，与m关系不大–设S=a1a2… a m，S是n位高进制数–可以把乘法的过程近似看做，先将这m个数分为n组，每组的积仍然是一个单精度数，最后计算后面这n个数的积。
c语言高精度计算n的阶乘
c语言高精度计算n的阶乘高精度计算是指对于超过计算机所能表示的数值范围的数字进行精确计算的方法。
在C语言中，常规的整型变量无法存储大数，因此需要使用其他方法来实现高精度计算。
本文将介绍如何使用C语言来计算一个数的阶乘，并实现高精度计算。
我们需要了解阶乘的概念。
阶乘是指从1到给定的数字n之间所有整数的乘积。
例如，5的阶乘表示为5!，计算方式为5 * 4 * 3 * 2 * 1 = 120。
对于较小的数，我们可以直接使用C语言中的循环来计算阶乘，但对于较大的数，我们需要使用高精度计算的方法。
在C语言中，我们可以使用数组来表示一个大数。
数组的每个元素存储大数的每一位。
例如，数字123456可以用数组arr表示为arr[] = {1, 2, 3, 4, 5, 6}。
这样，我们就可以通过数组来进行高精度计算。
我们需要定义一个数组来存储计算结果，并将其初始化为1。
然后，我们使用循环从2开始遍历到n，每次将当前数字与数组中的数相乘，并将结果存储到数组中。
具体的代码如下：```c#include <stdio.h>#define MAX_SIZE 1000void multiply(int result[], int num, int size) {int carry = 0; // 进位for (int i = 0; i < size; i++) {int product = result[i] * num + carry; // 计算乘积 result[i] = product % 10; // 保存当前位数carry = product / 10; // 计算进位}// 处理最高位的进位while (carry != 0) {result[size] = carry % 10;carry /= 10;size++;}}void factorial(int n) {int result[MAX_SIZE] = {1}; // 初始化结果为1int size = 1; // 数组大小for (int i = 2; i <= n; i++) {multiply(result, i, size);}// 逆序输出结果printf("%d的阶乘为：", n);for (int i = size - 1; i >= 0; i--) {printf("%d", result[i]);}printf("\n");}int main() {int n;printf("请输入一个正整数：");scanf("%d", &n);factorial(n);return 0;}```在上述代码中，我们定义了两个函数`multiply`和`factorial`。
用递归求n的阶乘
用递归求n的阶乘
什么是阶乘？
阶乘是指从1到n所有正整数相乘所得的结果，例如3的阶乘为3×2×1=6。
如何使用递归求n的阶乘？
递归是一种函数调用自身的技术，在数学计算中能够用递归方法的问题中有一类称为递归问题。
求n的阶乘就是一种递归问题，可以使用递归方法来解决它。
具体来说，如果要计算n的阶乘n!，那么n!等于n乘以(n-1)的阶乘(n-1)!，(n-1)!等于(n-1)乘以(n-2)的阶乘(n-2)!，以此类推，直到1的阶乘为1。
因此可以使用递归的思想来计算n的阶乘。
下面是使用递归求n的阶乘的示例代码：
```python
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)
```
代码的解释如下：
1. 定义一个函数factorial，接受一个整数n作为参数。
2. 如果n等于1，那么直接返回1，因为1的阶乘就是1。
3. 否则，返回n乘以n-1的阶乘factorial(n-1)。
这样，程序就能够正确地计算n的阶乘了。
需要注意的是，如果n过大，递归的层数会很多，导致程序占用大量的内存空间，甚至会导致堆栈溢出。
因此，使用递归求解问题时需要注意递归深度的问题。
综上所述，使用递归求n的阶乘是一种简单而高效的方法，能够有效地解决阶乘的计算问题。
n的阶乘的公式
n的阶乘的公式摘要：一、引言二、n 的阶乘概念介绍三、n 的阶乘公式推导四、n 的阶乘公式应用举例五、结论正文：【引言】在数学领域，阶乘是一个常见的概念。
n 的阶乘指的是从1 乘到n 的连乘积。
本文将介绍n 的阶乘的公式，并通过公式推导和应用举例来帮助理解这一概念。
【n 的阶乘概念介绍】的阶乘通常用符号n! 表示，它表示从1 乘到n 的连乘积，即n! = 1 × 2 × 3 × ...× n。
例如，4! = 1 × 2 × 3 × 4 = 24。
需要注意的是，0 的阶乘定义为1，即0! = 1。
【n 的阶乘公式推导】为了推导n 的阶乘公式，我们可以使用数学归纳法。
首先，当n = 1 时，n! = 1；假设当n = k 时，k! = 1 × 2 × 3 × ...× k 成立。
接下来，我们需要证明当n = k + 1 时，(k + 1)! = 1 × 2 × 3× ...× k × (k + 1) 成立。
根据乘法分配律，我们可以将(k + 1)! 拆分为k! × (k + 1)。
由归纳假设，k! = 1 × 2 × 3 × ...× k 成立，因此，(k + 1)! = k! × (k + 1) = 1 × 2 × 3 × ...× k × (k + 1)。
所以，对于任意正整数n，n 的阶乘公式为n! = 1 × 2 × 3 × ...× n。
【n 的阶乘公式应用举例】现在，我们通过几个例子来展示n 的阶乘公式在实际问题中的应用。
例1：计算5!根据5 的阶乘公式，5! = 1 × 2 × 3 × 4 × 5 = 120。
阶乘的相关运算公式
阶乘的相关运算公式阶乘，这个数学概念在我们的学习过程中可有着重要的地位呢！先来说说什么是阶乘。
阶乘用符号“!”表示，比如说 5 的阶乘，写作5! ，它就等于 5×4×3×2×1 。
简单来讲，就是从给定的那个数开始，依次乘以比它小 1 的数，一直乘到 1 为止。
那阶乘的运算公式都有啥呢？首先就是最基本的 n! = n×(n - 1)! 。
这个公式看起来有点绕，咱们来举个例子。
比如说算 6 的阶乘，也就是6! ，根据这个公式， 6! = 6×5! 。
而 5! 呢又等于 5×4×3×2×1 ，这样就能逐步算出 6! 的值啦。
再给大家说个有趣的事儿，我之前教过一个学生，他刚开始接触阶乘的时候，那叫一个迷糊。
有一次做作业，题目是算 4 的阶乘，他居然写成了 4×3×2 ，少乘了个 1 。
我就问他：“你咋把 1 给忘了呢？1 也是有作用的呀！”他挠挠头，不好意思地笑了。
从那以后，他就记住了阶乘的运算可不能少了最后的 1 。
还有一个重要的性质， 0! = 1 。
这可能会让一些同学感到奇怪，为啥 0 的阶乘是 1 呢？其实呀，这是为了让一些数学公式和运算能够更统一、更方便。
阶乘在数学的很多领域都有应用。
比如在排列组合中，要计算从 n 个不同元素中取出 m 个元素的排列数，就会用到阶乘。
另外，阶乘的增长速度是非常快的。
比如说 10! 就已经是 3628800 了。
随着数字越来越大，阶乘的值会变得超级大。
咱们再来说说怎么快速计算阶乘。
对于比较小的数，咱们可以直接一步一步乘。
但如果数字比较大，那可能就得借助一些数学方法或者计算机程序了。
阶乘这个概念虽然有点复杂，但只要咱们多练习、多思考，就一定能掌握它。
就像我那个迷糊的学生，后来不也搞清楚了嘛！总之，阶乘的运算公式虽然看起来有点头疼，但只要咱们耐心琢磨，多做几道题，就能轻松应对啦！希望大家都能在数学的海洋里畅游，把阶乘这个小怪兽给征服！。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#define N 5000 // modify it to hold larger number
int main(void)
{
int n, i, j, s, up, f[N] = {0};
scanf("%d", &n);
到这个时候，我们已经把n=5时的情况带入程序并完全分解开写了出来，通过这个展开式我们能够发现什么呢？在这个问题得到解决以前，我们先看一看以下乘法：
24*5=120，若是我们在小学，一定会这么算：
运算1：
2 4
* 5
————————
1 2 0
这是我们在小学的时候就用的乘法运算，但是我们还能够将上面的那个乘法过程加以变形，然后得到另一个类似的乘法运算：
运算3：
1 2 2
* ( 4 5)//在本次运算中把45视为一个整体
我们先用4乘以5得到20然后写下0进2；然后让2乘以5得到10，用10加上2得到12,我们应该写下2进1；因为24前一位是0，我们可以认为是用0乘以5加上1得到1，此时写下1，24*5的乘法运算结束。
算到这里你是不是有什么启发呢？再看下一个乘法运算的例子，或许你就会有一些灵感了：
运算2：
1 2 2
for (i = 2, f[0] = 1; i <= n; i++)
for (j = up = 0; j < N; j++)
{
s = f[j] * i +பைடு நூலகம்up;
f[j] = s % 10;
up = s / 10;
}
for (i = N-1; f[i] == 0; i--) ;
四：i=5时
1.
j=0时：s=f[j]*i+up;----->s=f[0]*5+0=20;
f[j]=s%10;----->f[0]=s%10=20%10=0;
up=s/10;----->up=20/10=2;
2.
j=1时：s=f[j]*i+up;----->s=f[1]*5+2=2*5+2=12;
f[j]=s%10;----->f[0]=6%10=6;
up=s/10;----->up=6/10=0;
2.j=1时：s=f[j]*i+up;----->s=f[1]*3+0=0*3+0=0;
f[j]=s%10;----->f[1]=0%10=0;
up=s/10;----->up=0/10=0;
一：i=2时
1.
j=0时：s=f[j]*i+up;----->s=f[0]*2+0=1*2+0=2；
f[j]=s%10;----->f[0]=2%10=2;
up=s/10;----->up=2/10=0;
2.
j=1时：s=f[j]*i+up;----->s=f[1]*2+0=0*2+0=0;
return 0;
}
当我们第一次接触这个代码的时候，你会不会感到很无奈呢？是不是不明白为什么这么做啊？
下面说一说我对这串代码的理解：
首先，要想要理解这串代码是怎么回事儿，最好的方法就是先找一个数带进去，找一张好的白纸，好好写一写，画一画，从0写到5。从更本质上来说，只把5带进去就行，因为
在n的阶乘中，n大于16时n的阶乘得出的结果用长整形保存时总是溢出，这对于刚刚到了关于“n的阶乘高精度运算”的c代码：
up=s/10;----->up=24/10=2;
2.
j=1时:s=f[j]*i+up;----->s=f[1]*4+2=0*4+2=2;
f[j]=s%10;----->f[1]=2%10=2;
up=s/10;----->up=2/10=0;
3.
j=2时：s=f[j]*i+up;----->s=f[2]*4+0=0*4+0=0;
—————————————————
等价于
运算5：
f[3] f[1] f[0]
* i
____________________________________________
f[2] f[1] f[0]
所以有
运算3：
1 2 2
* （4 5）
在运算3中122*45的过程相当于内循环中的整个循环，122相当于前44（外循环中的i-1）个数的乘积（假设是，实际上不是，这个乘积相当于i-1的阶乘），45相当于外循环中的i；
在运算的时候，程序把45当成一个整体来运算。我们来看看到底程序是怎样用数组来保存大整数的。还是用122*45这个例子。
f[j]=s%10;----->f[1]=12%10=2;
up=s/10;----->up=12/10=1;
3.
j=2时：s=f[j]*i+up;----->s=f[2]*5+1=0*5+1=1;
f[j]=s%10;----->f[2]=1%10=1;
up=s/10;----->up=1/10=0;
f[j]=s%10;
----->f[2]=0%10=0;
up=s/10;----->up=0/10=0;
当j大于等于2时的情况和“3.”时的情况相同，此时得到的结果为：f[0]=4;f[1]=2;f[2]=0;f[3]=0;......
* 4 5
——————————————————
6 1 0
4 8 8
——————————————————
5 4 9 0
for (; i >= 0; i--) printf("%d", f[i]) ;
printf("\n");
return 0;
}
若是感觉不是很好明白，可以改成以下代码，可能就会好明白一点了：
#include <stdio.h>
#define N 5000 // modify it to hold larger number
实际上数组中的每一个元素都保存有f[i]>=0&&f[i]<=9的元素。在122*45这个乘法运算中，则有
1 2 2
| | |
到5490这个答案，实际上，运算3可以等效为下面的运算4：
运算4：
4 5
* 1 2 2
————————————————
f[j]=s%10;----->f[1]=0%10=0;
up=s/10;----->up=0/10=0;
当j大于等于2时的情况和“2.”时的情况相同，此时得到的结果为：f[0]=2;f[1]=0;f[2]=0;.....
二：i=3时
1.j=0时：s=f[j]*i+up;----->s=f[0]*3+0=2*3+0=6;
我们把运算3的运算过程带入运算5就能发现，这个过程和我们将n=5时的情况带入程序时的分析过程完全相同，到此，我们已经完全证明了，程序代码中的内循环就是i-1的阶乘结果乘以i的过程，而且这个过程用的方法就是我们在运算3中用的方法环控制阶乘数，正如：
int main(void)
{
int n, i, j, s, up, f[N] = {0};
scanf("%d", &n);
f[0] = 1;
for (i = 2; i <= n; i++)//外循环控制阶乘的数
{
up=0;
for (j=0; j < N; j++) //内循环用于得出前一个数的阶乘结果乘以当前数i得出的阶乘结果
当j大于等于2时的情况和“2.”时的情况相同，此时得到的结果为：f[0]=6;f[1]=0;f[2]=0;......
三：i=4时
1.
j=0时：s=f[j]*i+up;----->s=f[0]*4+0=6*4+0=24;
f[j]=s%10;----->f[0]=24%10=4;
4.
j=3时：s=f[j]*i+up;----->s=f[3]*5+up=0*5+0=0;
f[j]=s%10;----->f[3]=0%10=0;
up=s/10;----->up=0/10=0;
当j大于等于4时的情况和"3."时的情况相同，此时得到的结果是：f[0]=0;f[1]=2;f[2]=1;f[3]=0;f[4]=0;......
{
s = f[j] * i + up;
f[j] = s % 10;