Sistemul cartezian

De ce contează?

Gândește-te la o tablă de șah. Ca să spui unui prieten exact pe ce căsuță e o piesă, nu zici „undeva în mijloc” — zici coloana și rândul, de exemplu „c4”. Două numere, o singură căsuță, fără confuzie. Sistemul cartezian face același lucru pentru întregul plan: oricărui punct îi dă o adresă unică din două numere.

Sistemul de coordonate cartezian este modul în care transformăm geometria în numere. Avem două axe perpendiculare:

axa Ox (orizontală), pe care citim coordonata x;
axa Oy (verticală), pe care citim coordonata y.

Punctul în care se intersectează axele se numește origine și are coordonatele O(0, 0). Orice punct din plan e descris de o pereche ordonată (x, y): mergi x unități pe orizontală, apoi y unități pe verticală.

Atenție la cuvântul ordonată: (3, 5) și (5, 3) sunt puncte diferite. Primul număr e mereu x, al doilea e mereu y.

Cele două axe împart planul în patru cadrane, numerotate în sens trigonometric (invers acelor de ceas), pornind din dreapta-sus:

Cadran	Semnul lui `x`	Semnul lui `y`	Poziție
I	`+`	`+`	dreapta-sus
II	`-`	`+`	stânga-sus
III	`-`	`-`	stânga-jos
IV	`+`	`-`	dreapta-jos

Punctul în cod

În programare, un punct este pur și simplu o pereche de două coordonate. Cel mai clar mod de a-l reprezenta este un struct cu două câmpuri întregi:

struct Punct {
    int x, y;
};

Folosim întregi pentru că, în acest capitol, lucrăm cu puncte pe o grilă: coordonatele sunt numere întregi, iar calculele rămân exacte. Dacă produsele pot deveni mari, înlocuim int cu long long. Evităm double cât putem — el aduce mici erori de rotunjire care strică comparațiile.

Acum noțiunea-cheie a întregului capitol: vectorul. Un vector descrie o deplasare de la un punct la altul — „cât și încotro” mergi de la A la B. Îl obținem scăzând coordonatele:

AB = B - A = (xB - xA, yB - yA)

Cu alte cuvinte, un vector nu e un punct fix, ci diferența dintre două puncte. Coada vectorului AB este A, vârful este B, iar componentele lui spun cu cât crește x și cu cât crește y când mergi de la A la B.

Exemplu pas cu pas

Fie A(1, 2) și B(4, 6). Vrem vectorul AB.

componenta pe x: xB - xA = 4 - 1 = 3
componenta pe y: yB - yA = 6 - 2 = 4
deci AB = (3, 4)

Interpretare: pornind din A, ca să ajungi în B mergi 3 la dreapta și 4 în sus. Dacă am calcula invers, BA = A - B = (-3, -4) — același segment, dar parcurs în sens opus. Ordinea contează: AB și BA sunt vectori opuși.

Observă și că ambele puncte din exemplu au x > 0 și y > 0, deci se află în cadranul I.

Implementare C++

#include <iostream>
using namespace std;

struct Punct {
    int x, y;
};

int main() {
    Punct A, B;

    // citim cele doua puncte: x y pentru fiecare
    cin >> A.x >> A.y;          // ex: 1 2
    cin >> B.x >> B.y;          // ex: 4 6

    // vectorul AB = B - A
    int dx = B.x - A.x;         // 4 - 1 = 3
    int dy = B.y - A.y;         // 6 - 2 = 4

    cout << "AB = (" << dx << ", " << dy << ")\n";  // AB = (3, 4)

    // vectorul opus BA = A - B
    int bx = A.x - B.x;         // 1 - 4 = -3
    int by = A.y - B.y;         // 2 - 6 = -4

    cout << "BA = (" << bx << ", " << by << ")\n";  // BA = (-3, -4)

    return 0;
}

Observația-cheie

Reține o singură idee din toată lecția: un vector este diferența a două puncte, AB = B - A. Pe această formulă se sprijină tot capitolul — distanțe, pante, arii, intersecții. Dacă o ții corect (vârf minus coadă), restul vine natural.

Greșeli frecvente

Confunzi (x, y) cu (linie, coloană): pe o matrice indexezi [linie][coloană], dar în plan x e orizontala și y verticala. Sunt inversate — nu le amesteca.
Greșești semnul în cadranele II–IV: în cadranul III ambele coordonate sunt negative, în II doar x, în IV doar y. Verifică semnele, nu doar valorile.
Folosești double unde întregii ajung: pe coordonate întregi, double introduce erori de rotunjire la comparații. Rămâi pe int / long long.
Inversezi ordinea la vector: AB = B - A, nu A - B. Scrii coada minus vârf și obții vectorul opus, cu toate semnele schimbate.

P	(1	2)	(4	6)	(-3	5)	(0	0)
	A	B	C	O

Patru puncte ca perechi (x, y): A și B în cadranul I, C în cadranul II, O este originea.

Vizualizare

Indiciu

Vezi distanța și aria calculate pe plan; folosește ← / → pentru a avansa pas cu pas.

Recapitulare

Un punct e o pereche ordonată (x, y); în cod îl ținem ca struct Punct { int x, y; }.
Cele patru cadrane se deosebesc prin semnele lui x și y; originea e (0, 0).
Vectorul AB = B - A = (xB - xA, yB - yA) — diferența de puncte, baza întregului capitol.