怎样计算“阶乘”?即从1开始的连续自然数相乘的积,如：1*2*3*4*5*6*7*8*9*……=?请告诉我计算“阶乘”的公式,再一步一步地仔细给我解释,我会很感谢的!请不要说什么“N!”因为我知道这是阶乘

怎样计算“阶乘”?即从1开始的连续自然数相乘的积,如：1*2*3*4*5*6*7*8*9*……=?请告诉我计算“阶乘”的公式,再一步一步地仔细给我解释,我会很感谢的!请不要说什么“N!”因为我知道这是阶乘
怎样计算“阶乘”?即从1开始的连续自然数相乘的积,如：1*2*3*4*5*6*7*8*9*……=?
请告诉我计算“阶乘”的公式,再一步一步地仔细给我解释,我会很感谢的!
请不要说什么“N!”因为我知道这是阶乘的表达方法，但我不知道怎样计算啊。请说清楚哦！PLEASE !!

怎样计算“阶乘”?即从1开始的连续自然数相乘的积,如：1*2*3*4*5*6*7*8*9*……=?请告诉我计算“阶乘”的公式,再一步一步地仔细给我解释,我会很感谢的!请不要说什么“N!”因为我知道这是阶乘
说实话,没有计算阶乘的公式,也没有简便方法,只是硬算,也可以运用计算机,可以计算到65!,如果你想计算跟大的数,我建议你上百度寻找计算阶乘的软件,听说多大的数都能计算出来.
还有这个参考：
由于阶乘运算的增长速度特别快（比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

呵呵
就是从1到n的连续自然数相乘
比如5的 阶乘就是1×2×3×4×5
6的 阶乘就是1×2×3×4×5×6
100的 阶乘就是1×2×3×4×。。。×100
懂了吧！？

通俗的讲，谁的阶乘就是从谁开始乘，一直乘到1为止
比如1！=1
2！=2*1
3！=3*2*1
……
9！=9*8*7*6*5*4*3*2*1
……
N！=N（N-1）（N-2）（N-3）……3*2*1
要注意，(1)0！=1这是规定的
(2)阶乘拿手算只能一个一个乘,不过可以借助 计算机来求较大数的阶乘...

全部展开

通俗的讲，谁的阶乘就是从谁开始乘，一直乘到1为止
比如1！=1
2！=2*1
3！=3*2*1
……
9！=9*8*7*6*5*4*3*2*1
……
N！=N（N-1）（N-2）（N-3）……3*2*1
要注意，(1)0！=1这是规定的
(2)阶乘拿手算只能一个一个乘,不过可以借助 计算机来求较大数的阶乘

收起

阶乘的定义] 设n为自然数，则
n!=1⋅2⋅3⋯n
称为n的阶乘.并且规定0!=1.又定义
(2n+1)!!= (2n+1)! 2 n n! =1⋅3⋅5⋯(2n+1), (−1)!!=0 (2n)!!= 2 n n!=2⋅4⋅6⋯(2n), 0!!=0

大整数阶乘的运算（可以计算1000！）
由于阶乘运算的增长速度特别快（比2^n的增长速度快），对于较小整数的阶乘运算采用简单的递规算法可以实现，但是对于大整数的乘法（比如1000！），则传统的递规算法就失去了作用。
由于本人的水平不高，用下列拙劣的方式实现，请高人多多指教。具体如下：定义一个很长的数组，用数组的每一项表示计算结果的每一位。例如，7！＝5040，a[1000]，则a...

全部展开

大整数阶乘的运算（可以计算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("\n"+count);
}
}

收起

由于阶乘运算的增长速度特别快（比2^n的增长速度快），对于较小整数的阶乘运算采用简单的递规算法可以实现，但是对于大整数的乘法（比如1000！），则传统的递规算法就失去了作用。
由于本人的水平不高，用下列拙劣的方式实现，请高人多多指教。具体如下：定义一个很长的数组，用数组的每一项表示计算结果的每一位。例如，7！＝5040，a[1000]，则a[0]＝0，a[1]=4,a[2]=0,a[3]=...

