Cómo encontrar el factorial de un número grande, como 100, en C

#include

#define MAX 10000

nulo factorial de (int);

multiplicación nula (int);

int longitud = 0;

hecho de hecho [MAX];

int main () {

int num;

int i;

printf (“Ingrese cualquier número entero:”);

scanf (“% d”, & num);

hecho [0] = 1;

factorial de (num);

printf (“Factorial es:”);

para (i = longitud; i> = 0; i -) {

printf (“% d”, hecho [i]);

}

devuelve 0;

}

nulo factorialof (int num) {

int i;

para (i = 2; i <= num; i ++) {

multiplicar (i);

}

}

multiplicación nula (int num) {

largo i, r = 0;

int arr [MAX];

para (i = 0; i <= longitud; i ++) {

arr [i] = hecho [i];

}

para (i = 0; i <= longitud; i ++) {

hecho [i] = (arr [i] * num + r)% 10;

r = (arr [i] * num + r) / 10;

// printf (“% d”, r);

}

si (r! = 0) {

mientras que (r! = 0) {

hecho [i] = r% 10;

r = r / 10;

i ++;

}

}

longitud = i-1;

}

Nota: Puede cambiar el valor de MAX para encontrar factorial de números demasiado grandes.

Fuente: http://www.cquestions.com

factorial (n)
1) Cree una matriz ‘res []’ de tamaño MAX donde MAX es el número de dígitos máximos en la salida.
2) Inicialice el valor almacenado en ‘res []’ como 1 e inicialice ‘res_size’ (tamaño de ‘res []’) como 1.
3) Haga lo siguiente para todos los números de x = 2 a n.
…… a) Multiplique x con res [] y actualice res [] y res_size para almacenar el resultado de la multiplicación.

¿Cómo multiplicar un número ‘x’ con el número almacenado en res []?
La idea es utilizar las matemáticas escolares simples. Uno por uno multiplicamos x con cada dígito de res []. El punto importante a tener en cuenta aquí es que los dígitos se multiplican del dígito más a la derecha al más a la izquierda. Si almacenamos dígitos en el mismo orden en res [], entonces se hace difícil actualizar res [] sin espacio adicional. Es por eso que res [] se mantiene en forma inversa, es decir, los dígitos de derecha a izquierda se almacenan.
multiplicar (res [], x)
1) Inicializar carry como 0.
2) Haga lo siguiente para i = 0 para res_size – 1
… .A) Encuentre el valor de res [i] * x + carry. Deje que este valor sea prod.
… .B) Actualice res [i] almacenando el último dígito de producción en él.
… .C) Actualice el carry almacenando los dígitos restantes en el carry.
3) Ponga todos los dígitos de carry en res [] y aumente res_size por el número de dígitos en carry.
Ejemplo para mostrar el funcionamiento de multiplicar (res [], x) Un número 5189 se almacena en res [] de la siguiente manera. res [] = {9, 8, 1, 5} x = 10 Inicializar carry = 0; i = 0, prod = res [0] * x + carry = 9 * 10 + 0 = 90. res [0] = 0, carry = 9 i = 1, prod = res [1] * x + carry = 8 * 10 + 9 = 89 res [1] = 9, carry = 8 i = 2, prod = res [2] * x + carry = 1 * 10 + 8 = 18 res [2] = 8, carry = 1 i = 3 , prod = res [3] * x + carry = 5 * 10 + 1 = 51 res [3] = 1, carry = 5 res [4] = carry = 5 res [] = {0, 9, 8, 1, 5}
A continuación se muestra la implementación en C ++ del algoritmo anterior.
// Programa C ++ para calcular factorial de grandes números
#include
usando el espacio de nombres estándar;

// Número máximo de dígitos en la salida
#define MAX 500

int multiply (int x, int res [], int res_size)

