Factorial (recapitulare)

În matematică factorialul unui număr întreg pozitiv n este notat cu n! și este egal
cu produsul tuturor numerelor naturale mai mici sau egale cu n. adica n!
=1*2*3*4*....*n

Prin definiție, 0!=1.

Se observa ca factorialul numarului n este n*(n-1)! (n inmultit cu factorialul lui n-
1)
5!=1*2*3*4*5; dar 1*2*3*4=4! si atunci 5! = 4! * 5 etc
https://en.wikipedia.org/wiki/Factorial

Factorialul unui număr oarecare n indică numărul de permutări (numărul de

posibilități de rearanjare) ale unei mulțimi finite având n elemente.

3! de exemplu indica cate permutari (schimburi) se pot face intre elementele unei multimi cu 3 elemente
3!=1*2*3=6 :
1-2-3 2-3-1
1-3-2 3-1-2
2-1-3 3-2-1
Obs 1 Atentie la programele cu factorial! Factorialul creste foarte repede:
13! depaseste tipul int
21! depaseste tipul long long int
Obs2 5!=1*2*3*4*5 adica (2*5)*1*3*4 adica 10*1*3*4 =>la n>= 5 factorialul se va termina in 0

Să se scrie un program care citește numărul natural n și determină valoarea

lui n!=1*2*3*...*n.

În <climits> sunt definite limitele tipurilor de date...

//limitele int si long long
//calculul factorialului cout<<"dati n: " ;
//12! este val maxima pt int fact_de_n=1;
//20! este varianta mazima pt long long cin>>n;
#include <iostream> if(n==0)
#include <climits> fact_de_n=1;
using namespace std; else
for(int i=1;i<=n;i++)
int main() fact_de_n=fact_de_n*i;
{ if(n!=-1) cout<<n<<" factorial=
cout << "nr max pt int este: "<<INT_MAX << endl; "<<fact_de_n<<endl;
cout << "nr minim pt int este:" <<INT_MIN<<endl; }
cout << "nr max pt llong este: "<<LLONG_MAX <<endl; return 0;
cout << "nr minim pt llong este:"<<LLONG_MIN<<endl; }

// Sa se calculeze n! =1*2*...n
int n, fact_de_n;
n=1;
while (n!=-1) // cu -1 terminam programul
{
BUUUN
Am vazut (si in problema palindrom) ca sunt cerinte unde sunt depășite limitele tipurilor numerice cunoscute de
compilator. De asemenea aceasta depășire poate rezulta și din calcule, exemplu cel mai la indemană fiind cel cu
factorialul si mai putem adauga sume si produsede numere intregi care pot depăși limitele
 Una din variante pentru a evita aceasta este să se solicite răspunsul modulo. Ex: modulo 666013, sau modulo
1.000.000.007 etc

Un exemplu ca să ne lămurim (pbInfo):

Fie n m, două numere naturale, 1 ≤ n ≤ m ≤ 1000. Determinați restul împărțirii

lui m!-n! la 1009.

Vedem ca numerele m! și n! depășesc limitele și nu le putem calcula ca să facem scăderea și apoi împărțirea
cerută și atunci trebuie să le prelucrăm.
Aceasta se numește aritmetica modulară (de la operatorul modulo)

formulele sunt simple, ușor de aplicat:

adunare:
(a+b) % MOD=((a % MOD) + (b % MOD)) % MOD
inmultire:
(a*b) % MOD=((a % MOD)*(b % MOD)) % MOD
scadere:
X=(a-b) % MOD=((a % MOD)-(b % MOD)) % MOD
daca X <0
X=X+MOD
(împărțirea nu se cere acum în programă, trebuie să mai parcurgem ceva materie ca s-o abordăm )

1. 2.
//Sa se calculeze restul impartirii lui N! la MOD=1009 //Avand un sir de numere intregi in fisierul nr_mari.in
#include <iostream> //sa se determine restul impartirii sumei lor la 1009
#include <iostream>
using namespace std;
#include <fstream>
using namespace std;
int main()
{ int main()
int N, P; {
const int MOD = 1009; ifstream fin("nr_mari.in");
cout<<"dati N: "; int n , nr, A;
cin>>N; const int MOD = 1009;
P = 1; fin>>n;
for(int i = 1 ; i <=N ; i ++) A = 0;
for(int i = 0 ; i < n ; i ++)
{
{
P=(P*i)%MOD; fin>>nr;
} A = A+nr%MOD;
cout <<endl<< P; }
return 0; } A=A%MOD;
cout <<endl<< A;
fin.close();
return 0; }

revenind la exemplu:
Fie n m, două numere naturale, 1 ≤ n ≤ m ≤ 1000. Determinați restul împărțirii
lui m!-n! la 1009.
Rezolvare: Fie MOD = 1009. Deoarece numere sunt mari, nu putem calcula
factorialele.
Vom calcula A = m! % MOD,
B= n! % MOD,
apoi X = (A-B)%MOD.
Dacă X este negativ, vom aduna la X valoarea MOD, acesta fiind și rezultatul.

Adică aplicăm formula:

scadere:
X=(a-b) % MOD=((a % MOD)-(b % MOD)) % MOD
daca X <0
X=X+MOD
//Fie n m, două numere naturale, 1 ≤ n ≤ m ≤ 1000.
//Determinați restul împărțirii lui m!-n! la 1009.

#include <iostream>
using namespace std;
int main()
{
int n , m;
const int MOD = 1009;
cout<<"dati n,m (n mai mic decat m):";
cin >> n >> m; // n <= m
int A = 1, B = 1;
for(int i = 1 ; i <= m ; i ++)
A = (A * i) % MOD; //fiecare termen din m! se imparte la MOD si se retine restul
for(int i = 1 ; i <= n ; i ++)
B = (B * i) % MOD; //fiecare termen din n! se imparte la MOD si se retine restul
int X = A - B;
if(X < 0)
X =X+ MOD;
cout << X;
return 0;
}