TEORIE - 45 minute
Ce vei învăța astăzi?
După această lecție, vei putea scrie un program care rezolvă o ecuație de gradul II, tratând toate cazurile posibile (rădăcini reale distincte, rădăcină dublă, rădăcini complexe, cazul a=0 care revine la ecuația de gradul I).
Forma generală: ax + bx + c = 0
Calculul discriminantului Δ = b - 4ac
Clasificarea soluțiilor după Δ
Formulele rădăcinilor
Tratarea cazului a = 0 (gradul I)
Implementarea în C++ cu if/else
Rădăcini complexe și afișarea lor
Dicționar: Ecuația de gradul II ↔ C++
Simboluri matematice pe care le folosim în această lecție:
| Simbol matematic | Ce înseamnă | În C++ |
|---|---|---|
| ax + bx + c = 0 | „ecuație de gradul II" | Se rezolvă cu if/else |
| Δ = b − 4ac | „discriminantul" | delta = b*b - 4*a*c; |
| √Δ | „radical din delta" | sqrt(delta) |
| x₁,₂ = (−b ± √Δ) / 2a | „formulele rădăcinilor" | (-b + sqrt(delta)) / (2*a) |
| Δ > 0 | „două rădăcini reale" | if (delta > 0) |
| Δ = 0 | „rădăcină dublă" | else if (delta == 0) |
| Δ < 0 | „nu există rădăcini reale" | else { /* imposibil */ } |
| #include <cmath> | „biblioteca matematică" | Necesară pentru sqrt() |
Ce este o ecuație de gradul II?
Forma generală: ax + bx + c = 0, unde a, b, c sunt numere reale, a ≠ 0 (pentru a fi de gradul II).
Discriminantul: Δ = b - 4ac determină natura rădăcinilor.
Discriminantul: Δ = b − 4ac
C++: float delta = b*b - 4*a*c;
„delta egal b ori b minus 4 ori a ori c"
- Dacă
Δ > 0: două rădăcini reale distincte. - Dacă
Δ = 0: o rădăcină dublă (reală). - Dacă
Δ < 0: două rădăcini complexe conjugate.
Formulele rădăcinilor:
x₁,₂ = (-b ± √Δ) / (2a)
Rădăcini reale: x₁,₂ = (−b ± √Δ) / (2a)
C++: x1 = (-b + sqrt(delta)) / (2*a);
„x1 egal minus b plus radical din delta, totul împărțit la 2 ori a"
Rădăcina dublă (Δ = 0): x = −b / (2a)
C++: x1 = -b / (2*a);
„x egal minus b împărțit la 2 ori a"
Exemple detaliate:
| Ecuația | a,b,c | Δ | Soluții | Explicație |
|---|---|---|---|---|
x - 5x + 6 = 0 |
1, -5, 6 | 25 - 24 = 1 | x₁=2, x₂=3 | Δ>0, două rădăcini reale |
x - 4x + 4 = 0 |
1, -4, 4 | 16 - 16 = 0 | x = 2 (dublă) | Δ=0, rădăcină dublă |
x + x + 1 = 0 |
1, 1, 1 | 1 - 4 = -3 | complexe: -0.5 ± i·√3/2 | Δ<0, rădăcini complexe |
2x + 3x - 5 = 0 |
2, 3, -5 | 9 + 40 = 49 | x₁=1, x₂=-2.5 | Δ>0, rădăcini reale |
0·x + 2x + 3 = 0 |
0, 2, 3 | - | x = -1.5 | a=0, ecuație de gradul I |
Interpretare geometrică:
Ecuația ax + bx + c = 0 reprezintă intersecția parabolei y = ax + bx + c cu axa Ox.
- Δ > 0 → parabola taie axa în două puncte.
- Δ = 0 → parabola este tangentă axei (un singur punct).
- Δ < 0 → parabola nu atinge axa Ox (rădăcini complexe).
- a = 0 → parabola degenerată într-o dreaptă.
Algoritmul de rezolvare (pseudocod)
// Pseudocod: Ecuația de gradul II
CITEȘTE a, b, c
DACĂ a = 0 ATUNCI
// tratează ecuația de gradul I
ALTFEL
delta ← b*b - 4*a*c
DACĂ delta > 0 ATUNCI
x1 ← (-b + sqrt(delta)) / (2*a)
x2 ← (-b - sqrt(delta)) / (2*a)
SCRIE x1, x2
DACĂ delta = 0 ATUNCI
x ← -b / (2*a)
SCRIE x // rădăcină dublă
DACĂ delta < 0 ATUNCI
SCRIE "Nu există soluții reale"
Pașii algoritmului:
- Citește coeficienții a, b, c.
- Dacă a = 0 atunci
- Rezolvă ecuația de gradul I: bx + c = 0 (tratează cazurile speciale).
- Altfel (a ≠ 0)
- Calculează Δ = b - 4ac.
- Dacă Δ > 0 atunci
- x₁ = (-b + √Δ) / (2a)
- x₂ = (-b - √Δ) / (2a)
- Afișează două rădăcini reale.
- Dacă Δ = 0 atunci
- x = -b / (2a)
- Afișează rădăcina dublă.
- Dacă Δ < 0 atunci
- parteReală = -b / (2a)
- parteImaginară = √(-Δ) / (2a)
- Afișează rădăcinile complexe conjugate.
Implementare în C++ (cu comentarii)
#include <iostream>
#include <cmath> // pentru sqrt
using namespace std;
int main() {
float a, b, c, delta, x1, x2, real, imag;
cout << "Introdu coeficientii a, b, c: ";
cin >> a >> b >> c;
if (a == 0) {
// Ecuație de gradul I
if (b != 0) {
x1 = -c / b;
cout << "Solutie unica: x = " << x1;
} else {
if (c == 0)
cout << "Infinitate de solutii";
else
cout << "Nu exista solutie";
}
} else {
// Ecuație de gradul II
delta = b*b - 4*a*c;
if (delta > 0) {
x1 = (-b + sqrt(delta)) / (2*a);
x2 = (-b - sqrt(delta)) / (2*a);
cout << "x1 = " << x1 << ", x2 = " << x2;
}
else if (delta == 0) {
x1 = -b / (2*a);
cout << "Radacina dubla: x = " << x1;
}
else {
real = -b / (2*a);
imag = sqrt(-delta) / (2*a);
cout << "x1 = " << real << " + " << imag << "i\n";
cout << "x2 = " << real << " - " << imag << "i";
}
}
return 0;
}
Atenție: Pentru Δ < 0, nu putem calcula sqrt(delta) direct (ar da eroare). Folosim sqrt(-delta) pentru partea imaginară.
Programul complet: Ecuația de gradul II
Traseu de execuție: x − 5x + 6 = 0 (a=1, b=−5, c=6)
| Pas | Instrucțiune | a | b | c | delta | x1 | x2 |
|---|---|---|---|---|---|---|---|
| 1 | cin >> a >> b >> c | 1 | -5 | 6 | — | — | — |
| 2 | if (a==0) → NU | 1 | -5 | 6 | — | — | — |
| 3 | delta = (-5)-4·1·6 = 25-24 | 1 | -5 | 6 | 1 | — | — |
| 4 | if (delta>0) → DA | 1 | -5 | 6 | 1 | — | — |
| 5 | x1 = (5+1)/2 | 1 | -5 | 6 | 1 | 3 | — |
| 6 | x2 = (5-1)/2 | 1 | -5 | 6 | 1 | 3 | 2 |
Rezolvarea ecuației ax + bx + c = 0 cu toate cazurile
#include <iostream>
#include <cmath> // pentru sqrt
using namespace std;
int main() {
float a, b, c, delta, x1, x2, real, imag;
cin >> a >> b >> c;
if (a == 0) {
// grad I
if (b != 0) cout << -c/b;
else if (c == 0) cout << "infinit";
else cout << "imposibil";
} else {
delta = b*b - 4*a*c;
if (delta > 0) {
x1 = (-b + sqrt(delta)) / (2*a);
x2 = (-b - sqrt(delta)) / (2*a);
cout << x1 << " " << x2;
} else if (delta == 0) {
x1 = -b/(2*a);
cout << "x = " << x1;
} else {
real = -b/(2*a);
imag = sqrt(-delta)/(2*a);
cout << real << " + " << imag << "i";
}
}
return 0;
}
Date de test: x-5x+6=0 (a=1,b=-5,c=6) → x=2 și x=3; x-2x+1=0 → x=1 (dublă); x+x+1=0 → rădăcini complexe -0.5±0.866i; 2x+3=0 → x=-1.5 (grad I).
Greșeli frecvente și cum să le eviți
| Greșeală | Exemplu greșit | Corect | Explicație |
|---|---|---|---|
| Nu tratăm cazul a = 0 | Presupunem mereu a ≠ 0 | Verificăm if(a==0) și tratăm gradul I | Dacă a=0, formula rădăcinilor nu se aplică. |
| Calcul greșit al discriminantului | delta = b - 4ac scris ca b*b - 4ac (corect), dar uităm parantezele la împărțire | (-b ± sqrt(delta)) / (2*a) | În C++, / și * au aceeași prioritate, dar e bine să folosim paranteze pentru claritate. |
| Folosim sqrt(delta) pentru delta negativ | sqrt(delta) când delta<0 → eroare | Folosim sqrt(-delta) pentru partea imaginară | Funcția sqrt din cmath acceptă doar argumente nenegative. |
| Afișare fără formatare | cout << x1; (poate afișa 2e+000) | cout << fixed << setprecision(2) << x1; | Pentru o afișare curată, controlează formatul. |
Sfaturi de depanare:
- Rulează programul cu ecuații simple: x - 5x + 6 = 0 (a=1,b=-5,c=6) ar trebui să dea 2 și 3.
- Testează cazul a=0: 2x+3=0 → -1.5.
- Testează cazul Δ=0: x - 2x + 1 = 0 → x=1.
- Testează cazul Δ<0: x + x + 1 = 0 → parte reală -0.5, imaginar ±0.866.
- Verifică dacă ai inclus
#include <cmath>.
Verificare cunoștințe (cu feedback detaliat)
1. Pentru ecuația x - 3x + 2 = 0, care este discriminantul?
2. Câte rădăcini reale are ecuația x + 2x + 5 = 0?
3. Ce se întâmplă dacă a = 0, b = 0, c = 5?
4. Ce valoare are √(-9) în matematică? (partea imaginară)
Întrebări frecvente (FAQ) extins
Ce fac dacă delta este negativ?
În multe probleme de informatică se cere doar să afișăm că nu există soluții reale. Uneori se cere și afișarea rădăcinilor complexe. În acest caz, calculezi partea reală = -b/(2a) și partea imaginară = √(-Δ)/(2a) și le afișezi ca numere complexe.
De ce folosim
float și nu double?
Ambele sunt acceptabile.
float este mai eficient în memorie, iar double oferă mai multă precizie. Pentru majoritatea problemelor, float este suficient. Dacă ai nevoie de mai multă precizie (de exemplu, calcule științifice), folosește double.
Cum pot afișa frumos rădăcinile complexe?
De exemplu:
cout << real << showpos << imag << "i"; pentru a afișa semnul explicit. A doua rădăcină va fi real << showpos << -imag << "i";. Sau poți folosi condiții pentru a afișa „+”. Nu uita să resetezi noshowpos după.
Ce se întâmplă dacă a și b sunt foarte mari?
Calculele în virgulă mobilă pot duce la pierderi de precizie. În cazuri extreme, poți folosi
double sau chiar long double. De asemenea, poți rescrie formulele pentru a evita operații cu numere foarte mari (de exemplu, împărțirea înainte de înmulțire).
Cum testez programul pentru toate cazurile?
Pregătește un set de teste:
- a ≠ 0, Δ > 0: de ex. (1, -3, 2) → 2, 1
- a ≠ 0, Δ = 0: (1, -2, 1) → 1
- a ≠ 0, Δ < 0: (1, 1, 1) → complexe
- a = 0, b ≠ 0: (0, 2, -4) → 2
- a = 0, b = 0, c = 0: infinit
- a = 0, b = 0, c ≠ 0: imposibil
Exercițiu: Alege tipul soluției
Pentru fiecare ecuație, alege tipul soluțiilor:
x - 5x + 6 = 0
x - 2x + 1 = 0
x + x + 1 = 0
0·x + 2x - 4 = 0
Aplicații practice ale ecuației de gradul II
- Mișcarea parabolică: Ecuația traiectoriei unui proiectil este de gradul II. Determinarea punctului de impact revine la rezolvarea unei ecuații de gradul II.
- Electrotehnică: Circuite RLC au ecuații diferențiale care, în regim staționar, duc la ecuații de gradul II pentru frecvențe.
- Optimizare: Punctul de minim/maxim al unei funcții de gradul II se găsește anulând derivata (ecuație de gradul I), dar valoarea optimă se obține din ecuația de gradul II.
- Geometrie: Intersecția unei drepte cu o parabolă sau cerc conduce la ecuații de gradul II.
Întrebări de examen: Ce se întâmplă cu rădăcinile dacă a este foarte mic? De ce Δ=0 se numește rădăcină dublă? Cum ai afișa rădăcinile sub formă fracționară? De ce tratăm separat cazul a=0?
PROBLEME PBINFO - 15 minute
PbInfo - Discriminantul
Delta pentru gradul II
Enunț:
Cerință: Se citesc a, b, c. Calculeaza discriminantul delta=b*b-4*a*c.
Date de intrare:
Coeficientii a, b, c.
Date de ieșire:
Valoarea lui delta.
Exemplu:
Intrare:
1 -3 2
Ieșire:
1
Explicație: delta = 9 - 8 = 1.
Cum gândim soluția:
- Citim coeficientii.
- Aplicam formula delta=b*b-4*a*c.
- Afisam delta.
Tip: Nu ai nevoie de sqrt pentru aceasta cerinta.
Scrie soluția în C++:
Soluție corectă:
#include <iostream>
using namespace std;
int main() {
double a, b, c;
cin >> a >> b >> c;
double delta = b * b - 4 * a * c;
cout << delta;
return 0;
}
PbInfo - Numar de radacini reale
Decizie dupa delta
Enunț:
Cerință: Se citesc a, b, c, cu a nenul. Afiseaza cate radacini reale are ecuatia.
Date de intrare:
Coeficientii a, b, c.
Date de ieșire:
0, 1 sau 2.
Exemplu:
Intrare:
1 -3 2
Ieșire:
2
Explicație: Delta este pozitiv.
Cum gândim soluția:
- Calculam delta.
- Daca delta > 0, sunt doua radacini.
- Daca delta == 0, este o radacina dubla.
- Altfel nu sunt radacini reale.
Tip: Este o aplicatie directa de if / else if / else.
Scrie soluția în C++:
Soluție corectă:
#include <iostream>
using namespace std;
int main() {
double a, b, c;
cin >> a >> b >> c;
double d = b * b - 4 * a * c;
if (d > 0) cout << 2;
else if (d == 0) cout << 1;
else cout << 0;
return 0;
}
PbInfo - Radacinile reale
Formula completa
Enunț:
Cerință: Se citesc a, b, c. Afiseaza radacinile reale daca exista, altfel mesajul Nu exista.
Date de intrare:
Coeficientii a, b, c.
Date de ieșire:
Radacinile reale sau mesajul Nu exista.
Exemplu:
Intrare:
1 -5 6
Ieșire:
2 3
Explicație: Radacinile ecuatiei sunt 2 si 3.
Cum gândim soluția:
- Verificam cazul a==0.
- Calculam delta.
- Daca delta < 0, nu calculam radical.
- Altfel aplicam formula radacinilor.
Tip: Include cmath pentru sqrt.
Scrie soluția în C++:
Soluție corectă:
#include <iostream>
#include <cmath>
using namespace std;
int main() {
double a, b, c;
cin >> a >> b >> c;
if (a == 0) {
cout << "Nu este gradul II";
return 0;
}
double d = b * b - 4 * a * c;
if (d < 0) cout << "Nu exista";
else if (d == 0) cout << - b / (2 * a);
else {
cout << (- b - sqrt(d)) / (2 * a) << " ";
cout << (- b + sqrt(d)) / (2 * a);
}
return 0;
}
Strategie de testare (verifică toate cazurile!):
- Δ > 0: testează cu x−5x+6=0 → x₁=2, x₂=3
- Δ = 0: testează cu x−2x+1=0 → x=1 (dublă)
- Δ < 0: testează cu x+x+1=0 → fără soluții reale
- a = 0: testează cu 2x−4=0 → x=2 (grad I)
EXERCIȚII PRACTICE - 2 sarcini / 20 minute
Exercițiul Practic: Ecuația de gradul II
Exersează calculul discriminantului, tratarea cazurilor și implementarea algoritmului pentru mai multe ecuații.
Sarcina 1: Analiză cod
Următorul cod conține mai multe greșeli. Găsește-le și corectează-le.
#include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int delta = b*b - 4*a*c;
if (delta >= 0) {
int x1 = (-b + sqrt(delta)) / (2*a);
int x2 = (-b - sqrt(delta)) / (2*a);
cout << x1 << " " << x2;
} else cout << "nu exista";
return 0;
}
Greșeli frecvente: tipuri int → pierd zecimale; lipsă cmath → sqrt() nu funcționează
C++:
float în loc de int; #include <cmath> pentru sqrt()„Dacă variabilele sunt int, rădăcinile se trunchiază — pierzi zecimalele!"
// Pseudocod: Verificare corectitudine cod
// 1. Verifică include-urile: lipsește cmath?
// 2. Verifică tipurile: int pierde zecimale → float
// 3. Verifică cazurile tratate:
// - a=0? (ecuație grad I)
// - Δ=0? (rădăcină dublă, tratată separat)
// 4. Verifică afișarea: setprecision(2)?
De ce funcționează? Codul original avea 5 greșeli: 1) lipsă cmath (sqrt nu merge), 2) int pierde zecimale, 3) delta≥0 nu separă cazul dublu, 4) a=0 netretat, 5) lipsă setprecision. Corectat:
#include <iostream> // cin, cout
#include <cmath> // sqrt() – LIPSEA în original!
#include <iomanip> // setprecision – LIPSEA în original!
using namespace std;
int main() {
float a, b, c, delta, x1, x2; // float, nu int!
cin >> a >> b >> c;
cout << fixed << setprecision(2); // afișare cu 2 zecimale
if (a == 0) {
// tratare grad I – NETRETAT în original!
} else {
delta = b*b - 4*a*c; // calculăm Δ
if (delta > 0) { // Δ>0: două rădăcini
x1 = (-b + sqrt(delta)) / (2*a);
x2 = (-b - sqrt(delta)) / (2*a);
cout << x1 << " " << x2;
} else if (delta == 0) { // Δ=0: rădăcină dublă – NESEPARAT în original!
x1 = -b / (2*a);
cout << x1;
} else { // Δ<0: imposibil
cout << "imposibil";
}
}
return 0;
}
Sarcina 2: Implementare pentru 5 ecuații
Scrie un program care citește 5 seturi de coeficienți (a,b,c) și afișează pentru fiecare soluția (sau mesajul corespunzător), fiecare pe o linie nouă.
Ideea: repetăm algoritmul de 5 ori → buclă
for(i=1;i<=5;i++)C++: for(int i=1; i<=5; i++) { cin>>a>>b>>c; /* rezolvă */ }
„pentru fiecare din cele 5 ecuații: citim coeficienții, rezolvăm, afișăm"
// Pseudocod: 5 ecuații de gradul II
PENTRU i ← 1 LA 5 EXECUTĂ
CITEȘTE a, b, c
DACĂ a = 0 ATUNCI
// rezolvă ca grad I
ALTFEL
delta ← b·b - 4·a·c
// tratează Δ>0, Δ=0, Δ<0
SCRIE rezultatul
SFÂRȘIT PENTRU
De ce funcționează? Bucla for repetă de 5 ori algoritmul complet de rezolvare. Fiecare iterație citește un set nou de coeficienți (a,b,c) și aplică aceeași logică cu discriminantul.
#include <iostream> // cin, cout
#include <cmath> // sqrt()
#include <iomanip> // setprecision
using namespace std;
int main() {
float a, b, c, delta, x1, x2;
cout << fixed << setprecision(2); // 2 zecimale global
for(int i = 1; i <= 5; i++) { // repetăm de 5 ori
cin >> a >> b >> c; // citim coeficienții
if(a == 0) { // grad I
if(b != 0) cout << -c/b << endl;
else if(c == 0) cout << "infinit" << endl;
else cout << "imposibil" << endl;
} else {
delta = b*b - 4*a*c; // Δ = b-4ac
if(delta > 0) { // două rădăcini
x1 = (-b - sqrt(delta)) / (2*a);
x2 = (-b + sqrt(delta)) / (2*a);
if(x1 > x2) swap(x1, x2); // ordine crescătoare
cout << x1 << " " << x2 << endl;
} else if(delta == 0) { // rădăcină dublă
x1 = -b / (2*a);
cout << x1 << endl;
} else { // imposibil
cout << "imposibil" << endl;
}
}
}
return 0;
}