#071Programare

Să se ordoneze crescător fracţiile, afişând valorile zecimale ale lor

date structuratefisiere →sortare

Enunț

Fişierul fractii.in conţine pe prima linie numărul natural n (numărul de fracţii), iar pe fiecare din următoarele n linii două numere întregi reprezentând numărătorul şi numitorul unei fracţii. Să se ordoneze crescător fracţiile, afişând valorile zecimale ale lor.

Exemple

Date de intrare (`fractii.in`)	Date de ieșire	Explicații
`6` `1 4` `7 -2` `26 8` `-6 5` `12 5` `9 -3`	`-3.5 -3 -1.2 0.25 2.4 3.25`	−3.5 = 7/(−2), −3 = 9/(−3), −1.2 = −6/5, 0.25 = 1/4, 2.4 = 12/5, 3.25 = 26/8

Rezolvare

C++

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

struct Fractie {
    int a, b;                           // numarator, numitor
    double valoare;
};

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

    int n;
    f >> n;

    Fractie fr[100];
    for (int i = 0; i < n; i++) {
        f >> fr[i].a >> fr[i].b;
        fr[i].valoare = (double)fr[i].a / fr[i].b;   // conversie obligatorie
    }
    f.close();

    for (int i = 0; i < n - 1; i++)     // sortare crescatoare dupa valoare
        for (int j = i + 1; j < n; j++)
            if (fr[j].valoare < fr[i].valoare) {
                Fractie aux = fr[i];
                fr[i] = fr[j];
                fr[j] = aux;
            }

    for (int i = 0; i < n; i++) cout << fr[i].valoare << " ";
    return 0;
}

Cum funcționează

Problema pare să fie despre fracții, dar e de fapt despre sortarea după o valoare calculată.

Capcana: nu poți compara fracțiile după numărător sau după numitor. 7/(-2) și 9/(-3) au numărători apropiați, dar valori foarte diferite. Singura comparație corectă e între valorile zecimale, deci acestea se calculează o dată, la citire, și se rețin.

De aceea structura are trei câmpuri, nu două:

struct Fractie {
    int a, b;           // datele originale
    double valoare;     // rezultatul calculat, folosit la sortare
};

Câmpul valoare e redundant ca informație — s-ar putea recalcula oricând — dar îl calculezi o singură dată în loc de mii de ori în timpul sortării. Este un tipar util în general.

Conversia (double) e obligatorie. În C++, a / b între două int dă împărțire întreagă: 1 / 4 ar fi 0, nu 0.25. Scriind (double)fr[i].a / fr[i].b forțezi împărțirea reală. Fără ea, toate fracțiile subunitare devin 0 și sortarea iese complet greșită.

Sortarea e cea prin selecție directă, ca la ordonarea elevilor, cu < pentru crescător. Se interschimbă structura întreagă, deci numărătorul și numitorul rămân lipite de valoarea lor.

Observă că numitorii negativi funcționează natural: 7 / -2 dă -3.5, iar sortarea îl plasează primul. Nu e nevoie să „normalizezi" semnul.

La afișare, cout scrie numerele reale fără zecimale inutile: -3 în loc de -3.000000, exact ca în exemplu.

Greșeli frecvente

Împărțirea fără (double) — 1 / 4 devine 0. Cea mai frecventă și cea mai costisitoare greșeală aici.
Sortarea după numărător sau numitor — ordinea rezultată n-are legătură cu valoarea fracției.
Recalcularea valorii în condiția de sortare — funcționează, dar se repetă inutil.
Interschimbarea doar a câmpului valoare — datele originale rămân desperecheate. Cu struct se mută tot.
Uitarea că numitorul poate fi negativ — nu necesită tratare specială; împărțirea se descurcă.

Apariții

Dolj 2026 — problema 11 · sursa oficială