// Esta función encuentra factorial de grandes números y los imprime
factorial nulo (int n)
{
int res [MAX];

// Inicializar resultado
res [0] = 1;
int res_size = 1;

// ¡Aplica la fórmula factorial simple n! = 1 * 2 * 3 * 4 … * n
para (int x = 2; x <= n; x ++)
res_size = multiplicar (x, res, res_size);

cout << "El factorial del número dado es \ n";
para (int i = res_size-1; i> = 0; i–)
cout << res [i];
}

// Esta función multiplica x con el número representado por res [].
// res_size es el tamaño de res [] o el número de dígitos en el número representado
// por res []. Esta función usa matemática escolar simple para la multiplicación.
// Esta función puede valorar res_size y devuelve el nuevo valor de res_size
int multiply (int x, int res [], int res_size)
{
int carry = 0; // Inicializar carry

// Uno por uno multiplican n con dígitos individuales de res []
para (int i = 0; i {
int prod = res [i] * x + carry;
res [i] = prod% 10; // Almacenar el último dígito de ‘prod’ en res []
llevar = prod / 10; // Poner descanso en llevar
}

// Poner carry en res y aumentar el tamaño del resultado
mientras (llevar)
{
res [res_size] = llevar% 10;
llevar = llevar / 10;
res_size ++;
}
return res_size;
}

// Programa del conductor
int main ()
{
factorial (100);
devuelve 0;
}
Salida:
El factorial del número dado es 9332621544394415268169923885626670049071596826438162146859296389 5217599993229915608941463976156518286253697920827223758251185210 9168640000000000000000000000000000000000000000000000000000000000000000000000000000000000

Fuente: – Factorial de un gran número – GeeksforGeeks

#include

int main ()
{
datos int, hecho [200], i, temp, m, k;

scanf (“% d”, & data); // data = 100 por 100!
m = 1;
hecho [0] = 1;
para (i = 2; i <= datos; ++ i)
{
temp = 0;
para (k = 0; k {
temp + = hecho [k] * i;
hecho [k] = temp% 10;
temp = temp / 10;
}
while (temp> 0)
{
hecho [m] = temp% 10;
m = m + 1;
temp = temp / 10;

}

}

para (k = m-1; k> = 0; –k)
printf (“% d”, hecho [k]);
printf (“\ n”);

devuelve 0;
}

Para obtener una explicación, vaya a: Cálculos factoriales de un gran número en C / C ++: un tutorial

Esto es de Cómo calcular 100 factorial (¡100!) En C y solo lo estoy citando.

Primero haremos una matriz para almacenar los dígitos del resultado de la multiplicación y almacenar el primer número en la matriz.

#include
#define MAX_DIGIT 200

int main ()
{
hecho hecho [MAX_DIGIT] = {1,2,3,4};
devuelve 0;
}

Hemos hecho un ‘hecho’ de matriz y hemos hecho todos sus elementos 0.

Ahora, haremos una variable para mantener el registro de la cantidad de dígitos actualmente en el resultado.

#include
#define MAX_DIGIT 200

int main ()
{
hecho hecho [MAX_DIGIT] = {4,3,2,1};
int número_de_digito = 4, i, carry = 0;
devuelve 0;
}

Ahora, haremos la multiplicación (estamos multiplicando 1234 con 10 en este ejemplo).

#include
#define MAX_DIGIT 200

int main ()
{
hecho hecho [MAX_DIGIT] = {4,3,2,1};
int número_de_digito = 4, i, carry = 0;

para (i = 0; i {
int x = hecho [i] * 10; //producto
hecho [i] = (x + carry)% 10;
llevar = (x + llevar) / 10;
// estamos al final del número con algunos carry restantes
// el número de dígitos aumentará en 1
if (i == number_of_digit-1 && carry> 0)
número_de_digito ++;
}

// para mostrar el factorial calculado
para (i = número_de_digito-1; i> = 0; i–)
{
printf (“% d”, hecho [i]);
}
printf (“\ n”);

devuelve 0;
}

1234
* 10
____
0 llevar – 4

1234
* 10
____
40 llevar – 3

1234
* 10
____
340 llevar – 2

1234
* 10
____
2340 carry – 1

1234
* 10
____
12340

Comprendamos el bucle for paso a paso.

int x = fact[i]*10 – hecho [i] es 4. Entonces, x es 40.

fact[i] = (x+carry)%10 – ‘carry’ es 0. Entonces, fact [i] se convertirá en 0. Actualizamos fact [i] como lo hacíamos en la multiplicación a mano.

carry = (x+carry)/10 – El carry se convertirá en 4.

De manera similar en el siguiente paso, int x = fact[i]*10 evaluará a x = 3*10 y fact[i] = (x+carry)%10 hará factual [i] (30 + 4)% 10 ie , 4. Finalmente, ‘carry’ se convertirá en 3. Del mismo modo, continuaremos más allá.

Después de comprender el código de multiplicación, el cálculo factorial es muy simple. Simplemente iteraremos de 1 al número y haremos la multiplicación. Entonces, para calcular el factorial de 4, primero multiplicaremos 1 con 2 y almacenaremos el resultado en la matriz y luego multiplicaremos el resultado en la matriz con 3 y luego nuevamente almacenaremos este resultado en la matriz y finalmente, multiplicaremos este resultado con 4 y almacenar este resultado en la matriz.

Entonces, después de la multiplicación de 1 por 2.

2

Después de la multiplicación de este resultado por 3.

6 6

Nuevamente, multiplicando el resultado por 4.

4 4

2

#include
#define MAX_DIGIT 200

int main ()
{
hecho hecho [MAX_DIGIT] = {4,3,2,1};
int número_de_digito = 4, i, carry = 0;

para (i = 0; i {
int x = hecho [i] * 10; //producto
hecho [i] = (x + carry)% 10;
llevar = (x + llevar) / 10;
// estamos al final del número con algunos carry restantes
// el número de dígitos aumentará en 1
if (i == number_of_digit-1 && carry> 0)
número_de_digito ++;
}

// para mostrar el factorial calculado
para (i = número_de_digito-1; i> = 0; i–)
{
printf (“% d”, hecho [i]);
}
printf (“\ n”);

devuelve 0;
}

Está bien explicado en Cómo calcular 100 factorial (¡100!) En C

Aqui tienes….

Código C ++:

#include
usando el espacio de nombres estándar;

int main () {
int n; cin >> n;
vector v;
v.push_back (1);
para (int i = 2; i <= n; i ++) {
for (auto it = v.begin (); it! = v.end (); it ++)
* it * = i;
for (int j = 0; j si (v [j] <10) continúa;
if (j == v.size () – 1) v.push_back (0);
v [j + 1] + = v [j] / 10;
v [j]% = 10;
}
}
for (auto it = v.rbegin (); it! = v.rend (); it ++)
cout << * it;

devuelve 0;
}

/ *
Escrito por Alex Vipul Verma en Xcode en OS X El Capitan
Compilado usando las herramientas de línea de comandos de Xcode
* /

#include
factorial doble largo (int x);
int main ()
{
int num;
largo doble xfact;
pone (“Ingrese un número para encontrar su factorial”);
scanf (“% d”, & num);
si (num == 0 || num == 1)
pone (“El factorial del número dado es 1”);
más si (num <0)
put (“No se puede encontrar el factorial de un número negativo”);
más
{
xfact = factorial (num);
printf (“\ nEl factorial del número dado es% 1.0Lf \ n”, xfact);
}
devuelve 0;
}
factorial doble largo (int x)
{
hecho doble largo = 1;
int cuenta = 1;
para (cuenta = 1; cuenta <= x; cuenta ++)
hecho = hecho * cuenta;
hecho de retorno;
}

Ejecute este programa, puede calcular el factorial de los números que son inferiores a 1755, lo acabo de compilar …

El siguiente enlace explica el programa C para calcular el factorial de un número grande como 100. Cómo calcular 100 factorial (100!) En C

Uno de los mejores enfoques que he visto para este asunto es aquí: Factorial de un gran número.

Es una solución muy simple y detallada.