factorielle de gros nombres avec des chaînes en c ++

Je fais un programme factoriel avec des chaînes parce que j’ai besoin de la factorielle des nombres supérieurs à 250

J’entends avec:

ssortingng factorial(int n){ ssortingng fact="1"; for(int i=2; i<=n; i++){ b=atoi(fact)*n; } } 

Mais le problème est que atoi ne fonctionne pas. Comment puis-je convertir ma chaîne en un entier.

Et le plus important Est-ce que je veux savoir si le programme de cette manière fonctionnera avec la factorielle de 400 par exemple?

Il existe un site Web qui calculera les factorielles pour vous: http://www.nitrxgen.net/factorialcalc.php . Il rapporte:

La factorielle résultante de 250! est 493 chiffres long. Le résultat contient également 62 zéros à la fin (ce qui représente 12,58% de l’ensemble)

3232856260909107732320814552024368470994843717673780666747942427112823747555111209488817915371028199450928507353189432926730931712808990822791030279071281921676527240189264733218041186261006832925365133678939089569935713530175040513178760077247933065402339006164825552248819436572586057399222641254832982204849137721776650641276858807153128978777672951913990844377478702589172973255150283241787320658188482062478582659808848825548800000000000000000000000000000000000000000000000000000000000000

De nombreux systèmes utilisant C ++ double ne fonctionnent que jusqu’à 1E + 308 ou environ; la valeur de 250! est trop volumineux pour être stocké dans de tels nombres.

Par conséquent, vous devrez utiliser une sorte de bibliothèque arithmétique multi-précision, que ce soit votre propre conception utilisant ssortingng valeurs de ssortingng C ++ ou une autre bibliothèque multi-précision largement utilisée (GNU GMP par exemple).

Le code ci-dessous utilise un unsigned double long pour calculer les très gros chiffres.

 #include int main() { long k=1; while(k!=0) { cout<<"\nLarge Factorial Calculator\n\n"; cout<<"Enter a number be calculated:"; cin>>k; if (k<=33) { unsigned double long fact=1; fact=1; for(int b=k;b>=1;b--) { fact=fact*b; } cout<<"\nThe factorial of "<0) { total=numArr[i]*count+rem; rem=0; if(total>9) { numArr[i]=total%10; rem=total/10; } else { numArr[i]=total; } i--; } rem=0; total=0; i=10000; } cout<<"The factorial of "< 

Sortie:

 ![Large Factorial Calculator Enter a number be calculated:250 The factorial of 250 is 32328562609091077323208145520243684709948437176737806667479424271128237475551112 09488817915371028199450928507353189432926730931712808990822791030279071281921676 52724018926473321804118626100683292536513367893908956993571353017504051317876007 72479330654023390061648255522488194365725860573992226412548329822048491377217766 50641276858807153128978777672951913990844377478702589172973255150283241787320658 18848206247858265980884882554880000000000000000000000000000000000000000000000000 000000000000][1] 

Vous ne savez pas pourquoi vous essayez d’utiliser une chaîne. Probablement pour économiser de l’espace en n’utilisant pas de vecteur entier? Ceci est ma solution en utilisant vecteur entier pour stocker factorial et print.Works bien avec 400 ou n’importe quel grand nombre d’ailleurs!

 //Factorial of a big number #include #include using namespace std; int main(){ int num; cout<<"Enter the number :"; cin>>num; vector res; res.push_back(1); int carry=0; for(int i=2;i<=num;i++){ for(int j=0;j=0;i--) cout< 

Entrez le nombre: 400 Factorielle de 400:

Vous pouvez comstackr atoi en ajoutant c_str (), mais ce sera un long chemin à parcourir jusqu’à obtenir factoriel. Actuellement, vous n’avez pas de b autour. Et si vous en aviez, vous multipliez encore int par int. Ainsi, même si vous convertissez éventuellement cette chaîne en chaîne avant le renvoi, votre étendue rest limitée. Tant que vous ne commencez pas à faire la multiplication avec ASCII ou à utiliser une bibliothèque bignum, inutile d’avoir une chaîne de caractères.

