¿Por qué los factoriales no son lo suficientemente rápidos como para calcularlos ahora?
¿Hiciste algo como esto?
función factorial (n) {
if (n === 0 || n === 1) {
retorno 1;
}
retorno n * factorial (n-1);
}
- ¿Qué es una computadora portátil para un estudiante de BCA?
- ¿Es posible programar una computadora para pensar como un verdadero cerebro humano?
- ¿Cómo se almacenan una cadena y números en la memoria en NASM?
- ¿Qué juegos son compatibles con 2 GB de RAM con una tarjeta gráfica de 1 GB en Windows 10?
- ¿Qué marca de computadora portátil recomienda para alguien que se prepara para comenzar una carrera en bienes raíces?
¿O hiciste algo como esto?
función factorial (n) {
hecho var = 1;
para (var i = 1; i <= n; i ++) {
hecho * = i;
}
hecho de retorno;
}
Estar en una base diferente no solucionará el último cuello de botella para el cálculo, la multiplicación es ineficiente para números realmente grandes.
Podría ser un poco menos difícil si los números se manejan en otra base, pero eso requiere tirar la mayor parte de lo que ha producido Computer Engineering en los últimos 60 años.
Entonces, ¿qué podemos hacer entonces?
Veamos, podemos paralelizarlo, para reducir la cantidad de multiplicación que cada procesador tiene que hacer individualmente.
#include
#include
#include
#ifndef NO_THREAD
#define THREAD_COUNT 4
#más
#define THREAD_COUNT 1
#terminara si
mpz_class factorial (const mpz_class & n) {
mpz_class comienza [THREAD_COUNT],
resultado = 1;
mpz_class termina [THREAD_COUNT];
#ifndef NO_THREAD
para (int i = 0; i <THREAD_COUNT; i ++) {
comienza [i] = (n / THREAD_COUNT) * i + (i == 0? 1: 0);
termina [i] = (n / THREAD_COUNT) * (i + 1);
}
#pragma omp parallel num_threads (THREAD_COUNT)
{
#pragma omp para
para (int i = 0; i <THREAD_COUNT; i ++) {
for (mpz_class j = comienza [i] +1; j <termina [i]; j ++) {
comienza [i] * = j;
}
}
}
para (int i = 0; i <THREAD_COUNT; i ++) {
resultado * = comienza [i];
}
#más
for (mpz_class j = 1; j <= n; ++ j) {
resultado * = j;
}
#terminara si
resultado de retorno;
}
int main () {
std :: número de cadena;
mpz_class n;
std :: cin >> número;
n = mpz_class (número);
std :: cout << factorial (n) << std :: endl;
devuelve 0;
}
Por lo tanto, compilado correctamente, esto dará como resultado una de dos cosas, una versión con subprocesos y una versión sin subprocesos.
La diferencia de velocidad es bastante impresionante, con n = 1000000, la versión sin rosca tarda 67 segundos, la versión con rosca tarda 18.
Sin embargo, eso no es realmente una respuesta a esto.
Voy a escribir una clase de número basada en una cadena, que usará base-10. Editaré esta respuesta para mostrar que no ayuda.