For循环计算阶乘

int numberInt = int.Parse(factorialNumberTextBox.Text);
for (int i = 1; i < numberInt; i++)
{
  numberInt = numberInt * i;
}
factorialAnswerTextBox.Text = numberInt.ToString();

int numberInt = int.Parse(factorialNumberTextBox.Text);
int result = numberInt;
for (int i = 1; i < numberInt; i++)
{
    result = result * i;
}
factorialAnswerTextBox.Text = result.ToString();

边注:这通常不是计算阶乘的正确方法。在开始计算之前，需要对输入进行检查，如果起始值为1或更低，则需要手动返回1。

另一方面:这也是递归方法可以发挥作用的一个完美例子。

int Factorial(int i)
{
    if (i <= 1)
        return 1;
    return i * Factorial(i - 1);
}

来晚了:

Func<int, int> factorial = n => n == 0 ? 1 : 
    Enumerable.Range(1, n).Aggregate((acc, x) => acc * x);

您可以使用这个(相当优雅的)解决方案:

    Func<int, int> factorial = null; 
    factorial = x => x <= 1 ? 1 : x * factorial(x-1);
    int numberInt = int.Parse(factorialNumberTextBox.Text);
    factorialAnswerTextBox.Text = factorial(numberInt).ToString();

public static int Factorial(int facno)
{
    int temno = 1;
    for (int i = 1; i <= facno; i++)
    {
        temno = temno * i;
    }
    return temno;
}

我来晚了，但这就是

    public ulong Factorial(uint numb)
    {
        if (numb <= 1) return 1;
        ulong final = 1;
        for (uint i = 1; i <= numb; i++)
        {
            final *= i;
        }
        return final;
    }

注意:
我使用无符号类型以获得更好的范围
因为这计算到Factorial(65)，而正常的有符号类型将给出负值

试图为n的阶乘提供一个更可靠的解决方案。这里有一个可以防止溢出，以及n的负值和零值。使用long类型的结果变量(而不是int)允许计算"更大"的值(对于long，您可以计算到并包括n = 20)。

如果发生溢出，此代码返回0，但您可以将其更改为更合适的操作。

    static long nFactorial(int n)
    {
        if (n <= 1)
        {
            return 1;
        }
        long result = 1;
        try
        {
            for (int i = 1; i <= n; i++)
            {
                result = checked(result * i); 
            }
        }
        catch (OverflowException)
        {
            return 0;
        }
        return result;
    }

我必须创建一个用于计算组合的阶乘方法，并且遇到了这样一个事实，即阶乘在相对较小的输入下会非常快地变得非常大。这是我的解决方案，不使用递归来避免堆栈溢出，并使用System.Numerics.BigInteger实现。

static BigInteger factorial(int num) {
    BigInteger result = 1;
    while (num > 1) {
        result *= num--;
    }
    return result;
}

显然，您也可以使用BigInteger作为输入，但我的用例是我正在处理int值。

使用For循环最简单的方法是:

private static int Fact(int num){
  if (num <= 1){
    return 1;
  }
  int result = 0;
  for(int i = num; i > 1; i--){
    --num; 
    result = (result == 0) ? i-- * num : result * i;
  }
  return result;
}

如果您输入Fact(3)， num的值将为3。我们将它存储到i，然后i = 3，——num将被缩减为2。如3 * 2 * 1(基数和将结束循环)。

use factorial function:

static long Factorial(long number)
    {
    if( number <= 1 )
        return 1;
    else
        return number * Factorial(number - 1);
    }

，然后调用函数

long result = Factorial(int.Parse(factorialNumberTextBox.Text));
factorialAnswerTextBox.Text = result.ToString();

 int numberInt=1 ;
            for (int i = 1; i <= int.Parse(factorialNumberTextBox.Text); i++)
            {
                numberInt = numberInt * i;
            }
            factorialNumberTextBox.Text = numberInt.ToString();

试试这个，

int numberInt = int.Parse(textBox1.Text);
        int answer = 1;
        for (int i = 1; i <= numberInt; i++)
        {
            answer = answer * i;
        }
        textBox1.Text = answer.ToString();

实现了两种方法:递归和基本阶乘计算。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication50
{
    class Program
    {
        static void Main(string[] args)
        {
        NumberManipulator manipulator = new NumberManipulator();
        Console.WriteLine("Please Enter Factorial Number:");
        int a= Convert.ToInt32(Console.ReadLine());
        Console.WriteLine("---Basic Calling--");
        Console.WriteLine("Factorial of {0} is: {1}" ,a, manipulator.factorial(a));
        Console.WriteLine("--Recursively Calling--");
        Console.WriteLine("Factorial of {0} is: {1}", a, manipulator.recursively(a));
        Console.ReadLine();
    }
}
class NumberManipulator
{
    public int factorial(int num)
    {
        int result=1;
        int b = 1;
        do
        {
            result = result * b;
            Console.WriteLine(result);
            b++;
        } while (num >= b);
        return result;
    }
    public int recursively(int num)
    {
        if (num <= 1)
        {
            return 1;
        }
        else
        {
            return recursively(num - 1) * num;
        }
    }
  }
}

static void Main()
{
    int numberFactorial = int.Parse(Console.ReadLine());
    int result = numberFactorial;
    for (int i = 1; i < numberFactorial; i++)
    {
        result = result * i;
        Console.WriteLine("{0}*{1}",numberFactorial,i);
    }
    Console.WriteLine(result);
}

一个很好的阶乘解决方案，为您的美好夜晚。

int num = Convert.ToInt32(Console.ReadLine());
int fact = 1;
for (int i = num; i > 0; --i)
    fact *= i;
Console.WriteLine(fact);

    public static void Main(string[] args)
    {
      string result =   Convert.ToString(GetFactorial(5));
        Console.WriteLine(result);
    }
    internal static int GetFactorial(int factNumber)
    {
        int factorial =1;
        int i = factNumber;            
        while(factNumber>=1)
        {
          factorial = factNumber * factorial;
            factNumber--;
        }
       return  factorial;
    }

这个怎么样?

public int FactorialFunction(int Factorial){
        int Product = Factorial -1;
        for(int Number = Factorial - 1; Number < Factorial; Number++ ) {
            Factorial = Product * Factorial;
            Product--;
        }
        return Factorial;
}