Votre factorielle dépend de la conversion en int, qui débordera assez rapidement, vous voulez donc pouvoir calculer de grandes factorielles de cette façon. Pour implémenter correctement le calcul sur les grands nombres, vous devez implémenter la logique, comme pour le calcul sur papier, règles qui vous ont été enseignées à l’école primaire, mais traitez les ints de longue durée comme des “atomes”, pas des chiffres individuels. Et ne le faites pas sur des chaînes, ce serait péniblement lent et plein de conversions méchantes

La logique devrait être:

 unsigned int factorial(int n) { unsigned int b=1; for(int i=2; i<=n; i++){ b=b*n; } return b; } 

Cependant b peut être débordé. Donc, vous pouvez utiliser un type entier plus grand. Vous pouvez également utiliser un type de type float inexact mais pouvant contenir des nombres beaucoup plus importants. Mais il semble qu'aucun des types intégrés ne soit assez gros.

Si vous voulez résoudre factorielle pour des nombres supérieurs à 12, vous devez adopter une approche différente de celle utilisée avec atoi , car cela vous donne simplement un entier 32 bits et, quoi que vous fassiez, vous n’obtiendrez pas plus de 2 milliards (à prendre ou à prendre) de cela. Même si vous doublez la taille du nombre, vous n’allez plus que 20 ou 21.

Il n’est pas si difficile (relativement parlant) d’écrire une routine de multiplication de chaîne qui prend un petit nombre (ish), multiplie chaque chiffre et répercute les résultats sur le nombre (commencez au dos du nombre et complétez-le).

Voici mon code obscurci – il est intentionnellement écrit de sorte que vous ne pouvez pas le prendre et le remettre comme devoir, mais il semble fonctionner (correspond au numéro indiqué dans la réponse de Jonathan Leffler), et fonctionne jusqu’à (au moins) 20000! [sujet à assez de mémoire].

 std::ssortingng operator*(const std::ssortingng &s, int x) { int l = (int)s.length(); std::ssortingng r; r.resize(l); std::fill(r.begin(), r.end(), '0'); int b = 0; int e = ~b; const int c = 10; for(int i = l+e; i != e;) { int d = (s[i]-0x30) * x, p = i + b; while (d && p > e) { int t = r[p] - 0x30 + (d % c); r[p] = (t % c) + 0x30; d = t / c + d / c; p--; } while (d) { r = static_cast((d % c) +0x30)+r; d /= c; b++; } i--; } return r; } 

En C ++, le type entier le plus grand est ‘long long’ et contient 64 bits de mémoire, vous ne pouvez donc évidemment pas en stocker 250! dans un type entier. C’est une bonne idée d’utiliser des chaînes, mais ce que vous faites avec votre code est (je n’ai jamais utilisé la fonction atoi (), donc je ne sais pas s’il fonctionne même avec des chaînes plus grandes qu’un caractère, mais cela ne fonctionne pas. peu importe):

  1. convertir la chaîne en entier (chaîne qui, si ce code a bien fonctionné, contient en un instant la valeur de 249!)
  2. multiplier la valeur de la chaîne

Ainsi, après la multiplication, vous ne convertissez même pas l’entier en chaîne. Et même si vous faisiez cela, à un moment où vous reconvertiriez la chaîne en un entier, votre programme planterait, car l’entier ne pourrait pas contenir la valeur de la chaîne.

Ma suggestion est d’utiliser une classe pour les grands entiers. Malheureusement, il n’y en a pas de disponible en C ++, vous devrez donc le coder vous-même ou en trouver un sur Internet. Mais ne vous inquiétez pas, même si vous le codez vous-même, si vous réfléchissez un peu, vous verrez que ce n’est pas si difficile. Vous pouvez même utiliser votre idée avec les chaînes, qui, même difficiles, ne sont pas la meilleure approche, pour ce problème, vous obtiendrez toujours les résultats dans les délais souhaités sans trop utiliser de mémoire.