Date structurate (struct) în C++ la atestatul de informatică — fracții, numere complexe, puncte, timp

Motivul pentru care enunțurile cer struct se vede la sortare. Cu numele într-un vector și mediile în altul, la fiecare interschimbare trebuie mutați amândoi, sincronizat — o singură scăpare și elevii ajung cu mediile altora. Cu struct, elevul e un singur element, care se mută întreg:

for (int i = 0; i < n - 1; i++)
    for (int j = i + 1; j < n; j++)
        if (e[j].media > e[i].media) {     // > descrescator, < crescator
            Elev aux = e[i];               // se muta structura intreaga
            e[i] = e[j];
            e[j] = aux;
        }

Comparația se face pe un câmp, interschimbarea pe toată structura. Algoritmul de sortare e explicat pe larg la algoritmii de sortare.

Fracțiile nu se pot sorta după numărător sau după numitor: 7/(-2) și 9/(-3) au numărători apropiați, dar valori foarte diferite. Se sortează după valoarea lor — care se calculează o dată, la citire, și se păstrează într-un câmp în plus:

struct Fractie {
    int a, b;            // datele originale
    double valoare;      // calculata la citire, folosita la sortare
};

fr[i].valoare = (double)fr[i].a / fr[i].b;   // fara (double): 1/4 = 0

Același tipar la numerele complexe sortate după modul (modul = sqrt(a*a + b*b)). Câmpul calculat e redundant ca informație, dar scutește recalcularea la fiecare comparație și ține rezultatul lângă datele din care a ieșit.

Subprogramele cerute la a) primesc adesea structuri: distanta(punct A, punct B), timp(clipa c). Structura se transmite ca orice variabilă — o singură valoare, cu toate câmpurile în ea:

struct punct { float x, y; };

float distanta(punct A, punct B) {
    float dx = A.x - B.x, dy = A.y - B.y;
    return sqrt(dx * dx + dy * dy);          // #include <cmath>
}

Formulele de geometrie care apar:

O altă cerință care se rezolvă prin transformarea structurii într-un singur număr: momentul cel mai târziu dintr-o listă hh:mm:ss. Comparând câmp cu câmp, ușor se greșește ordinea; transformat în secunde de la miezul nopții (ora * 3600 + mi * 60 + sec), devine o simplă căutare de maxim.

Suma a două fracții e tot o fracție; suma a două numere complexe e tot un număr complex. Funcția întoarce o structură, construită câmp cu câmp:

fractie suma(fractie f, fractie g) {
    fractie r;
    r.x = f.x * g.y + g.x * f.y;      // a/b + c/d = (ad + cb) / bd
    r.y = f.y * g.y;
    long long d = cmmdc(r.x, r.y);
    r.x /= d;                         // suma adusa la forma ireductibila
    r.y /= d;
    return r;
}

Suma mai multor valori se acumulează ca la numere, cu s = suma(s, t) — doar că elementul neutru e o structură: 0/1 la fracții, 0 + 0i la numerele complexe.

Trei detalii care decid rezultatul:

• Suma se reduce după fiecare adunare prin c.m.m.d.c.; altfel ieși cu 845/420 în loc de 169/84, iar numitorii cresc până depășesc tipul.
• long long pentru produse. Doi numitori de 9 cifre înmulțiți nu încap în int, iar depășirea nu dă nicio eroare — doar un rezultat greșit.
• La complexe, părțile se adună separat: reală cu reală, imaginară cu imaginară.