fortran中阶乘算法

阶乘的主要公式：1、任何大于1的自然数n阶乘表示方法：n!=1×2×3×……×n。2、n的双阶乘：当n为奇数时表示不大于n的所有奇数的乘积 ，如：7!=1×3×5×7。3、当n为偶数时表示不大于n的所有偶数的乘积(除0外），如：8!=2×4×6×8。4、小于0的整数-n 的阶乘表示：（-n）!= 1 / (n+1)!。一个正整数的阶乘是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n!。1808年，基斯顿·卡曼引进这个表示法。定义的必要性由于正整数的阶乘是一种连乘运算，而0与任何实数相乘的结果都是0，所以用正整数阶乘的定义是无法推广或推导出0！=1的，即在连乘意义下无法解释“0！=1”，给“0！”下定义只是为了相关公式的表述及运算更方便。阶乘的计算方法是1乘以2乘以3乘以4，一直乘到所要求的数，例如所要求的数是6，则阶乘式是1×2×3×…×6，得到的积是720，720就是6的阶乘。

一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n!。亦即n!=1×2×3×...×(n-1)×n。阶乘亦可以递归方式定义：0!=1，n!=(n-1)!×n。式:n!=n*(n-1)!阶乘的计算方法 阶乘指从1乘以2乘以3乘以4一直乘到所要求的数.例如所要求的数是4,则阶乘式是1×2×3×4,得到的积是24,24就是4的阶乘.例如所要求的数是6,则阶乘式是1×2×3×..×6,得到的积是720,720...

阶乘= 10！=

阶乘的主要公式：1、任何大于1的自然数n阶乘表示方法。n！=1×2×3×……×n或n！=n×(n-1)！2、n的双阶乘：当n为奇数时表示不大于n的所有奇数的乘积。如：7！=1×3×5×73、当n为偶数时表示不大于n的所有偶数的乘积（除0外）。如：8！=2×4×6×84、小于0的整数－n的阶乘表示。（－n）！＝1 / (n+1)！5、0的阶乘。0！＝0阶乘计算方法：正整数阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。例如所要求的数是4，则阶乘式是1×2×3×4，得到的积是24，24就是4的阶乘。例如所要求的数是6，则阶乘式是1×2×3×……×6，得到的积是720，720就是6的阶乘。例如所要求的数是n，则阶乘式是1×2×3×……×n，设得到的积是x，x就是n的阶乘。

5的阶乘就是5×4×3×2×1。阶乘（一个数n的阶乘写成n！）的算法：n!=1×2×3×...×(n-1)×n。定义：0!=1，n!=(n-1)!×n扩展资料：真正严谨的阶乘定义应该为：对于数n，所有绝对值小于或等于n的同余数之积。称之为n的阶乘，即n!对于复数应该是指所有模n小于或等于│n│的同余数之积。。。对于任意实数n的规范表达式为：正数 n=m+x,m为其正数部，x为其小数部负数n=-m-x,-m为其正数部，-x为其小数部对于纯复数n=(m+x)i,或n=-(m+x)i

【阶乘的概念】 阶乘(factorial)是基斯顿·卡曼(Christian Kramp, 1760 – 1826)于1808年发明的运算符号。 阶乘，也是数学里的一种术语。[编辑本段]【阶乘的计算方法】 阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。 例如所要求的数是4，则阶乘式是1×2×3×4，得到的积是24，24就是4的阶乘。 例如所要求的数是6，则阶乘式是1×2×3×……×6，得到的积是720，720就是6的阶乘。例如所要求的数是n，则阶乘式是1×2×3×……×n，设得到的积是x，x就是n的阶乘。[编辑本段]【阶乘的表示方法】 在表达阶乘时，就使用“！”来表示。如x的阶乘，就表示为x! 如：n!=n×(n-1)×(n-2)×(n-3)×...×1 阶乘的另一种表示方法：(2n-1)!! 当n=2时，3!!=3×1=3 当n=3时，5!!=5×3×1=15 当n=4时，7!!=7×5×3×1=105 ...(以此类推)[编辑本段]【20以内的数的阶乘】 以下列出0至20的阶乘： 0！=1， 1！=1， 2！=2， 3！=6， 4！=24， 5！=120， 6！=720， 7！=5040， 8！=40320 9！=362880 10！=3628800 11！=39916800 12！=479001600 13！=6227020800 14！=87178291200 15！=1307674368000 16！=20922789888000 17！=355687428096000 18！=6402373705728000 19！=121645100408832000 20！=2432902008176640000 另外，数学家定义，0！=1，所以0！=1！[编辑本段]【阶乘的定义范围】 通常我们所说的阶乘是定义在自然数范围里的，小数没有阶乘，像0.5！，0.65！，0.777！都是错误的。但是，有时候我们会将Gamma函数定义为非整数的阶乘，因为当x是正整数n的时候，Gamma函数的值是n-1的阶乘。 ¤伽玛函数（Gamma Function） Γ（x)=∫e^(-t)*t^(x-1)dt (积分下限是零上限是＋∞）(x>0,-1,-2,-3,……) 运用积分的知识，我们可以证明Γ（x)＝(x-1) * Γ（x-1) 所以，当x是整数n时，Γ（n) = (n-1)(n-2)……＝(n-1)! 这样Gamma 函数实际上就把阶乘的延拓。 ¤欧拉等式 x!=)=∫-(ln(x))^ndx (积分下限是零上限是＋1）(x>0) ¤[计算机科学] 用Ruby求365的阶乘。 def AskFactorial(num) factorial=1; 1.step(num,1){|i| factorial*=i} return factorial end factorial=AskFactorial(365) puts factorial ¤【阶乘有关公式】 n!~sqrt(2*pi*n)(n/e)^n 该公式常用来计算与阶乘有关的各种极限。

n的阶乘公式是：n!=1×2×3×……×nn!=n×(n-1)!例如求4!，则阶乘式是1×2×3×4，得到的积是24，24就是4的阶乘。乘法的计算法则：数位对齐，从右边起，依次用第二个因数每位上的数去乘第一个因数，乘到哪一位，得数的末尾就和第二个因数的哪一位对齐。两位数的十位相同的，而个位的两数则是相补的（相加等于10）。（1）分别取两个数的一位，而后一个的要加上一以后，相乘。（2）两个数的尾数相乘，（不满十，十位添作0），口决：头加1，头乘头，尾乘尾。

公式:n!=n*(n-1)!阶乘的计算方法阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。例如所要求的数是4，则阶乘式是1×2×3×4，得到的积是24，24就是4的阶乘。例如所要求的数是6，则阶乘式是1×2×3×..×6，得到的积是720，720就是6的阶乘。例如所要求的数是n，则阶乘式是1×2×3×…×n，设得到的积是x，x就是n的阶乘。阶乘的表示方法在表达阶乘时，就使用“！”来表示。如x的阶乘，就表示为x!他的原理就是反推，如，举例，求10的阶乘=10*9的阶乘（以后用!表示阶乘）那么9!=？，9!=9*8!,8!=8*7!,7!=7*6!,6!=6*5!,5!=5*4!,4!=4*3!,3!=3*2!,2!=2*1!,1的阶乘是多少呢？是11!=1*1,数学家规定，0!=1,所以0!=1!然后在往前推算，公式为n！(n!为当前数所求的阶乘)=n(当前数)*(n-1)!（比他少一的一个数n-1的阶乘把公式列出来像后推，只有1的!为1，所以要从1开始，要知道3！要知道2！就要知道1！但必须从1!开始推算所以要像后推，如果遍程序算法可以此公式用一个函数解决，并且嵌套调用次函数，，）把数带入公式为,1!=1*12!=2*1(1!)3!=3*2(2!)4=4*6(3!),如果要是编程，怎么解决公式问题呢首先定义算法//算法，1，定义函数，求阶乘，定义函数fun,参数值n，（#includelongfun(intn)//long为长整型，因20！就很大了超过了兆亿（数学家定义数学家定义，0！=1，所以0！=1！，0与1的阶乘没有实际意义）2，函数体判断，如果这个数大于1，则执行if(n>1)（往回退算，这个数是10求它!,要从2的阶乘值开始，所以执行公式的次数定义为9，特别需要注意的是此处，当前第一次写入代码执行，已经算一次）求这个数的n阶乘（公式为，n！=n*(n-1)！，并且反回一个值，return(n*(fun(n-1));(这个公式为，首先这个公式求的是10的阶乘，但是求10的阶乘就需要，9的阶乘，9的阶乘我们不知道，所以就把10减1，也就是n-1做为一个新的阶乘，从新调用fun函数，求它的阶乘然后在把这个值返回到fun(n-1),然后执行n*它返回的值，其实这个公式就是调用fun函数的结果，函数值为return返回的值，（n-1）为参数依次类推，...一值嵌套调用fun函数，到把n-1的值=1,注意：此时已经运行9次fun（）函数算第一次运行，，调用几次fun函数呢？8次函数，所以，n-1执行了9次，n-1=1，n=2已经调用就可以求2乘阶值

【阶乘的概念】 阶乘(factorial)是基斯顿·卡曼(Christian Kramp, 1760 – 1826)于1808年发明的运算符号。 阶乘，也是数学里的一种术语。[编辑本段]【阶乘的计算方法】 阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。 例如所要求的数是4，则阶乘式是1×2×3×4，得到的积是24，24就是4的阶乘。 例如所要求的数是6，则阶乘式是1×2×3×……×6，得到的积是720，720就是6的阶乘。例如所要求的数是n，则阶乘式是1×2×3×……×n，设得到的积是x，x就是n的阶乘。[编辑本段]【阶乘的表示方法】 在表达阶乘时，就使用“！”来表示。如x的阶乘，就表示为x! 如：n!=n×(n-1)×(n-2)×(n-3)×...×1 阶乘的另一种表示方法：(2n-1)!! 当n=2时，3!!=3×1=3 当n=3时，5!!=5×3×1=15 当n=4时，7!!=7×5×3×1=105 ...(以此类推)[编辑本段]【20以内的数的阶乘】 以下列出0至20的阶乘： 0！=1， 1！=1， 2！=2， 3！=6， 4！=24， 5！=120， 6！=720， 7！=5040， 8！=40320 9！=362880 10！=3628800 11！=39916800 12！=479001600 13！=6227020800 14！=87178291200 15！=1307674368000 16！=20922789888000 17！=355687428096000 18！=6402373705728000 19！=121645100408832000 20！=2432902008176640000 另外，数学家定义，0！=1，所以0！=1！[编辑本段]【阶乘的定义范围】 通常我们所说的阶乘是定义在自然数范围里的，小数没有阶乘，像0.5！，0.65！，0.777！都是错误的。但是，有时候我们会将Gamma函数定义为非整数的阶乘，因为当x是正整数n的时候，Gamma函数的值是n-1的阶乘。 ¤伽玛函数（Gamma Function） Γ（x)=∫e^(-t)*t^(x-1)dt (积分下限是零上限是＋∞）(x<>0,-1,-2,-3,……) 运用积分的知识，我们可以证明Γ（x)＝(x-1) * Γ（x-1) 所以，当x是整数n时，Γ（n) = (n-1)(n-2)……＝(n-1)! 这样Gamma 函数实际上就把阶乘的延拓。 ¤欧拉等式 x!=)=∫-(ln(x))^ndx (积分下限是零上限是＋1）(x>0) ¤[计算机科学] 用Ruby求365的阶乘。 def AskFactorial(num) factorial=1; 1.step(num,1){|i| factorial*=i} return factorial end factorial=AskFactorial(365) puts factorial ¤【阶乘有关公式】 n!~sqrt(2*pi*n)(n/e)^n 该公式常用来计算与阶乘有关的各种极限。

可以是递归或循环

程序源代码： /** *计算大数的阶乘，算法的主要思想就是将计算结果的每一位用数组的一位来表示：如要计算5!，那么首先将 *(1) a[0]=1，然后a[0]=a[0]*2，a[0]=2， *(2) a[0]=a[0]*3，a[0]=6 *(3) a[0]=a[0]*4，a[0]=24，此时a[1]＝2，a[0]＝4 */ public class Factorial { static int a[] = new int [10000]; static void factorial(int n) { for(int i=2; i< a.length; i++) a[i] = 0; //将数组元素初始化 a[0] = 1; //用数组的一项存放计算结果的位数 a[1] = 1; //将第一项赋值为一 for(int j= 2; j <= n; j++) { int i=1; int c = 0; //c表示向高位的进位 for(; i <= a[0]; i++) { a[i] = a[i] * j + c;//将来自低位的计算结果和本位的结果相加 c = a[i] / 10; a[i] = a[i] % 10; } for(; c != 0; i++) { a[i] = c%10; c = c / 10; } a[0] = i - 1;

大整数阶乘的运算（可以计算1000！） 由于阶乘运算的增长速度特别快（比2^n的增长速度快），对于较小整数的阶乘运算采用简单的递规算法可以实现，但是对于大整数的乘法（比如1000！），则传统的递规算法就失去了作用。由于本人的水平不高，用下列拙劣的方式实现，请高人多多指教。具体如下：定义一个很长的数组，用数组的每一项表示计算结果的每一位。例如，7！＝5040，a[1000]，则a[0]＝0，a[1]=4,a[2]=0,a[3]=5。程序源代码：/***计算大数的阶乘，算法的主要思想就是将计算结果的每一位用数组的一位来表示：如要计算5!，那么首先将*(1) a[0]=1，然后a[0]=a[0]*2，a[0]=2，*(2) a[0]=a[0]*3，a[0]=6*(3) a[0]=a[0]*4，a[0]=24，此时a[1]＝2，a[0]＝4*/public class Factorial { static int a[] = new int [10000]; static void factorial(int n) { for(int i=2; i< a.length; i++) a[i] = 0; //将数组元素初始化 a[0] = 1; //用数组的一项存放计算结果的位数 a[1] = 1; //将第一项赋值为一 for(int j= 2; j <= n; j++) { int i=1; int c = 0; //c表示向高位的进位 for(; i <= a[0]; i++) { a[i] = a[i] * j + c;//将来自低位的计算结果和本位的结果相加 c = a[i] / 10; a[i] = a[i] % 10; } for(; c != 0; i++) { a[i] = c%10; c = c / 10; } a[0] = i - 1; } } public static void main(String[] args) { String num = args[0]; int count = 0; int n = Integer.parseInt(num); f(n); for(int i= a[0]; i>0; i--) { count++; System.out.print(/*"a[" + i + "]=" + */a[i]/* + " "*/); } System.out.println(" "+count); }}

privatesubcommand1_click()dimn,i,sumasintegern=5"n的初值sum=1"1做为阶乘的基数，因为乘以任何数都为原数fori=1ton"从1乘到n,这是阶乘的原理sum=sum*inextiprintsum"输出结果endsubprivatesubcommand1_click()dimx,yassinglex=1"给x任意的一个初值ifx<0then"x小于0的情况y=0else:ifx>=0andx<1then"0<=x<1的情况y=1else:ifx>=1andx<2then"1<=x<2的情况y=2else:y=3"3x>=2的情况endifendifendifprintyendsub

import java.util.Scanner;public class Jiecheng { public static void main(String[] args) { System.out.print("请输入你想要的阶乘数："); Scanner scan = new Scanner(System.in); int a = scan.nextInt(); System.out.print("!" + a + "的结果是：" + jiecheng(a)); } public static double jiecheng(int a) { if (a <= 1) { return a; } return jiecheng(a - 1) * a; }}

function f1(n)p=1for i=1 to np=p*inextf1=pend functions=0for i=1 to 7s=s+f1(i)nextresponse.write cstr(s)

阶乘的数字是几，就是从1按自然数的顺序乘到这个数比如4的阶乘就是1×2×3×4＝24

作业题不做详细解答，不过我可以提供一些思路。算阶乘很简单，一个循环就能搞定，通常用是long来保存积。不过由于阶乘的数值很大，如果n足够大，long是保存不下来的（溢出），那么就要代表java.math.BigInteger类了。然后由于除出来的数不是整数，所以还要借助java.math.BigDecimal类

( 0!+0!+0!+0! )! = 24

可以分成两段求：先求出35的阶乘，然后再求出36~50相乘的结果，之后再用大数乘法求得最终结果！//程序#include <cstdlib>#include <iostream>using namespace std;int main(int argc, char *argv[]){ int i; long long result1 = 1, result2 = 36; for (i=2; i<=35; i++) result1 *= i; for (i=37; i<=50; i++) result2 *= i; cout<<"The multiply result of 1~35 is : "<<result1<<endl; cout<<"The multiply result of 36~50 is : "<<result2<<endl; system("PAUSE"); return EXIT_SUCCESS;}//运行结果：

阶乘里面的数不可以为负。负数没有阶乘，只有-1有双阶乘，双阶乘的意思是：(2n)!=2*4*6*……*2n，(2n+1)!=1*3*5*……*(2n+1)，(-1)的双阶乘是0。一般来说，定义一种新运算是为了某种需要，但到现在还没有什么数学的分支学科需要定义负数的阶乘，因此现在还没有这种算法，也不需要这种算法。阶乘计算技巧：当然，当n较大，n!超过计算机字长表示范围时，可以采用多精度算术进行计算。事实上有一种更高效的问题求解方法，其思路是：首先将n!分解为唯一的素因子的乘积形式，然后，对该乘积进行适当优化。

10×9×8×7×6×5×4×3×2×1是阶乘算法。阶乘就是指一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n。，是基斯顿·卡曼于1808年发明的运算符号。

我想到个用数组方法,请大家看看是否可行.#include <stdio.h>#define NN 10000void main(){int a[NN], i, j;for(i=0;i<NN;i++0a[NN] = 0;a[0] = 1;for (i=1; i<=NN; i++){ for(j=0; j<NN;j++) { a[j]=a[j]*i; } for(j=0; j<NN-1;j++) { a[j+1]=[j+1] + a[j]/10; // 每个数组元素只保留一位(最后一个例外) }}printf(" NN 阶乘是:");for(j=NN-1; j>=0;j--) if (a[j]!=0) break; // get the first no-zero for(i=j; i>=0;i--) printf("%d",a[i]);}

const maxn=1000; var a:array[0..maxn]of longint; i,j,n,e:longint; begin readln(n); a[0]:=1; for i:=1 to n do begin e:=0; for j:=0 to a[maxn] do begin e:=e+a[j]*i; a[j]:=e mod 10; e:=e div 10; end; while e>0 do begin a[maxn]:=a[maxn]+1; a[a[maxn]]:=e mod 10; e:=e div 10; end; end; for i:=a[maxn] downto 0 do write(a[i]); writeln; end. andprogram liuke_jc; const z=10000; var a:array[0..z+1]of integer; n,j,i,k:longint; begin writeln("n="); readln(n); begin a[1]:=1; for i:=1 to n do begin for j:=1to z do a[j]:=a[j]*i; for k:=1 to z do begin a[k+1]:=a[k+1]+a[k]div 10; a[k]:=a[k]mod 10; end; end; i:=z;k:=0; repeat if a[i]<>0 then k:=1; i:=i-1; until k=1; k:=0; for j:=i+1 downto 1 do write(a[j]); end; writeln; end.

二项分布公式是P（X=k)=C(n,k)（p^k）*(1-p)^(n-k)。其中n是试验次数，X表示随机试验的结果。k是指定事件发生的次数，p是指定事件在一次试验中发生的概率

阶乘是基斯顿·卡曼（Christian Kramp，1760～1826）于1808年发明的运算符号，是数学术语。一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n!。1808年，基斯顿·卡曼引进这个表示法。亦即n!=1×2×3×...×n。阶乘亦可以递归方式定义：0!=1，n!=(n-1)!×n。

int fn(n){int y;if(n<0)｛ printf("error");return -1;}if(n==0) return 1;else{y=fn(n-1)return n*y;}}

算法很简单,就是在100后面加一个"!",因此，100的阶乘等于"100!"

#include<stdio.h>void main(){ int i,j=1; for(i=1;i<=5;i++) { j*=i; } printf("5的阶乘为%d ",j);}

先占个位子！

首先，明确一个问题，一个大数的阶乘，不管用什么都是无法存储得下的，所以必须用数组一位一位的存储，接下来举个例子来说明一下，比如5！首先算2！则a[0]=2,3!=3*2!,则a[0]=6，4=4*3!,则a[0]=24,进一步使a[1]=2,a[0]=4,5!=5*4!,a[0]=20,a[1]=10,进一步是a[0]=0,a[1]=10+2=12,再使a[1]=2,a[2]=1,输出时则按a[2],a[1]a[0]的顺序输出，即120.具体程序如下：#include<iostream.h>#include<stdio.h>int main(){ int m,temp=0,i,j,k=0,count1=0,count2=0; cin>>m; int a[100]={0}; a[0]=1; for(i=2;i<=m;i++) { for(j=0;j<=count1;j++) { a[j]=a[j]*i; } for(k=0;k<=count1;k++) { if(a[k]/10>0) { temp=a[k]/10; a[k]=a[k]%10; a[k+1]=a[k+1]+temp; if(k==count1) count2++; } } count1=count2; } for(i=count1;i>=0;i--) printf("%d",a[i]); printf(" "); return 0;}

n=int(input())def factorial(n): if n<0: return "No Result" if n==1 or n==0: return 1 return n * factorial(n - 1)print(factorial(n))

Function

n!=1×2×3×……×n16！=16*15*14*13*12*11*10*9*8*7*6*5*4*3*2*1=20,922,789,888,000

以下是1~15的阶乘：1！=12！=23！=64！=245！=1206！=7207！=50408！=403209！=36288010！=3628800，11！=3991680012！=47900160013！=622702080014！=8717829120015！=1307674368000

n!

阶乘的计算方法很简单，只需将要计算的数从1一直乘到该数即可。在实际应用中，阶乘常用于组合数学、概率论和统计学等领域。在计算大数的阶乘时，可以使用递归算法或循环算法进行计算。递归算法的思路是将大数的阶乘分解为小数的阶乘相乘，直到分解为1的阶乘为止。循环算法的思路是使用一个循环来依次计算每个数的阶乘，直到计算到要求的数为止。在组合数学中，阶乘常用于计算排列和组合的数量。从n个不同的元素中取出k个元素进行排列，其排列数为n!/(n-k)!；从n个不同的元素中取出k个元素进行组合，其组合数为n!/k!(n-k)!。总之，阶乘是数学中的一个重要概念，其应用广泛，计算方法简单。初学者应该掌握阶乘的概念和计算方法，以便在实际应用中灵活运用。在概率论中，阶乘常用于计算排列和组合的概率。从一副52张的扑克牌中随机取出5张牌，其组合数为52!/5!(52-5)!，其概率为C(52,5)/C(52,5)。

B这是一个递归程，可以看出每递归一次n的规模小一，所是结果是线性的。

n!=n*(n-1)*(n-2)*......*1

从5个不同的小球里任取三个,共有多少种取法? 属于组合问题,C(3,5)=(5*4*3)/(3*2*1)=10种 从数字1、2、3、4、5中任取三个数组成一个新的三位数,共可组成多少个不同的三位数? 属于排列问题,方法一,P(3,5)=5*4*3=60个 方法二,C(3,5)*P(3,3)=10*6=60个 “!”表示阶乘,5!=5*4*3*2*1=120,3!=3*2*1=6

VB 递归算法 求阶乘Function Factorial(n As Long) As Long If n = 1 Then Factorial = 1 Else Factorial = n * Factorial(n - 1)End FunctionPrivate Sub Command1_Click()Dim n As LongFor n = 1 To 10 Print CStr(n); "!="; Factorial(n)Next nEnd Sub

用QB来算哈a=1for b=1 to 6a=a*bnext bprint aend你乘到几，那个6就变成几哈

程序源代码： /** *计算大数的阶乘，算法的主要思想就是将计算结果的每一位用数组的一位来表示：如要计算5!，那么首先将 *(1) a[0]=1，然后a[0]=a[0]*2，a[0]=2， *(2) a[0]=a[0]*3，a[0]=6 *(3) a[0]=a[0]*4，a[0]=24，此时a[1]＝2，a[0]＝4 */ public class Factorial { static int a[] = new int [10000]; static void factorial(int n) { for(int i=2; i< a.length; i++) a[i] = 0; //将数组元素初始化 a[0] = 1; //用数组的一项存放计算结果的位数 a[1] = 1; //将第一项赋值为一 for(int j= 2; j <= n; j++) { int i=1; int c = 0; //c表示向高位的进位 for(; i <= a[0]; i++) { a[i] = a[i] * j + c;//将来自低位的计算结果和本位的结果相加 c = a[i] / 10; a[i] = a[i] % 10; } for(; c != 0; i++) { a[i] = c%10; c = c / 10; } a[0] = i - 1;

36的阶乘是这样子表示的36！=1*2*3*……*34*35*36你用上面那个除以35那么35是不是就是约掉啦？那么就变成1*2*3*……*31*32*33*34*36把36单独写出来左边1到34还是齐全的对不对？那么它就是34的阶乘所以答案是36（34！）（*可省略）

Dim n, i, j As Integer, S, Si As LongDo While .T. n = InputBox("请输入小于13的数", "n=", 0) If n >= 13 Then MsgBox ("请重新输入小于13的数据") Else Exit Do End IfEnddoS = 0For i = 1 To n Si = 1 For j = 2 To i Si = Si * j Next S = S + SiNextPrint "S = 1！+2！+3！+···+n! = "; Format(S)

概率阶层是算法阶乘（一个数n的阶乘写成n！）的算法：n!=1×2×3×...×(n-1)×n。定义：0!=1，n!=(n-1)!×n

（2n-1)!=1*3*5*7 （2n)! =2*4*6*8

int count=1; //积 int sum=0; //和 for(int i=1;i<=10;i++){ count=count*i; if(i<=10){ sum=count+sum; } } System.out.println(count); System.out.println(sum); }

n! = n*(n-1)*(n-2)*.....*2*1