В настоящее время у меня есть этот набор кода и его предназначение для вычисления факториалов.
int numberInt = int.Parse(factorialNumberTextBox.Text);
for (int i = 1; i < numberInt; i++)
{
numberInt = numberInt * i;
}
factorialAnswerTextBox.Text = numberInt.ToString();
По какой-то причине это не работает, и я не знаю, почему. Например, я буду вводить 3 и получить ответ как -458131456, который кажется действительно странным.
Любая помощь оценивается. Благодаря
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) позволяет вычислять "более крупные" значения (долгое время вы можете рассчитать до и включая 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;
}
используйте факториальную функцию:
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);
}
Мне пришлось создать метод факториала для вычисления комбинаций, и я столкнулся с тем фактом, что факториалы очень быстро становятся очень большими при относительно небольших затратах. Здесь мое решение без использования рекурсии, чтобы избежать и реализовано с использованием System.Numerics.BigInteger.
static BigInteger factorial(int num) {
BigInteger result = 1;
while (num > 1) {
result *= num--;
}
return result;
}
Очевидно, что вы также можете использовать BigInteger для ввода, но мой вариант использования состоял в том, что я обрабатывал значения int.
Хорошее факториальное решение для вашего хорошего вечера.
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;
}