Ce vei învăța astăzi?
Fizica întâlnește informatica! Vom traduce ecuațiile mișcării rectilinii uniforme în cod C++ și vom afla când și unde se întâlnesc două mobile.
Dicționar: Matematică ↔ C++ (MRU)
| Concept matematic | Cum se citește | În C++ | Observație |
|---|---|---|---|
| x₀ (poziția inițială) | „x zero" | double x0; | sufixul 0 = valoare la t=0 |
| v (viteza) | „v" (constantă) | double v; | unitate: m/s sau km/h |
| t (timpul) | „t secunde" | double t; | rezultat zecimal → double! |
| x(t) = x₀ + v·t | „x de t egal x zero plus v ori t" | x = x0 + v * t; | ecuația mișcării MRU |
| v₁ ≠ v₂ | „v1 diferit de v2" | v1 != v2 | verificăm ÎNAINTE de împărțire |
| t ≥ 0 | „t mai mare sau egal cu zero" | t >= 0 | t negativ = trecut |
| ÷ 3.6 | „împărțit la 3.6" | v / 3.6 | km/h → m/s |
| × 3.6 | „înmulțit cu 3.6" | v * 3.6 | m/s → km/h |
Analogie: Mașini pe autostradă
Imaginează-ți autostrada A1:
Mașina roșie pornește de la km 0 și merge cu 80 km/h. Mașina albastră pornește de la km 240 (mai în față) și merge cu 40 km/h. Roșia merge mai repede — la un moment dat o va ajunge pe albastră.
Întrebarea: După câte ore? La ce km?
Exact asta rezolvăm cu formula de întâlnire: t = (240 - 0) / (80 - 40) = 6 ore, la km 80 × 6 = 480 km.
Ecuația mișcării rectilinii uniforme
Mișcare rectilinie uniformă (MRU) = un obiect se deplasează în linie dreaptă cu viteză constantă.
double x = x0 + v * t;| Simbol | Semnificație | Unitate |
|---|---|---|
| x(t) | Poziția la momentul t | metri (m) |
| x₀ | Poziția inițială | metri (m) |
| v | Viteza | m/s |
| t | Timpul scurs | secunde (s) |
Exemplu rapid: Ești pe o autostradă la km 50, mergi cu 100 km/h. Unde ești după 2 ore? x = 50 + 100 · 2 = 250 km. Aceeași formulă o folosim și în programele noastre.
Punctul de întâlnire
Două mobile se întâlnesc când pozițiile lor sunt egale: x₁(t) = x₂(t)
Deducerea formulei
Mobilul 1: x₁ = x₁₀ + v₁·t
Mobilul 2: x₂ = x₂₀ + v₂·t
Egalăm: x₁₀ + v₁·t = x₂₀ + v₂·t
v₁·t - v₂·t = x₂₀ - x₁₀
t·(v₁ - v₂) = x₂₀ - x₁₀
double t = (x20 - x10) / (v1 - v2);Tabel pas cu pas: Mașina roșie (R) vs albastră (A)
R: x₁₀=0 km, v₁=80 km/h | A: x₂₀=240 km, v₂=40 km/h
| t (ore) | Pos. R = 0+80·t | Pos. A = 240+40·t | Distanța R-A | C++: abs(posR-posA) |
|---|---|---|---|---|
| 0 | 0 | 240 | 240 km | abs(0-240)=240 |
| 1 | 80 | 280 | 200 km | abs(80-280)=200 |
| 2 | 160 | 320 | 160 km | abs(160-320)=160 |
| 3 | 240 | 360 | 120 km | abs(240-360)=120 |
| 4 | 320 | 400 | 80 km | abs(320-400)=80 |
| 5 | 400 | 440 | 40 km | abs(400-440)=40 |
| 6 | 480 | 480 | 0 km ✓ | 0 ✓ |
Formula: t = (240-0)/(80-40) = 240/40 = 6 ore. Se confirmă!
Cazuri speciale:
- v₁ = v₂: Viteze egale → nu se întâlnesc niciodată (dacă x₁₀ ≠ x₂₀) sau merg mereu împreună
- t < 0: Întâlnirea ar fi fost în trecut → nu se întâlnesc
Conversie unități: km/h ↔ m/s
În fizică se lucrează cu m/s, dar în viața reală folosim km/h. Conversia:
double vMs = vKmH / 3.6; | double vKmH = vMs * 3.6;| km/h | ÷ 3.6 | m/s | Context |
|---|---|---|---|
| 36 | ÷ 3.6 | 10 | Bicicletă |
| 72 | ÷ 3.6 | 20 | Oraș |
| 108 | ÷ 3.6 | 30 | Drum județean |
| 130 | ÷ 3.6 | ≈ 36.1 | Autostradă |
double vKmH, vMs; cout << "Viteza (km/h): "; cin >> vKmH; vMs = vKmH / 3.6; cout << vKmH << " km/h = " << vMs << " m/s" << endl;
Implementarea în C++
#include <iostream>
using namespace std;
int main() {
double x10, v1, x20, v2;
cout << "Mobilul 1 - pozitie initiala: ";
cin >> x10;
cout << "Mobilul 1 - viteza: ";
cin >> v1;
cout << "Mobilul 2 - pozitie initiala: ";
cin >> x20;
cout << "Mobilul 2 - viteza: ";
cin >> v2;
if (v1 == v2) {
if (x10 == x20)
cout << "Mobilele merg mereu impreuna!" << endl;
else
cout << "Mobilele nu se intalnesc niciodata "
<< "(viteze egale, pozitii diferite)." << endl;
} else {
double t = (x20 - x10) / (v1 - v2);
if (t < 0) {
cout << "Mobilele nu se intalnesc (t = "
<< t << " < 0)." << endl;
} else {
double x = x10 + v1 * t;
cout << "Se intalnesc dupa " << t << " secunde" << endl;
cout << "la pozitia " << x << " metri." << endl;
}
}
return 0;
}
De ce double? Timpul și pozițiile pot fi numere zecimale. Folosim double pentru precizie.
Trace: x10=0, v1=10, x20=100, v2=5
| t | x1 = 0+10·t | x2 = 100+5·t | |x1-x2| | C++: abs(pos1-pos2) |
|---|---|---|---|---|
| 0 | 0 | 100 | 100 | abs(0-100)=100 |
| 5 | 50 | 125 | 75 | abs(50-125)=75 |
| 10 | 100 | 150 | 50 | abs(100-150)=50 |
| 15 | 150 | 175 | 25 | abs(150-175)=25 |
| 20 | 200 | 200 | 0 ✓ | abs(200-200)=0 |
t = (x20-x10)/(v1-v2); x = x10 + v1*t;Greșeli frecvente
Eroare #1: Împărțire la zero
Dacă v₁ == v₂, formula t = (x₂₀-x₁₀)/(v₁-v₂) împarte la 0! Trebuie întotdeauna verificat mai întâi dacă v₁ ≠ v₂.
Eroare #2: Unități diferite
Dacă un mobil are viteza în km/h și altul în m/s, rezultatul e greșit! Convertește toate valorile în aceleași unități înainte de calcul.
Eroare #3: Folosirea int în loc de double
int t = 100 / 3; dă t=33, nu 33.33! Folosește double pentru toate variabilele de mișcare.
Verificare cunoștințe
1. Mobilul 1: x₀=0, v=10. Mobilul 2: x₀=100, v=5. Când se întâlnesc?
2. Mobilul 1: x₀=0, v=5. Mobilul 2: x₀=100, v=5. Ce se întâmplă?
3. Dacă t obținut este negativ, ce înseamnă?
4. Ce rezultat dă formula x(t) = x₀ + v·t dacă x₀=50, v=-10, t=3?
5. 72 km/h convertit în m/s este:
Întrebări frecvente (FAQ)
Vitezele reale sunt adesea numere zecimale (ex: 33.33 m/s). Chiar și formula de întâlnire poate da un timp zecimal (ex: t=6.5 secunde). Cu int, partea zecimală se pierde, iar rezultatul devine incorect.
Da! O viteză negativă înseamnă că mobilul se deplasează în sens opus axei alese. De exemplu, dacă axa este spre dreapta, v=-5 înseamnă că mobilul merge spre stânga.
Dacă x₁₀ = x₂₀ și v₁ ≠ v₂, formula dă t = 0. Aceasta înseamnă că sunt deja împreună la t=0, dar se despart imediat. Dacă și vitezele sunt egale, merg mereu împreună.
MRU se aplică ori de câte ori viteza e constantă: mașini pe autostradă (cruise control), trenuri, avioane la altitudine de croazieră. GPS-ul calculează ETA (timp estimat) exact cu formula t = distanță / viteză.
PbInfo - Pozitia dupa timp
x=x0+v*t
Enunț:
Cerință: Se citesc x0, v si t. Afiseaza pozitia mobilului.
Date de intrare:
x0 v t.
Date de ieșire:
Pozitia x.
Exemplu:
Intrare:
10 3 4
Ieșire:
22
Explicație: 10+3*4=22.
Cum gândim soluția:
- Citim datele.
- Aplicam x=x0+v*t.
- Afisam x.
Tip: Formula este directa, fara bucla.
Scrie soluția în C++:
Soluție corectă:
#include <iostream>
using namespace std;
int main() {
double x0, v, t;
cin >> x0 >> v >> t;
cout << x0 + v * t;
}
PbInfo - Punctul de intalnire
Doua mobile
Enunț:
Cerință: Se citesc x1, v1, x2, v2. Afiseaza timpul intalnirii daca este pozitiv.
Date de intrare:
x1 v1 x2 v2.
Date de ieșire:
Timpul intalnirii sau mesaj.
Exemplu:
Intrare:
0 5 20 1
Ieșire:
5
Explicație: Cele doua mobile se intalnesc dupa 5 secunde.
Cum gândim soluția:
- Daca vitezele sunt egale, tratam separat.
- Calculam t=(x2-x1)/(v1-v2).
- Verificam t>=0.
Tip: Daca t este negativ, intalnirea a fost in trecut.
Scrie soluția în C++:
Soluție corectă:
#include <iostream>
using namespace std;
int main() {
double x1, v1, x2, v2;
cin >> x1 >> v1 >> x2 >> v2;
if (v1 == v2)
cout << "Nu se intalnesc";
else {
double t = (x2 - x1) / (v1 - v2);
if (t >= 0)
cout << t;
else cout << "Timp negativ";
}
}
PbInfo - Pozitia la intalnire
Timp si spatiu
Enunț:
Cerință: Se citesc doua miscari. Afiseaza timpul si pozitia intalnirii.
Date de intrare:
x1 v1 x2 v2.
Date de ieșire:
t si pozitia.
Exemplu:
Intrare:
0 5 20 1
Ieșire:
5 25
Explicație: La t=5, pozitia este 25.
Cum gândim soluția:
- Calculam t.
- Daca t>=0, calculam x=x1+v1*t.
- Afisam t si x.
Tip: Pozitia poate fi calculata cu oricare dintre cele doua mobile.
Scrie soluția în C++:
Soluție corectă:
#include <iostream>
using namespace std;
int main() {
double x1, v1, x2, v2;
cin >> x1 >> v1 >> x2 >> v2;
if (v1 == v2) {
cout << "Nu";
return 0;
}
double t = (x2 - x1) / (v1 - v2);
if (t < 0)
cout << "Nu";
else cout << t << " " << x1 + v1 * t;
}
Exercițiul Practic: Mișcare rectilinie uniformă
Aplică formula MRU pentru poziții în timp, întâlniri și simulări cu mai multe mobile. Poți rezolva întâi cu formule directe, apoi poți adăuga bucle sau vectori.
Pe scurt: formula de bază este mereu x = x0 + v * t. Bucla for nu schimbă formula; doar o repetă pentru mai multe momente de timp.
Sarcina 1: Poziția după t secunde
Citește x₀, v și t. Afișează poziția mobilului la fiecare secundă de la 0 la t.
Pași de rezolvare
- Citește
x0,vșit(int, pentru secunde) - FOR
ide la 0 lat: calculeazăx = x0 + v * i - La fiecare pas, afișează
t=i : x=valoare
x = x0 + v * i;De ce funcționează? Formula MRU x(t) = x₀ + v·t calculează poziția mobilului la orice moment. Bucla FOR parcurge fiecare secundă, afișând traseul complet al mișcării.
#include <iostream>
using namespace std;
int main(){
double x0, v; // pozitia initiala si viteza
int t; // numarul de secunde
cin >> x0 >> v >> t; // citim datele de la tastatura
for(int i=0; i<=t; i++){
// formula MRU: x(t) = x0 + v * t
cout << "t=" << i << " : x=" << x0+v*i << endl;
}
return 0;
}
Sarcina 2: Trei mobile
Citește datele pentru 3 mobile. Verifică fiecare pereche (1-2, 1-3, 2-3) și afișează prima întâlnire (timpul minim pozitiv).
Pași de rezolvare
- Citește
x[3]șiv[3](vectori: trei poziții și trei viteze) - Pentru fiecare pereche (0-1), (0-2), (1-2): verifică
v[i] != v[j] - Calculează
t = (x[j]-x[i]) / (v[i]-v[j]) - Dacă
t ≥ 0și mai mic decât minimul curent → salvează - Afișează perechea cu timpul minim pozitiv
t = (x[j]-x[i]) / (v[i]-v[j]);De ce funcționează? Comparăm toate perechile de mobile (combinări C(3,2)=3). Formula t = (x₂−x₁)/(v₁−v₂) dă momentul întâlnirii. Salvăm minimul pozitiv — aceasta e prima întâlnire.
#include <iostream>
using namespace std;
int main(){
double x[3], v[3]; // vectori: pozitii si viteze
for(int i=0;i<3;i++) cin >> x[i] >> v[i]; // citim 3 mobile
double tmin = -1; // -1 = inca nu am gasit intalnire
int m1=-1, m2=-1; // indicii perechii gasite
for(int i=0;i<3;i++)
for(int j=i+1;j<3;j++){ // fiecare pereche (i,j)
if(v[i]!=v[j]){ // viteze egale = paralele, skip
double t=(x[j]-x[i])/(v[i]-v[j]); // formula intalnire
if(t>=0 && (tmin<0 || t<tmin)){ // t pozitiv si minim
tmin=t; m1=i+1; m2=j+1; // salvam perechea
}
}
}
if(tmin<0) cout << "Nicio intalnire";
else cout << "Prima intalnire: mob " << m1
<< " si " << m2 << " la t=" << tmin;
return 0;
}