[原创]阶乘(1000的阶乘,10000的阶乘...)以及大数相乘(几十万位乘几十万位)

10进制--> 1,000,000,000 进制
1000!阶乘0.048s 48ms (包含输出,以及每1000输出一次)
10000!阶乘5.553125s  5531.25ms (包含输出,以及每1000输出一次)

代码如下:

C# code

   
   
   
   

    
    
    
    
     
    
    
    
    using
    
    
    
     System; 
    
    
    
    using
    
    
    
     System.Collections.Generic; 
    
    
    
    using
    
    
    
     System.Linq; 
    
    
    
    using
    
    
    
     System.Text; 
    
    
    
    using
    
    
    
     System.IO; 
    
    
    
    namespace
    
    
    
     Factorial { 
    
    
    
    class
    
    
    
     Program { 
    
    
    
    static
    
    
    
     
    
    
    
    void
    
    
    
     Main(
    
    
    
    string
    
    
    
    [] args) { 
    
    
    
    int
    
    
    
     Number 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; 
    
    
    
    //
    
    
    
    接收输入
    
    
    
     
    
    
    
     Console.WriteLine(
    
    
    
    @"
    
    
    
    Please input a numeric:
    
    
    
    "
    
    
    
    ); Number 
    
    
    
    =
    
    
    
     
    
    
    
    int
    
    
    
    .Parse(Console.ReadLine().Trim()); DateTime BeginTime 
    
    
    
    =
    
    
    
     DateTime.Now; DateTime EndTime 
    
    
    
    =
    
    
    
     DateTime.Now; 
    
    
    
    //
    
    
    
    阶乘计算
    
    
    
     
    
    
    
     FactorialWithBaseNumberAndList.FactorialCalculation(Number); EndTime 
    
    
    
    =
    
    
    
     DateTime.Now; Console.WriteLine(EndTime.Subtract(BeginTime).TotalMilliseconds 
    
    
    
    +
    
    
    
     
    
    
    
    "
    
    
    
     ms!
    
    
    
    "
    
    
    
    ); Console.ReadKey(); } } } 
    
    
    
    using
    
    
    
     System; 
    
    
    
    using
    
    
    
     System.Collections.Generic; 
    
    
    
    using
    
    
    
     System.Linq; 
    
    
    
    using
    
    
    
     System.Text; 
    
    
    
    namespace
    
    
    
     Factorial { 
    
    
    
    class
    
    
    
     FactorialWithBaseNumberAndList { 
    
    
    
    public
    
    
    
     
    
    
    
    const
    
    
    
     
    
    
    
    ulong
    
    
    
     baseNumber 
    
    
    
    =
    
    
    
     
    
    
    
    1000000000
    
    
    
    ; 
    
    
    
    public
    
    
    
     
    
    
    
    static
    
    
    
     List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
     GetProduct(List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
     FactorX, List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
     FactorY) { List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
     ret 
    
    
    
    =
    
    
    
     
    
    
    
    new
    
    
    
     List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
    (); 
    
    
    
    ulong
    
    
    
     Carry 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; 
    
    
    
    //
    
    
    
    进位数
    
    
    
     
    
    
    
     
    
    
    
    ulong
    
    
    
     Product 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; 
    
    
    
    //
    
    
    
    乘积
    
    
    
     
    
    
    
     
    
    
    
    int
    
    
    
     Position 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; 
    
    
    
    //
    
    
    
    位数
    
    
    
     
    
    
    
     
    
    
    
    ulong
    
    
    
     Number 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; 
    
    
    
    //
    
    
    
    乘积 % baseNumber 取余的余数
    
    
    
     
    
    
    
     
    
    
    
    ulong
    
    
    
     TempNumber 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; 
    
    
    
    //
    
    
    
    旧值 
    
    
    
    //
    
    
    
    循环历遍因数X中的元素
    
    
    
     
    
    
    
     
    
    
    
    for
    
    
    
     (
    
    
    
    int
    
    
    
     i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     FactorX.Count; i
    
    
    
    ++
    
    
    
    ) { 
    
    
    
    //
    
    
    
    清除进位数
    
    
    
     
    
    
    
     Carry 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; 
    
    
    
    //
    
    
    
    循环历遍因数Y中的元素
    
    
    
     
    
    
    
     
    
    
    
    for
    
    
    
     (
    
    
    
    int
    
    
    
     j 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; j 
    
    
    
    <
    
    
    
     FactorY.Count; j
    
    
    
    ++
    
    
    
    ) { 
    
    
    
    //
    
    
    
    取得乘积,例如 9 * 9 = 81
    
    
    
     
    
    
    
     Product 
    
    
    
    =
    
    
    
     FactorX[i] 
    
    
    
    *
    
    
    
     FactorY[j]; 
    
    
    
    //
    
    
    
    取得位数,例如 因数X的第1位 * 因数Y的第1位,那么其乘积所在开始的位数则为2, 
    
    
    
    //
    
    
    
    比如 20 * 30 中两个十位数相乘其结果 
    
    
    
    //
    
    
    
    开始的位数为(2所在位数为1 + 3所在位数为1) = 6所在位数为2,即是600
    
    
    
     
    
    
    
     Position 
    
    
    
    =
    
    
    
     i 
    
    
    
    +
    
    
    
     j; 
    
    
    
    //
    
    
    
    取得乘积 % baseNumber 取余的余数
    
    
    
     
    
    
    
     Number 
    
    
    
    =
    
    
    
     Product 
    
    
    
    %
    
    
    
     baseNumber; 
    
    
    
    //
    
    
    
    判断乘积结果中该位是否有值,有值则相加,否则插入
    
    
    
     
    
    
    
     
    
    
    
    if
    
    
    
     (ret.Count 
    
    
    
    >
    
    
    
     Position) { 
    
    
    
    //
    
    
    
    临时存放旧值
    
    
    
     
    
    
    
     TempNumber 
    
    
    
    =
    
    
    
     ret[Position]; 
    
    
    
    //
    
    
    
    更新当前位的值,当前位值 = (旧值 + 取得乘积 % baseNumber 取余的余数 + 上一次进位数) % baseNumber 取余
    
    
    
     
    
    
    
     ret[Position] 
    
    
    
    =
    
    
    
     (TempNumber 
    
    
    
    +
    
    
    
     Number 
    
    
    
    +
    
    
    
     Carry) 
    
    
    
    %
    
    
    
     baseNumber; 
    
    
    
    //
    
    
    
    取得当前进位值,當前進位值 = (旧值 + 乘积 + 进位)/baseNumber 取整
    
    
    
     
    
    
    
     Carry 
    
    
    
    =
    
    
    
     (
    
    
    
    ulong
    
    
    
    )Math.Floor((TempNumber 
    
    
    
    +
    
    
    
     Product 
    
    
    
    +
    
    
    
     Carry) 
    
    
    
    /
    
    
    
     baseNumber 
    
    
    
    *
    
    
    
     
    
    
    
    1.0
    
    
    
    ); } 
    
    
    
    else
    
    
    
     { 
    
    
    
    //
    
    
    
    插入位数,值
    
    
    
     
    
    
    
     ret.Add((Number 
    
    
    
    +
    
    
    
     Carry) 
    
    
    
    %
    
    
    
     baseNumber); 
    
    
    
    //
    
    
    
    取得当前进位值,當前進位值 = (乘积 + 进位)/10 取整
    
    
    
     
    
    
    
     Carry 
    
    
    
    =
    
    
    
     (
    
    
    
    ulong
    
    
    
    )Math.Floor((Product 
    
    
    
    +
    
    
    
     Carry) 
    
    
    
    /
    
    
    
     baseNumber 
    
    
    
    *
    
    
    
     
    
    
    
    1.0
    
    
    
    ); } } 
    
    
    
    //
    
    
    
    当最后进位数不为0时,需要新增最高位,其值为进位数
    
    
    
     
    
    
    
     
    
    
    
    if
    
    
    
     (Carry 
    
    
    
    !=
    
    
    
     
    
    
    
    0
    
    
    
    ) ret.Add(Carry); } 
    
    
    
    return
    
    
    
     ret; } 
    
    
    
    ///
    
    
    
     
    
    
    
    <summary>
    
    
    
     
    
    
    
    ///
    
    
    
     阶乘计算 
    
    
    
    ///
    
    
    
     
    
    
    
    </summary>
    
    
    
     
    
    
    
     
    
    
    
    public
    
    
    
     
    
    
    
    static
    
    
    
     
    
    
    
    void
    
    
    
     FactorialCalculation(
    
    
    
    int
    
    
    
     Number) { List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
     ProductZ 
    
    
    
    =
    
    
    
     
    
    
    
    new
    
    
    
     List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
    (); 
    
    
    
    //
    
    
    
    乘积Z - Dictionary
    
    
    
     
    
    
    
     List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
     FactorX 
    
    
    
    =
    
    
    
     
    
    
    
    new
    
    
    
     List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
    (); 
    
    
    
    //
    
    
    
    因数X - Dictionary 
    
    
    
    //
    
    
    
    初始化乘积,避免出错
    
    
    
     
    
    
    
     ProductZ.Add(
    
    
    
    1
    
    
    
    ); 
    
    
    
    //
    
    
    
    阶乘数历遍,从1开始
    
    
    
     
    
    
    
     
    
    
    
    for
    
    
    
     (
    
    
    
    int
    
    
    
     i 
    
    
    
    =
    
    
    
     
    
    
    
    1
    
    
    
    ; i 
    
    
    
    <=
    
    
    
     Number; i
    
    
    
    ++
    
    
    
    ) { 
    
    
    
    //
    
    
    
    清空因数
    
    
    
     
    
    
    
     FactorX.Clear(); 
    
    
    
    //
    
    
    
    每1000个数输出一次
    
    
    
     
    
    
    
     
    
    
    
    if
    
    
    
     (i 
    
    
    
    %
    
    
    
     
    
    
    
    1000
    
    
    
     
    
    
    
    ==
    
    
    
     
    
    
    
    0
    
    
    
    ) Console.WriteLine(i.ToString()); FactorX.Add(Convert.ToUInt64(i)); 
    
    
    
    //
    
    
    
    计算乘积,将上一次的结果作为因数Y传入
    
    
    
     
    
    
    
     ProductZ 
    
    
    
    =
    
    
    
     GetProduct(FactorX, ProductZ); } 
    
    
    
    //
    
    
    
    显示结果
    
    
    
     
    
    
    
     ShowResult(ProductZ); } 
    
    
    
    ///
    
    
    
     
    
    
    
    <summary>
    
    
    
     
    
    
    
    ///
    
    
    
     显示结果 
    
    
    
    ///
    
    
    
     
    
    
    
    </summary>
    
    
    
     
    
    
    
    ///
    
    
    
     
    
    
    
    <param name="Product">
    
    
    
    乘积 - List 
    
    
    
    </param>
    
    
    
     
    
    
    
    ///
    
    
    
     
    
    
    
    <param name="DecimalDigits">
    
    
    
    小数位数 - int
    
    
    
    </param>
    
    
    
     
    
    
    
     
    
    
    
    public
    
    
    
     
    
    
    
    static
    
    
    
     
    
    
    
    void
    
    
    
     ShowResult(List
    
    
    
    <
    
    
    
    ulong
    
    
    
    >
    
    
    
     Product) { StringBuilder sb 
    
    
    
    =
    
    
    
     
    
    
    
    new
    
    
    
     StringBuilder(); 
    
    
    
    for
    
    
    
     (
    
    
    
    int
    
    
    
     i 
    
    
    
    =
    
    
    
     Product.Count 
    
    
    
    -
    
    
    
     
    
    
    
    1
    
    
    
    ; i 
    
    
    
    >=
    
    
    
     
    
    
    
    0
    
    
    
    ; i
    
    
    
    --
    
    
    
    ) { sb.Append(Product[i]); } Console.WriteLine(
    
    
    
    "
    
    
    
    Result:
    
    
    
    "
    
    
    
     
    
    
    
    +
    
    
    
     sb.ToString()); } } }