全部展开

由于阶乘运算的增长速度特别快（比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("\n"+count);
}
}
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=528778

收起

阶乘的定义] 设n为自然数，则
n!=1⋅2⋅3⋯n
称为n的阶乘.并且规定0!=1.又定义
(2n+1)!!= (2n+1)! 2 n n! =1⋅3⋅5⋯(2n+1), (−1)!!=0 (2n)!!= 2 n n!=2⋅4⋅6⋯(2n), 0!!=0

晕，买个计算器呗

高精度
白痴

哇！！！！1楼的人C语言学的真好。我都忘光了，记得当初还编译过的，现在全忘了。真厉害啊/

“阶乘”即从1开始的连续自然数相乘的积，即n!=1*2*3...*n,这就是它的计算公式。
由于阶乘运算的增长速度特别快（比2^n的增长速度快），对于较小的正整数的阶乘运算可采用简单的笔算，但是对于较大的正整数可用计算器或计算机。注意：当正整数过大时，计算器和计算机也算不出来！
当然，有一个近似的公式，斯特林公式：n!≈[√(2πn)[*(n/e)^n ,π和e是无理数，π≈3.1...

全部展开

“阶乘”即从1开始的连续自然数相乘的积，即n!=1*2*3...*n,这就是它的计算公式。
由于阶乘运算的增长速度特别快（比2^n的增长速度快），对于较小的正整数的阶乘运算可采用简单的笔算，但是对于较大的正整数可用计算器或计算机。注意：当正整数过大时，计算器和计算机也算不出来！
当然，有一个近似的公式，斯特林公式：n!≈[√(2πn)[*(n/e)^n ,π和e是无理数，π≈3.14159 ,e≈2.71828
斯特林公式的最大好处就是把阶乘化成了指数的形式，在精度不高的情况下，可以使用。
0!=1（规定）
1!=1
2!=1*2=2
3!=1*2*3=6
4!=1*2*3*4=24
5!=1*2*3*4*5=120
6!=1*2*3*4*5*6=720
......

收起

阶乘算法（0---10000）
#include
#include
#include
const int N=1000;
int compute(unsigned int *s,int n)//s用来存储一次的计算结果,n为本次计算的乘数,函数返回结果中有效数据的节数
{ ...

全部展开

阶乘算法（0---10000）
#include
#include
#include
const int N=1000;
int compute(unsigned int *s,int n)//s用来存储一次的计算结果,n为本次计算的乘数,函数返回结果中有效数据的节数
{
unsigned long p; //暂时存放一节的结果
unsigned long more=0;//一次乘法的进位
int i; //循环变量
static int m=1;//存放结果中的节数,三位一节
static int q=0;//存放结果中最后为零的节数
//计算本次的结果
for(i=q;i{
p=(long)s[i]*(long)n+more;
more=p/N;
s[i]=p-more*N;
}
//计算结果中最后为零的节数
while(s[q]==0) q++;
//处理最高位
for(more=p/N;more;)
{
p=more;
more=p/N;
s[i++]=p-more*N;
m++; //有效节数增一
}
return m; //返回有效节数
}
void main()
{
unsigned int *s; //存放结果
int i; //循环变量
int m; //存放节数
int n; //求n的阶乘
cout<<"请输入一个正整数<0----10000>:";
cin>>n;
if(n<0)
{
cout<<"输入数据错误!"<return;
}
else if(n==0)
{
cout<<"0!==1"<return;
}
//初始化s
s=(unsigned int *)malloc(n*sizeof(s)*10);
for(i=1;is[0]=1;
//计算结果
for(i=2;i<=n;i++) m=compute(s,i);
while(s[m]==0) m--;//过滤掉前面的零
//输出结果
cout<int num=1;
for(i=m;i>=0;i--)
{
num++;
cout<<','<if((num%10)==0) cout<}
cout<//释放空间
free(s);
}

收起