Funcția pătrat
Completați funcția patrat, care întoarce pătratul argumentului. main citește n și afișează patrat(n).
525Un program C/C++ este o colecție de module distincte numite funcții. Împărțirea codului în funcții mici, fiecare cu o responsabilitate clară, este principalul instrument de control al complexității: face codul reutilizabil, testabil și mult mai ușor de citit.
tip_rez nume_functie (lista_parametri)
{
<declaratii locale>
secventa de instructiuni
}
| Element | Rol | Observații |
|---|---|---|
tip_rez | tipul valorii returnate | implicit int; se scrie void dacă nu se returnează nimic |
nume_functie | identificator | respectă regulile identificatorilor |
lista_parametri | declarații de forma tip nume | se separă prin virgulă; void sau gol dacă nu există |
// PROTOTIP (declaratie) - spune compilatorului ce sa astepte
double aria(double raza); // se pune inainte de main, in zona globala
int main(void) {
printf("%.2f\n", aria(2.5)); // apelul este acum valid
return 0;
}
// DEFINITIE - corpul propriu-zis, poate fi si in alt fisier
double aria(double raza) {
return 3.14159 * raza * raza;
}
| Mod | Ce primește funcția | Modifică originalul? | Cost |
|---|---|---|---|
| Prin valoare | o copie a valorii | nu | copierea datelor |
| Prin pointer | adresa variabilei | da | doar o adresă |
| Prin referință (C++) | un alias al variabilei | da | doar o adresă |
| Tablou | întotdeauna adresa primului element | da | doar o adresă |
int v[], funcția primește un pointer, deci modificările
se reflectă în tabloul original. Din același motiv, sizeof aplicat parametrului dă
dimensiunea unui pointer, nu a tabloului - dimensiunea trebuie transmisă separat.Urmăriți ce se întâmplă cu variabilele când se apelează o funcție: se creează copii pe stivă, iar la revenire acestea dispar. Observați de ce prima variantă nu modifică nimic.
| Tip de variabilă | Vizibilă în | Trăiește |
|---|---|---|
| Locală (automată) | blocul în care e declarată | până la ieșirea din bloc |
| Parametru formal | corpul funcției | pe durata apelului |
Locală static | blocul în care e declarată | tot programul |
| Globală | tot fișierul, după declarație | tot programul |
::nume.O funcție recursivă se apelează pe ea însăși. Orice funcție recursivă trebuie să aibă:
| Problemă | Recursiv | Iterativ |
|---|---|---|
| Factorial | elegant, dar consumă stivă | mai eficient |
| Fibonacci naiv | foarte lent - O(2ⁿ), recalculează aceleași valori | O(n) |
| Parcurgerea arborilor | natural și clar | necesită stivă explicită |
| Turnurile din Hanoi | soluția evidentă | complicat |
| Facilitate | Descriere | Exemplu |
|---|---|---|
| Supraîncărcare | mai multe funcții cu același nume, dar parametri diferiți | int max(int,int) și double max(double,double) |
| Parametri impliciți | valori folosite dacă argumentul lipsește la apel | void f(int a, int b = 10) |
Funcții inline | codul se inserează la locul apelului | inline int patrat(int x) |
| Referințe | transmitere fără copiere, cu sintaxă simplă | void f(int &x) |
#include <stdio.h>
// prototipuri
double aria(double raza);
int maxim(int a, int b);
void afiseazaLinie(char c, int n);
void minMax(int v[], int n, int *min, int *max);
int main(void)
{
afiseazaLinie('=', 40);
printf("Aria pentru r=2.5: %.4f\n", aria(2.5));
printf("Maximul dintre 17 si 42: %d\n", maxim(17, 42));
int v[] = {29, 10, 14, 37, 5};
int mn, mx;
minMax(v, 5, &mn, &mx); // doua rezultate prin pointeri
printf("Minim=%d Maxim=%d\n", mn, mx);
afiseazaLinie('=', 40);
return 0;
}
double aria(double raza) { return 3.14159265 * raza * raza; }
int maxim(int a, int b) { return (a > b) ? a : b; }
void afiseazaLinie(char c, int n)
{
for (int i = 0; i < n; i++) putchar(c);
putchar('\n');
}
void minMax(int v[], int n, int *min, int *max)
{
*min = *max = v[0];
for (int i = 1; i < n; i++) {
if (v[i] < *min) *min = v[i];
if (v[i] > *max) *max = v[i];
}
}
#include <stdio.h>
long factorialRec(int n)
{
if (n <= 1) return 1; // CAZ DE BAZA - obligatoriu
return n * factorialRec(n - 1); // pas recursiv
}
long factorialIter(int n)
{
long r = 1;
for (int i = 2; i <= n; i++) r *= i;
return r;
}
long fibonacciRec(int n) // ATENTIE: exponential de lent
{
if (n <= 1) return n;
return fibonacciRec(n - 1) + fibonacciRec(n - 2);
}
long fibonacciIter(int n) // liniar, mult mai rapid
{
long a = 0, b = 1, t;
for (int i = 0; i < n; i++) { t = a + b; a = b; b = t; }
return a;
}
int cmmdc(int a, int b) // algoritmul lui Euclid
{
if (b == 0) return a;
return cmmdc(b, a % b);
}
int main(void)
{
printf("10! recursiv = %ld\n", factorialRec(10));
printf("10! iterativ = %ld\n", factorialIter(10));
printf("Fibonacci(20) = %ld\n", fibonacciIter(20));
printf("cmmdc(48, 18) = %d\n", cmmdc(48, 18));
return 0;
}
#include <iostream>
using namespace std;
// aceeasi denumire, parametri diferiti
int maxim(int a, int b) { return (a > b) ? a : b; }
double maxim(double a, double b) { return (a > b) ? a : b; }
int maxim(int a, int b, int c) { return maxim(maxim(a, b), c); }
// parametri impliciti - doar la sfarsitul listei
void afiseaza(const char *text, int repetari = 1, char separator = '\n')
{
for (int i = 0; i < repetari; i++)
cout << text << separator;
}
// transmitere prin referinta
void dubleaza(int &x) { x *= 2; }
int main()
{
cout << maxim(3, 7) << endl; // varianta int
cout << maxim(3.5, 7.1) << endl; // varianta double
cout << maxim(3, 7, 5) << endl; // varianta cu trei parametri
afiseaza("Salut"); // foloseste valorile implicite
afiseaza("Test", 3); // repeta de 3 ori
afiseaza("A", 4, ' '); // separator personalizat
cout << endl;
int n = 21;
dubleaza(n);
cout << "n = " << n << endl; // 42
return 0;
}
La funcții, panoul din dreapta arată stiva de apeluri: fiecare apel își are propriul set de variabile. La recursivitate se vede cum se adună cadrele unul peste altul.
factorial() unul sub altul: fiecare are propriul n. Ștergeți condiția de oprire și veți vedea eroarea de stivă plină.Aici scrieți voi codul. Butonul ✓ Verifică rulează programul pe mai multe seturi de date și vă arată imediat unde diferă rezultatul. La final trimiteți traseul ales, iar profesorul îl notează automat.
Fiecare exercițiu are programul deja început, iar comentariile vă spun ce mai trebuie adăugat. Scrieți codul, apăsați ✓ Verifică și citiți ce spune fiecare test picat. Dacă v-ați blocat, deschideți câte un indiciu. Puteți afișa și mesaje pentru utilizator (de tipul Introduceti n:), testul se uită la ce afișați la final.
Completați funcția patrat, care întoarce pătratul argumentului. main citește n și afișează patrat(n).
525Completați funcția fact, care calculează n! (0 ≤ n ≤ 20) iterativ, într-un long long.
5120Completați funcția prim, care întoarce 1 dacă n este prim și 0 altfel. main afișează prim sau neprim.
7primCompletați funcția recursivă suma_cifre, fără bucle: suma cifrelor lui n este ultima cifră plus suma cifrelor lui n / 10.
123410Completați funcția recursivă cmmdc după algoritmul lui Euclid: cmmdc(a, 0) = a și cmmdc(a, b) = cmmdc(b, a % b).
48 186Problemele pornesc de la un main gol. Formatul ieșirii trebuie respectat exact (spațiile și rândurile noi nu contează, dacă enunțul nu spune altfel), deci nu afișați mesaje pentru utilizator. Testele vizibile acoperă doar cazurile simple; la notare se rulează și teste ascunse, alese să prindă cazurile limită.
Citiți n (0 ≤ n ≤ 90) și afișați F(n), unde F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2). Testele au și valori mari ale lui n, deci varianta recursivă directă nu se termină la timp.
1055Citiți a b m (0 ≤ a ≤ 109, 0 ≤ b ≤ 1015, 1 ≤ m ≤ 9·107). Afișați ab mod m. Pentru b atât de mare aveți nevoie de un algoritm logaritmic.
2 10 100024Citiți n (1 ≤ n ≤ 10). Afișați mutările care duc n discuri de pe tija 1 pe tija 3, câte una pe rând, în forma 1 -> 3, apoi numărul total de mutări.
21 -> 2
1 -> 3
2 -> 3
3Citiți n (1 ≤ n ≤ 6) și afișați toate permutările mulțimii {1, …, n}, în ordine lexicografică, câte una pe rând (numerele despărțite prin spațiu).
31 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1sizeof în interiorul ei - explicați rezultatul.