#061Programare

Modulele numerelor complexe dintr-un fișier, afișate în ordine descrescătoare

date structuratefisiere →sortare

Enunț

Fişierul complexe.in conţine pe prima linie numărul natural n (numărul de valori complexe), iar pe fiecare din următoarele n linii două numere întregi reprezentând partea reală şi partea imaginară a unui număr complex. Să se afişeze, în ordine descrescătoare, modulele numerelor complexe, cu precizie de două zecimale.

Modulul numărului complex este |a + bi| = √(a² + b²).

Exemple

Date de intrare (`complexe.in`)	Date de ieșire	Explicații
`6` `3 4` `1 2` `-2 3` `0 4` `-5 -2` `1 -3`	`5.39 5.00 4.00 3.61 3.16 2.24`	5.39 = \|−5−2i\|, 5 = \|3+4i\|, 4 = \|4i\|, 3.61 = \|−2+3i\|, 3.16 = \|1−3i\|, 2.24 = \|1+2i\|

⚠️ Enunțul oficial are o mică inconsecvență. Cere „precizie de două zecimale", dar în exemplul din subiect valorile întregi apar ca 5 și 4, nu ca 5.00 și 4.00. Rezolvarea de mai jos respectă cerinţa scrisă (două zecimale întotdeauna). Dacă vrei exact forma din exemplu, vezi nota de la finalul explicaţiei — ambele se punctează.

Rezolvare

C++

#include <iostream>
#include <iomanip>
#include <fstream>
#include <cmath>
using namespace std;

struct Complex {
    int a, b;                           // parte reala, parte imaginara
    double modul;
};

int main() {
    ifstream f("complexe.in");

    int n;
    f >> n;

    Complex z[100];
    for (int i = 0; i < n; i++) {
        f >> z[i].a >> z[i].b;
        z[i].modul = sqrt((double)z[i].a * z[i].a + (double)z[i].b * z[i].b);
    }
    f.close();

    for (int i = 0; i < n - 1; i++)     // sortare DESCRESCATOARE dupa modul
        for (int j = i + 1; j < n; j++)
            if (z[j].modul > z[i].modul) {
                Complex aux = z[i];
                z[i] = z[j];
                z[j] = aux;
            }

    cout << fixed << setprecision(2);
    for (int i = 0; i < n; i++) cout << z[i].modul << " ";

    return 0;
}

Cum funcționează

Structural, problema e geamăna ordonării fracțiilor: citești perechi de numere din fişier, calculezi o valoare pentru fiecare, sortezi după ea. Diferă doar formula și sensul sortării.

Din nou structura are trei câmpuri — datele originale plus valoarea calculată, ca să n-o recalculezi la fiecare comparație:

struct Complex {
    int a, b;
    double modul;
};

Modulul e distanța de la origine până la punctul (a, b) în plan — adică exact teorema lui Pitagora: √(a² + b²). De aceea semnele nu contează: |-5 - 2i| și |5 + 2i| au același modul. Pentru (-5, -2): √(25 + 4) = √29 ≈ 5.39.

sqrt necesită #include <cmath>.

Conversia (double) la înmulțire e o măsură de siguranță: pentru valori mari, a * a între doi int poate depăși limita tipului înainte ca sqrt să apuce să lucreze cu el.

Sortarea e descrescătoare, deci > în condiție — spre deosebire de fracții, unde era <. Acesta e singurul caracter care decide sensul; verifică-l de două ori.

fixed << setprecision(2) se scrie o singură dată, înainte de buclă — setarea rămâne activă pentru toate afișările ulterioare. Necesită #include <iomanip>.

Despre inconsecvenţa din enunţ. fixed << setprecision(2) produce 5.39 5.00 4.00 ..., adică exact „două zecimale". Exemplul oficial arată însă 5.39 5 4 .... Pentru acea formă se scoate fixed şi se foloseşte setprecision(3), care păstrează 3 cifre semnificative şi elimină zecimalele nule. Cerinţa scrisă din enunţ e respectată de prima variantă, deci pe ea o folosim.

Greșeli frecvente

Uitarea lui sqrt — se afișează a² + b² în loc de modul.
a + b în loc de √(a² + b²) — pentru (-5, -2) ar da -7, un rezultat fără sens ca modul.
Sortare crescătoare — enunțul cere descrescător, deci >.
setprecision fără fixed — se numără cifre semnificative, nu zecimale.
setprecision scris în interiorul buclei — funcționează, dar e redundant.
Interschimbarea doar a modulului — datele originale se desperechează; cu struct se mută tot.

Apariții

Dolj 2026 — problema 12 · sursa oficială