计算任意数值的阶乘
谈到计算阶乘，大家可能会觉得比较简单，不就是一个循环从1一直乘到n吗？是的，确实是这样，但由于计算机的计算精度问题，利用计算机提供的现成的整数类型，我们最多可以计算到22! = 17196083355034583040 再大了，64位整形就无法存储。那么如果我们想计算100! 怎么办呢？eaglet 以前在博问中回答过类似问题，今天有空把它整理出来，供大家参考。
要实现任意数值的阶乘，最简单的办法就是自己实现一个整数类型，这个整数类型可以像int, long 这些类型一样实现加和乘的操作，但没有大小限制。下面就给出eaglet 做的十进制无符号整形类。这个类只实现了加法和乘法操作，没有实现减法和除法，但用作阶乘已经足够了，减法和除法大家有兴趣可以自己补充。
加法是基础
算法很简单，就是从个位开始按位相加，如果有进位，就进位。
乘法的方法是将乘数从各位开始逐位和被乘数相乘，然后再将相乘后得到的数累加，这个方法和手工计算乘法的方法是一样的。
个人感觉这两种方法的效率应该不是最高的，如果哪位TX有更高效的算法，也不妨一起讨论一下。
下面给出代码
///
/// 十机制无符号整数类
///
public class DecimalNumber
{
List<byte> _Data;
public List<byte> Data
{
get
{
return _Data;
}
}
public int Length
{
get
{
return _Data.Count;
}
}
public DecimalNumber()
{
_Data = new List<byte>();
}
public DecimalNumber(byte[] data)
{
foreach (byte b in data)
{
System.Diagnostics.Debug.Assert(b >= 0 && b <= 9);
}
_Data = new List<byte>(data);
}
public DecimalNumber(List<byte> data)
{
foreach (byte b in data)
{
System.Diagnostics.Debug.Assert(b >= 0 && b <= 9);
}
_Data = data;
}
///
/// 1位10机制数和10进制序列相乘
///
///
/// 10进制序列
/// 1位10机制数
/// 10的幂数
///
private static List<byte> Multiply(List<byte> s, byte d, int power)
{
System.Diagnostics.Debug.Assert(power >= 0);
System.Diagnostics.Debug.Assert(d >= 0 && d <= 9);
List<byte> result = new List<byte>();
for (int i = 0; i < power; i++)
{
result.Add(0);
}
byte carry = 0; //进位
foreach (byte si in s)
{
System.Diagnostics.Debug.Assert(si >= 0 && si <= 9);
byte r = (byte)(si * d + carry);
byte m = (byte)(r % 10);
carry = (byte)(r / 10);
result.Add(m);
}
if (carry > 0)
{
result.Add(carry);
}
return result;
}
///
/// 两个10进制序列相加
///
/// 序列1
/// 序列2
/// 相加后的序列
private static List<byte> Plus(List<byte> s1, List<byte> s2)
{
List<byte> result = new List<byte>();
int c1 = s1.Count;
int c2 = s2.Count;
if (c1 > c2)
{
for (int i = 0; i < c1 - c2; i++)
{
s2.Add(0);
}
}
else if (c1 < c2)
{
for (int i = 0; i < c2 - c1; i++)
{
s1.Add(0);
}
}
byte carry = 0; //进位
for (int i = 0; i < s1.Count; i++)
{
System.Diagnostics.Debug.Assert(s1[i] >= 0 && s1[i] <= 9);
System.Diagnostics.Debug.Assert(s2[i] >= 0 && s2[i] <= 9);
byte r = (byte)(s1[i] + s2[i] + carry);
byte m = (byte)(r % 10);
carry = (byte)(r / 10);
result.Add(m);
}
if (carry > 0)
{
result.Add(carry);
}
return result;
}
public static implicit operator DecimalNumber(string value)
{
List<byte> data = new List<byte>();
for (int i = value.Length - 1; i >= 0; i--)
{
data.Add(byte.Parse(value[i].ToString()));
}
return new DecimalNumber(data);
}
public static implicit operator DecimalNumber(int value)
{
System.Diagnostics.Debug.Assert(value >= 0);
return value.ToString();
}
public static DecimalNumber operator ++(DecimalNumber d)
{
return d + new DecimalNumber(new byte[] { 1 });
}
public static DecimalNumber operator +(DecimalNumber d1, int d2)
{
System.Diagnostics.Debug.Assert(d2 >= 0);
return d1 + d2.ToString();
}
public static DecimalNumber operator +(DecimalNumber d1, DecimalNumber d2)
{
return new DecimalNumber(Plus(d1.Data, d2.Data));
}
public static DecimalNumber operator *(DecimalNumber d1, DecimalNumber d2)
{
List<byte>> multiplicationSerial = new List<byte>>();
for (int i = 0; i < d1.Data.Count; i++)
{
multiplicationSerial.Add(Multiply(d2.Data, d1.Data[i], i));
}
List<byte> result = new List<byte>();
foreach (List<byte> s in multiplicationSerial)
{
result = Plus(s, result);
}
return new DecimalNumber(result);
}
public override string ToString()
{
StringBuilder str = new StringBuilder();
for (int i = _Data.Count - 1; i >= 0; i--)
{
str.Append(_Data[i].ToString());
}
return str.ToString();
}
}
有了这个类，我们计算阶乘就简单了
下面是计算任意数阶乘的函数
static public DecimalNumber Factorial(int n)
{
if (n < 0)
{
throw new System.ArgumentException("n < 0!");
}
DecimalNumber result = 1;
for (int i = 1; i <= n; i++)
{
result *= i;
}
return result;
}
用这个函数，我们计算0 到 50 的阶乘
for (int i = 0; i <= 50; i++)
{
Console.WriteLine(string.Format("{0}! = {1}", i, Factorial(i)));
}
看看结果：
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
21! = 51090942171709440000
22! = 1124000727777607680000
23! = 25852016738884976640000
24! = 620448401733239439360000
25! = 15511210043330985984000000
26! = 403291461126605635584000000
27! = 10888869450418352160768000000
28! = 304888344611713860501504000000
29! = 8841761993739701954543616000000
30! = 265252859812191058636308480000000
31! = 8222838654177922817725562880000000
32! = 263130836933693530167218012160000000
33! = 8683317618811886495518194401280000000
34! = 295232799039604140847618609643520000000
35! = 10333147966386144929666651337523200000000
36! = 371993326789901217467999448150835200000000
37! = 13763753091226345046315979581580902400000000
38! = 523022617466601111760007224100074291200000000
39! = 20397882081197443358640281739902897356800000000
40! = 815915283247897734345611269596115894272000000000
41! = 33452526613163807108170062053440751665152000000000
42! = 1405006117752879898543142606244511569936384000000000
43! = 60415263063373835637355132068513997507264512000000000
44! = 2658271574788448768043625811014615890319638528000000000
45! = 119622220865480194561963161495657715064383733760000000000
46! = 5502622159812088949850305428800254892961651752960000000000
47! = 258623241511168180642964355153611979969197632389120000000000
48! = 12413915592536072670862289047373375038521486354677760000000000
49! = 608281864034267560872252163321295376887552831379210240000000000
50! = 30414093201713378043612608166064768844377641568960512000000000000
