C# For循环计算阶乘

目前我有这组代码，它的目的是计算阶乘

int numberInt = int.Parse(factorialNumberTextBox.Text);

for (int i = 1; i < numberInt; i++)
{
  numberInt = numberInt * i;
}

factorialAnswerTextBox.Text = numberInt.ToString();

int numberprint=int.Parse（factorialNumberTextBox.Text）；
对于（int i=1；i

由于某种原因，它不起作用，我不知道为什么。例如，我输入3，得到的答案是-458131456，这看起来很奇怪

谢谢你的帮助。谢谢

int numberprint=int.Parse（factorialNumberTextBox.Text）；
int numberInt = int.Parse(factorialNumberTextBox.Text);
int result = numberInt;

for (int i = 1; i < numberInt; i++)
{
    result = result * i;
}

factorialAnswerTextBox.Text = result.ToString();

int结果=numberprint；
对于（int i=1；i

另一方面：这通常不是计算阶乘的正确方法。 如果起始值为1或以下，则需要先检查输入，然后才能开始计算。在这种情况下，需要手动返回1

另一方面，请注意：这也是一个很好的例子，说明递归方法在哪些方面是有用的

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

int阶乘（inti）
{
if（i
公共静态整数阶乘（int facno）
{
int-temno=1；
对于（int i=1；i使用阶乘函数：

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

int numberprint=1；
对于（int i=1；i，您可以使用此（相当优雅的）解决方案：

    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();

Func factorial=null；
阶乘=x=>x试试这个

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

        textBox1.Text = answer.ToString();

int numberprint=int.Parse（textBox1.Text）；
int-answer=1；
对于（int i=1；i参加聚会有点晚：

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

Func factorial=n=>n==0？1:
可枚举范围（1，n）.聚合（（acc，x）=>acc*x）；
实现了两种方法：递归和基本阶乘计算

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;
        }
    }
  }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
命名空间控制台应用程序50
{
班级计划
{
静态void Main（字符串[]参数）
{
NumberManipulator操纵器=新的NumberManipulator（）；
Console.WriteLine（“请输入阶乘号：”）；
int a=Convert.ToInt32（Console.ReadLine（））；
Console.WriteLine（“--Basic Calling--”）；
WriteLine（{0}的阶乘是：{1}），a，操纵器.Factorial（a））；
WriteLine（“--递归调用--”）；
WriteLine（{0}的阶乘为：{1}），a，操纵器。递归（a））；
Console.ReadLine（）；
}
}
类编号计算器
{
公共整数阶乘（整数）
{
int结果=1；
int b=1；
做
{
结果=结果*b；
控制台写入线（结果）；
b++；
}而（num>=b）；
返回结果；
}
递归公共int（int num）
{
如果（num
static void Main（）
{
int numberFactorial=int.Parse（Console.ReadLine（））；
int结果=numberFactorial；
for（int i=1；i
这个怎么样

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

公共整数阶乘函数（整数阶乘）{
整数乘积=阶乘-1；
对于（整数=阶乘-1；数<阶乘；数++）{
阶乘=乘积*阶乘；
产品--；
}
收益因子；
}
我参加聚会迟到了，但就在这里

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

public-ulong阶乘（uint-numb）
{
如果（numb试图为n阶乘提供一个更可靠的解决方案，这里有一个方法可以防止溢出以及n的负值和零值。使用long类型的结果变量（而不是int）可以计算“更大”的值（很长时间内，您最多可以计算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;
    }

静态长nFactorial（int n）
{
if（n我必须创建一个计算组合的阶乘方法，并且由于阶乘以相对较小的输入快速变大这一事实而绊倒。以下是我的解决方案，不使用递归来避免堆栈溢出，并使用
System.Numerics.BigInteger
实现

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

显然，您也可以使用
biginger
进行输入，但我的用例是，我正在处理
int
值。
对于您美好的夜晚来说，这是一个不错的阶乘解决方案

int num=Convert.ToInt32（Console.ReadLine（））；
int-fact=1；
for（int i=num；i>0；--i）
事实*=i；
控制台。写入线（事实）；
<代码> >在循环中改变循环条件<代码>代码> <代码>。使用另一个变量。您正在更改for循环内的变量编号，并且使用相同的变量来进行比较。同时，请注意，使用32位<代码> int <代码>，您只能计算多达12个阶乘。改为64位
long
。编辑：嗯，
long
只适用于最多20个阶乘。：）编辑：打开
biginger
！感谢大家的帮助！完美：）请注意，这不适用于0！的情况，0！的结果应为1。它仅在NumberPrint小于等于20时有效，对于较大的值，将发生整数结果溢出。我今天制作了一个版本，用于计算组合，并在（明显的？）上绊倒事实上，阶乘在输入相对较小的情况下迅速变大。简单的解决方案是使用System.Numerics.BigInteger，而不是任何值类型的整数（即使是UInt64）。这是一个不错的解决方案，但您应该注意捕捉n=0并短路以返回1，而不是工程？：-）@JorisBrauns：不是真的……它是尾部递归的，如果输入的数字足够大，不会导致堆栈溢出。Wim Ombelets的递归解决方案最终会。它工作到12！））无法更改为BigInteger，因为它是可枚举的。范围（1，n）可枚举的。范围（1，n）
    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;
}

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

    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;
    }

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