afișezi partea întreagă a unui număr real Radicalul Unui numar Radicalul unui număr cu 2 zecimale fără

#include <iostream> rotunjire

#include <iostream> #include <cmath> //Includem #include <iostream>
biblioteca ce conține funcția sqrt() #include <cmath> //Includem biblioteca ce
//Nu avem nevoie de vreo altă bibliotecă conține funcția sqrt()
pentru a folosi funcția int(). using namespace std; #include <iomanip> //Includem biblioteca ce ne
ajută să manipulăm datele afișate
using namespace std; int main() using namespace std;
{ int main()
int main() int n; {
{ cin >> n; int n;
//Declarare și citire cout << sqrt(n); //Afișăm radicalul cin >> n;
double n; lui n. Dacă n nu este pătrat perfect, se double radical = sqrt(n); //Salvăm radicalul
cin >> n; afișează un număr cu zecimale radical = (int)(radical * 100); //Păstrăm doar
return 0; zecimile și sutimile, ștergând tot ce e după
//Partea întreagă a lui n } radical = (double)radical / 100; //Mutăm la
cout << int(n); loc zecimalele rămase (2 zecimale)
return 0; cout << fixed << setprecision(2) << radical;
} //Afișăm cu exact 2 zecimale
return 0;
}

Interschimbarea a două variabile Aria circumferentei Numere reale naturale dintrun intreval
#include <iostream> #include <iostream> #include <iostream>
using namespace std; #include <cmath> //Bibliotecă ce conține using namespace std;
int main() constanta matematică π în M_PI int main()
{ using namespace std; {
//Declarăm și citim cele două numere int main() //Declarăm și citim capetele intervalului
int a, b; { int x, y;
cin >> a >> b; //Declarăm și citim r, raza cercului cin >> x >> y;
//Interschimbăm valorile celor două variabile (număr real)
int aux = a; double r; //Calculăm și afișăm numărul de numere
a = b; cin >> r; naturale din intervalul dat
b = aux; //Dacă am fi scris b = a, b ar fi luat double arie = M_PI * r * r; int nrInterv = y - x + 1;
noua valoare a lui a (nu cea inițială), care este double circumferinta = 2 * M_PI * r; cout << "Intervalul [" << x << "; " << y << "] are "
însuși b. << nrInterv << " termeni";
cout << arie << " " << circumferinta; return 0;
//Afișăm variabilele după interschimbare return 0; }
cout << a << " " << b; }
return 0;
}

Distanta dintre 2 puncte; Aria unui triunghi folosind coordonatele acestora

#include <iostream>

#include <iostream> cin >> x3 >> y3;

#include <cmath> //Ne trebuie biblioteca cmath

#include <cmath> //Pentru funcția sqrt //Declarăm și calculăm laturile

pentru a avea acces la funcția de radical (sqrt)
using namespace std; triunghiului, precum și perimetrul
using namespace std;
double dist(int x1, int y1, int x2, int y2) { //Funcție acestuia
int main()
ajutătoare pentru a calcula distanța dintre două double a, b, c, p; //Folosim double,
{
puncte deoarece distanțele nu sunt neapărat
//Declarăm și citim coordonatele punctelor
int deltaX = x1 - x2; numere întregi
int x1, y1, x2, y2;
int deltaY = y1 - y2; a = dist(x1, y1, x2, y2);
cout << "Primul punct: ";
return sqrt(deltaX * deltaX + deltaY * deltaY); b = dist(x1, y1, x3, y3);
cin >> x1 >> y1;
} c = dist(x2, y2, x3, y3);
cout << "Al doilea punct: ";
int main() p = (a + b + c) / 2;
cin >> x2 >> y2;
{ //Calculăm și afișăm aria, folosind
//Diferența de x și y din formula de mai devreme
//Declarăm și citim coordonatele celor trei formula lui Heron
//Pentru că ridicăm aceste numere la pătrat, nu
puncte double arie = sqrt(p * (p - a) * (p - b) *
contează semnul lor
int x1, y1, x2, y2, x3, y3; (p - c));
int deltaX = (x2 - x1);
cout << "Primul punct: "; cout << "Aria triunghiului este " <<
int deltaY = (y2 - y1);
cin >> x1 >> y1; arie;
//Calculul și afișarea distanței
cout << "Al doilea punct: "; return 0;
double distanta = sqrt(deltaX * deltaX + deltaY *
cin >> x2 >> y2; }
deltaY);
cout << "Al treilea punct: ";
cout << "Distanta este " << distanta;
return 0;
}
Citire fisier INVERASREA TABLOULUI UNIDIMENSIONAL calculăm factorialul unui număr
#include <iostream> #include <iostream> #include <iostream>
//Avem nevoie de biblioteca <fstream> pentru using namespace std;
fluxurile de citire/afișare din fișiere using namespace std; int factorial(int n) {
#include <fstream> if(n < 0) { //Caz particular
using namespace std; int main() return 1;
int main() { } else { //Formula generală
{ int a[101], n; return n * factorial(n - 1);
//Declararea fluxurilor; se recomandă declararea cin >> n; }
lor la început for(int i = 1; i <= n; i++) { //i = 1, 2, 3, …, }
ifstream filein("fisiere.in"); n - 1, n int main()
ofstream fileout("fisiere.out"); cin >> a[i]; {
//Declararea variabilei n } int n;
int n; for(int i = n; i >= 1; i--) { //i = n, n - 1, n - cin >> n;
//Citire și afișare cu fluxurile create, în loc de cin 2, …, 2, 1 cout << factorial(n);
și cout cout << a[i] << " "; return 0;
filein >> n; } }
fileout << n; return 0;
return 0; }
}
MINIM SI MAXIM citește un număr natural și care calculează Să se determine recursiv al n-lea
#include <iostream> numărul de divizori al oglinditului său termen tribonacci (elementul
using namespace std; #include <iostream> curent este egal cu suma
int n, a[101]; //Vectorul nostru (a) și lungimea sa (n) using namespace std; ultimelor trei):
int minim = 2000000000, maxim = 0; int ogl(int n) {
int main() int rasp = 0; int tribo(int x) {
{ while(n != 0) { if(x <= 3) {
//Citim n și vectorul de lungime n int cif = n % 10; return 1;
cin >> n; rasp = rasp * 10; rasp += cif; }
for(int i = 1; i <= n; i++) n /= 10;
cin >> a[i]; } return
//Calculăm maximul return rasp; tribo(x - 1) + tribo(x -
for(int i = 1; i <= n; i++) { } 2
if(a[i] > maxim) { int nrdiv(int n) { ) + tribo(x - 3);
maxim = a[i]; int nr = 0; }
} for(int i = 1; i * i <= n; i++) {
} if(n % i == 0) {
Să se afișeze crescător primele n
//Calculăm minimul nr++;
numere naturale:
for(int i = 1; i <= n; i++) { if(i != n / i) {
if(a[i] < minim) { nr++;
void f(int n) {
minim = a[i]; }
if(n > 1) {
} }
} }
f
//Afișăm cele două rezultate return nr;
(n - 1);
cout << maxim << " " << minim; }
}
return 0; int main()
cout <<
} {
n
int n;
<< " ";
cin >> n;
Definiția recursivității }
Recursivitatea este proprietatea unui element de a se int oglindit = ogl(n);
defini prin el însuși. cout << nrdiv(oglindit);
return 0;
Exemple }
Noțiunea de recursivitate poate părea destul de dificil de
înțeles, așadar să considerăm câteva exemple.

Exemple în matematică
Factorialul unui număr n, n!, este egal cu produsul 1 × 2 ×
3 × … × (n - 1) × n. Putem să rescriem factorialul astfel: n!
= (n - 1)! × n. Astfel, am definit factorialul lui n pe baza
factorialului lui n - 1.

Șirul Fibonacci este un șir cunoscut în matematică, cu

primii doi termeni 1 și 1, iar termenul F(n) = F(n - 1) + F(n -
2).

Progresiile aritmetice și geometrice se pot scrie recursiv:

a(n) = a(n - 1) + r, sau g(n) = g(n - 1) * r.