Tag: rezolvări

Rezolvarea subiectelor de informatică de la examenul de bacalaureat național, sesiunea iulie 2014 (2)

Filiera teoretică, profilul real, specializarea științe ale naturii

 

Enunțul subiectelor precum și baremul de corectare pot fi descărcate de pe site-ul Ministerului Educației Naționale.

Pe contul de GitHub poate fi consultat codul sursă corespunzător subiectelor care solicită elaborarea de programe C/C++.

SUBIECTUL I (30 de puncte)


Acest subiect este identic cu cel de la specializarea matematică-informatică.

 

SUBIECTUL II (30 de puncte)


1. Subiectul urmărește să verifice cunoașterea funcțiilor predefinite din limbajul C/C++ (abs) precum și abilități cu privire la rezolvarea unor probleme.

Pentru x ∈ [45, 55], valorile pe care le poate lua expresia x/10 sunt 4 (pentru x ∈ [45, 49]) sau 5 (pentru x ∈ [50, 55]) iar ale expresiei x%10 pot fi cuprinse între 0 (pentru x=50) și 9 (pentru x=49). Așadar, diferența maximă dintre cele două expresii (în modul) poate fi 5, aceasta obținându-se atât pentru x=49 (abs(4-9)=5) cât și pentru x=50(abs(5-0)=0).

Răspunsul corect este b.

 

2. Prin acest exercițiu se dorește să se verifice capacitatea de înțelegere a unui algoritm precum și posibilitatea de completare a acestuia.

În enunț se precizează faptul că m>n, cu alte cuvinte m-n>0. De asemenea, se observă că pe fiecare iterație a instrucțiunii repetitive cu test final x este incrementat cu 1, y este decrementat cu 1, astfel încât diferența x-y va fi incrementată cu 2. Pentru a se satisface condiția de terminare a ciclului repetitiv (x<y ⇔ x-y<0), trebuie să se realizeze un număr de iterații egal cu:

a) (m-n)/2, dacă n-m este par, astfel încât diferența inițială (negativă) n-m (valoarea lui x-y) să fie anulată (la sfârșitul ciclului repetitiv cu test final x=y)

În aceste condiții r=m-n (după înmulțirea cu 2) numai dacă r reflectă numărul de iterații ale ciclului repetitiv cu test final, adică r = r + 1

b) (m-n)/2 + 1, dacă n-m este impar, astfel încât diferența inițială (negativă) n-m (valoarea lui x-y) să fie devină pozitivă (la sfârșitul ciclului repetitiv cu test final x = y + 1)

În aceste condiții r=m-n(+1) (după înmulțirea cu 2 și decrementarea în urma testului de egalitate dintre x și y – din rezultat ar fi trebuit să se scadă 2 și nu 1) numai dacă r reflectă numărul de iterații ale ciclului repetitiv cu test final, adică r = r + 1

Răspunsul corect este c.

 

3. Acest subiect reprezintă o variantă a celui omolog de la specializarea matematică-informatică, propunându-și să verifice capacitatea unui elev de a elabora un algoritm relativ simplu. Nu este testată capacitatea elevului de a lucra cu structuri de date.

Și pentru această problemă trebuie tratate cele trei cazuri:

a) minutul de start este mai mic decât minutul de stop (momentul de start este anterior momentului de stop) ⇒ rezultat acceptat;

b) minutul de start este egal cu minutul de stop:

    1. secunda de start este mai mică decât secunda de stop (momentul de start este anterior momentului de stop) ⇒ rezultat acceptat;

    2. secunda de start este egală sau mai mare decât secunda de stop (momentul de start coincide cu momentul de stop sau este ulterior momentului de stop) ⇒ rezultat respins.

c) minutul de start este mai mare cu minutul de stop (momentul de start este ulterior momentului de stop) ⇒ rezultat respins.

using namespace std;

#include <iostream>

int main() {
    int minut_start, secunda_start, minut_stop, secunda_stop;
    cout<<“start”<<endl;
    cout<<“minut:”; cin>>minut_start;
    cout<<“secunda:”; cin>>secunda_start;
    cout<<“stop”<<endl;
    cout<<“minut:”; cin>>minut_stop;
    cout<<“secunda:”; cin>>secunda_stop;
    if (minut_start<minut_stop)
        cout<<“acceptat”<<endl;
    else if (minut_start==minut_stop) {
        if (secunda_start<secunda_stop)
            cout<<“acceptat”<<endl;
        else
            cout<<“respins”<<endl;
    } else if (minut_start>minut_stop)
        cout<<“respins”<<endl;
    return 0;
}

 

4. Acest subiect este identic cu cerința 3, subiectul III de la specializarea matematică-informatică, cu excepția faptului că nu se solicită scrierea programului C/C++ corespunzător ci descrierea algoritmului în pseudocod, fără utilizarea de subprograme.

a) Este evident că trebuie respectate simultan condițiile:

  • n! ∈ [a, b]
  • (n-1)! ∉ [a, b]
  • (n+1)! ∉ [a, b]
  • b-a maxim

de unde rezultă automat faptul că a = (n-1)! + 1 și b=(n+1)! – 1.

Algoritmul în pseudocod este următorul:

citește n

factorial ← 1

pentru contor = 2, n-1

    factorial ← factorial * contor

a ← factorial + 1

b ← factorial * n * (n + 1) – 1

afișează a, b

b) Datele de intrare sunt n, care trebuie să respecte condiția de a face parte din intervalul [2, 10].

Datele de ieșire sunt a și b, reprezentând limita inferioară, respectiv limita superioară a intervalului factorial.

A fost utilizată o variabilă contor, pentru a indica iterația curentă în ciclul repetitiv cu număr cunoscut de pași și variabila factorial, în care se calculează valoarea (n-1)!, utilizată ulterior pentru determinarea limitei inferioare, respectiv a limitei superioare a intervalului factorial.

Având formulele pentru limita inferioară, respectiv limita superioară determinate mai sus, algoritmul nu trebuie decât să calculeze (n-1)! (printr-un algoritm iterativ, folosind un ciclu repetitiv cu număr cunoscut de pași – factorial = 1 * 2 * … * (n-1)) și pe baza sa a (n+1)! care sunt ulterior incrementate, respectiv decrementate pentru a se obține valorile dorite.

 

SUBIECTUL III (30 de puncte)


1. Interclasarea a doi vectori presupune introducerea elementelor unui vector neordonat între elementele unui vector ordonat (de obicei crescător), astfel încât după această operație să se mențină proprietatea de ordine între elementele vectorului rezultat (xi < xj, ∀i<j).

În cazul de față se cunosc A = (4, 11, 14, 18, 21) și A ∪ B = (3, 4, 8, 11, 14, 14, 17, 18, 21, 46). Pentru determinarea vectorului B, trebuie realizată operația de diferență dintre A ∪ B și A.

Procedând astfel, se obține că B = (A ∪ B) \ A = (3, 4, 8, 11, 14, 14, 17, 18, 21, 46) \ (4, 11, 14, 18, 21) = (3, 8, 14, 17, 46). Acestea sunt valorile pe care vectorul B trebuie să le conțină, nu neapărat în această ordine, întrucât sortarea se realizează în cadrul operației de interclasare, fiecare element din B fiind plasat în A ∪ B pe poziția corespunzătoare, astfel încât să se mențină proprietatea de ordine.

Dintre toate variantele de răspuns, se observă că doar varianta b conține toate elementele vectorului B și numai pe cele aparținându-i acestuia.

 

2. Exercițiul reprezintă o problemă clasică de căutare a unei valori într-o mulțime neordonată.

În secvența dată se citesc 10 valori de la tastatură și se cere ca variabila ok să rețină rezultatul căutării (0 dacă valoarea nu face parte din mulțime, 1 dacă aceasta este identificată printre elementele mulțimii).

Prin urmare, valoarea ok va fi inițializată cu 0 (inițial, valoarea nu a fost găsită), urmând ca în ciclul repetitiv cu număr cunoscut de pași să se modifice valoarea acesteia (în 1) în condițiile în care, în urma unui instrucțiuni de tip decizional, elementul citit este identificat ca fiind cel căutat.

ok = 0; // elementul nu a fost gasit printre valorile citite

for(i = 1; i <= 10; i++) {

    cin>>x;

    if (x == 2014)

        ok = 1; // elementul a fost gasit printre valorile citite

}

 

3. Subiectul vizează verificarea modului de lucru cu tablouri (citire, scriere, indexare, modificare a valorilor conform unei condiții). De asemenea, deși baremul nu o precizează explicit, ar trebui urmărit modul de alocare / dealocare (dinamică) a memoriei pentru tablou, respectiv verificarea restricțiilor precizate în enunț pentru datele de intrare (n și x cuprinse între anumite valori, elementele vectorului de maxim 4 cifre, minim un element par în vector).

Prin urmare, algoritmul:

  • va citi variabila n, urmărind respectarea restricțiilor specificate în enunț;
  • va aloca tabloul dinamic (pentru fix atâtea elemente câte urmează să fie citite);
  • va citi fiecare element al tabloului, într-o secvență repetitivă cu număr cunoscut de pași, verificând, pentru fiecare în parte, dacă a fost respectat criteriul de validare
  1. pentru fiecare element al tabloului în parte, să aibă maxim 4 cifre (să fie mai mic decât 10000);
  2. doar la ultimul element, să fie existat anterior cel puțin un element par (restul împărțirii la 2 să fie 0) – întânirea unui astfel de element se face pentru fiecare element al tabloului care respectă criteriul de validare;
  • va citi variabila x, urmărind respectarea restricțiilor specificate în enunț;
  • va parcurge tabloul, scăzând valoarea x din elementul curent în cazul în care acesta este par;
  • va scrie fiecare element al tabloului, acesta fiind separat de celelalte printr-un spațiu;
  • va dealoca spațiul de memorie rezervat pentru tablou.

using namespace std;

#include <iostream>

int main() {
    int n, *vector, x, contor, par = 0;
    do {
        cout<<“n=”;
        cin>>n;
    } while (n <= 2 || n >= 50);
    vector = new int[n];
    for (contor=0; contor < n; contor++) {
        int conditie = 0;
        do {
            cout<<“vector[“<<(contor+1)<<“]=”;
            cin>>vector[contor];
            if (vector[contor] < 10000) {
                if (vector[contor] % 2 == 0)
                    par = 1;
                if (contor == (n – 1)) {
                    if (par)
                        conditie = 1;
                }
                else
                    conditie = 1;
            }
        } while (!conditie);
    }
    do {
        cout<<“x=”;
        cin>>x;
    } while (x <= 0 || x >= 10);
    for (contor = 0; contor < n; contor++)
        if (vector[contor] %2 == 0)
            vector[contor] -= x;
    for (contor = 0; contor < n; contor++)
        cout<<vector[contor]<<” “;
    cout<<endl;
    delete vector;
    return 0;
}

 

4. Acest subiect reprezintă o variantă simplificată a  celui omolog de la specializarea matematică-informatică, solicitându-se identificarea cifrelor cu apariție maximă, nu a subnumerelor (de 2 cifre).

a) Se determină toate cifrele unui număr (ca rest al împărțirii la 10 al acestuia), eliminându-se succesiv ultima cifră (prin împărțirea sa la 10) până când acesta devine nul (nu mai conține cifre). Valorile cifrelor și numărul de apariții al fiecărui subnumăr va fi contorizat în cadrul a doi vectori, unul care reține valorile (cifre), iar celălalt care stochează numărul de apariții (ocurente). De fiecare dată se verifică, prin căutare, dacă cifra respectivă există anterior. (S-ar fi putut inițializa un vector cu 10 elemente corespunzătoare fiecărei cifre de la 0 la 9, eliminându-se altfel vectorul care reține cifrele propriu-zise precum și căutarea care se realizează de fiecare dată pentru a se verifica dacă cifra respectivă există sau nu). Se determină maximul numărului de ocurențe și valoarea (valorile) corespunzătoare acestui maxim se afișează.

Complexitatea algoritmului propus este O(n) întrucât vectorul este parcurs de 2 ori, odată pentru determinarea cifrelor și odată pentru determinarea maximului numărului de ocurențe (stocarea valorilor cifrelor în vector presupune și ea o parcurgere pentru căutare, însă și aceasta se realizează tot în timp liniar și poate fi eliminată prin varianta amintită).

b)

Soluția 1:

using namespace std;

#include <iostream>
#include <fstream>

#define MAX 10 // pot fi maxim 10 cifre, insa nu este obligatoriu ca toate sa se regaseasca in fisier

int main() {
    long numar;
    // vectori ce contin
    // – valorile cifrelor aferente numerelor din fisier
    // – numarul de aparitii pentru fiecare cifra
    int *cifre, *ocurente, dimensiune = 0;
    // alocare memorie
    cifre = new int[MAX];
    ocurente = new int[MAX];
    // deschidere fisier
    ifstream fisier(“bac.txt”);
    if (fisier.is_open()) {
        // citire numar din fisier
        while (fisier>>numar) {
            while (numar != 0) {
                // determinare cifra
                int cifra = numar % 10, gasit = 0;
                // cautare cifra in vector
                for (int contor = 0; contor < dimensiune && !gasit; contor++)
                    // cifra a fost gasita in vector, se incrementeaza numarul de ocurente
                    if (cifre[contor] == cifra) {
                        ocurente[contor]++;
                        gasit = 1;
                    }
                // cifra nu a fost gasit in vector, se stocheaza (numarul de ocurente este 1)
                if (!gasit) {
                    cifre[dimensiune] = cifra;
                    ocurente[dimensiune] = 1;
                    dimensiune++;
                }
                numar /= 10;
            }
        }
        // inchidere fisier
        fisier.close();
    }
    // determinare numar maxim de ocurente
    int maxim = 1;
    for (int contor = 0; contor < dimensiune; contor++)
        if (ocurente[contor] >= maxim)
            maxim = ocurente[contor];
    // afisarea subnumerelor care apar de cele mai multe ori
    for (int contor = 0; contor < dimensiune; contor++)
        if (ocurente[contor] == maxim)
            cout<<cifre[contor]<<” “;
    cout<<endl;
    // dealocare memorie
    delete cifre;
    delete ocurente;
    cin>>maxim;
    return 0;
}

Soluția 2:

using namespace std;

#include <iostream>
#include <fstream>

#define MAX 10 // pot fi maxim 10 cifre, insa nu este obligatoriu ca toate sa se regaseasca in fisier

int main() {
    long numar;
    // vector ce contine numarul de aparitii pentru fiecare cifra
    // ocurente[i] – numarul de aparitii pentru cifra i, i=0..9
    int *ocurente, dimensiune = 0;
    // alocare memorie
    ocurente = new int[MAX];
    for (int contor = 0; contor < MAX; contor++)
        ocurente[contor] = 0;
    // deschidere fisier
    ifstream fisier(“bac.txt”);
    if (fisier.is_open()) {
        // citire numar din fisier
        while (fisier>>numar) {
            while (numar != 0) {
                // determinare cifra
                int cifra = numar % 10;
                // incrementarea numarului de ocurente pentru cifra curenta
                ocurente[cifra]++;
                numar /= 10;
            }
        }
        // inchidere fisier
        fisier.close();
    }
    // determinare numar maxim de ocurente
    int maxim = 1;
    for (int contor = 0; contor < MAX; contor++)
        if (ocurente[contor] >= maxim)
            maxim = ocurente[contor];
    // afisarea subnumerelor care apar de cele mai multe ori
    for (int contor = 0; contor < MAX; contor++)
        if (ocurente[contor] == maxim)
            cout<<contor<<” “;
    cout<<endl;
    // dealocare memorie
    delete ocurente;
    return 0;
}

Subiectele de matematică la examenul de bacalaureat național, sesiunea iulie 2014

Subiectele de la proba de matematică (E.c) de la examenul de bacalaureat național, sesiunea iulie 2014, au avut un grad de dificultate sub medie, fapt demonstrat și de numărul mare de medii de 10 (nu mai puțin de 108 la nivelul întregii țări!!!) înregistrate anul acesta. Nu mai puțin adevărat este faptul că există și un îngrijorător procent de candidați respinși (puțin peste 40%), care nu ar fi avut nici un motiv să nu obțină o notă de promovare în condițiile în care subiectele formulate nu ar fi trebuit să pună nici un fel de probleme. Este păcat că site-ul Ministerului Educației Naționale pe care sunt publicate rezultatele la examenul de bacalaureat nu oferă instrumente mai avansate pentru realizarea de statistici pentru fiecare disciplină în parte, spre exemplu.

Matematica este, de câțiva ani, disciplina obligatorie pentru elevii care au absolvit profilul real, corespondenta istoriei pentru elevii care au urmat cursurile aferente profilului uman. Ar merita menționat faptul că în timp ce la istorie, competențele specifice și conținuturile evaluate fac parte exclusiv din programa analitică a clasei a XII-a, la matematică sunt verificate cunoștințele din toți cei patru ani de liceu. În plus, matematica nu se poate deprinde doar pe parcursul unui an școlar (sau mai puțin), presupune acumulare continuă (datorită interdependenței dintre algebră, analiză matematică, geometrie și trigonometrie) și exercițiu susținut, pentru formarea experienței de lucru. Din acest punct de vedere, absolvenții profilului real sunt evident dezavantajați și nu înțeleg de ce Ministerul Educației Naționale perpetuează această stare de lucruri.

Revenind strict la subiectele propuse spre rezolvare în acest an, ele puteau fi rezolvate în mai puțin de o oră din cele 3 și pe cel mult patru pagini. Nu a existat nici măcar un subiect care să testeze ingeniozitatea elevului, care să îl forțeze să fie original, să propună o metodă de rezolvare inovativă. S-au preferat exerciții clasice, la care elevii erau solicitați să aplice o formulă sau cel mult o metodă de lucru cât se poate de convențională.

Nu cunosc conținutul celorlalte variante, însă este îngrijorător faptul că lipsesc din cunoștințele evaluate elementele de combinatorică, limitele de șiruri, reprezentarea grafică a unei funcții (prilej cu care se putea verifica abilitatea de a aplica teorema lui Lagrange, Rolle, Fermat), inelele și grupurile (subiect ce putea fi combinat lejer cu unul dintre exercițiile legate de polinoame / sisteme de ecuații), aplicațiile primitivelor pentru calculul de arii. Sigur că în formatul curent al probei de matematică nu pot fi propuse exerciții care să acopere întreaga programă analitică, însă cunoștințele esențiale trebuie incluse și, așa cum am arătat mai sus, anumite elemente pot fi combinate astfel încât un subiect să implice mai multe competențe specifice / conținuturi simultan.

rezolvari_bac2014

Foarte probabil, au existat numeroase motive care au concurat la elaborarea unor astfel de subiecte: faptul că ne aflăm într-un an electoral, iar absolvenții de liceu tocmai au împlinit vârsta necesară pentru a putea vota, numărul mare de locuri în învățământul universtar (de stat sau particular) la care accesul este condiționat de promovarea examenului de bacalaureat, acestea trebuind ocupate pentru a asigura locul de muncă al cadrelor didactice ce își desfășoară activitatea în respectivele instituții de învățământ (și de ce nu, prosperitatea facultății / universității respective), “spălarea” imaginii pe care învâțământul românesc îl are în fața opiniei publice prin niște rezultate care nu reflectă realitatea… O complicitate tacită din care singurii care au de pierdut sunt elevii, chiar dacă pe moment nu conștientizează acest lucru.

Una peste alta, este îngrijorător faptul că scăderea exigențelor la un examen care se dorește să fie al maturității nu este deloc proporțională cu creșterea promovabilității, care, de ceva vreme, se încăpățânează să stagneze uneva între 50-60%.

PS. Subiectele (și baremele aferente) pentru probele de matematică și de istorie de la sesiunea iulie 2014 a examenului de bacalaureat pot fi descărcate de pe site-ul Ministerului Educației Naționale dedicat subiectelor la examenele naționale.

Subiectele de algebră și elemente de analiză matematică de la examenul de admitere la facultate, Universitatea “Politehnica” București, sesiunea iulie 2014

Ca și în anii precedenți, subiectele propuse pentru proba de algebră și elemente de analiză matematică de la examenul de admitere într-una din cele șapte facultăți din cadrul Universității “Politehnica” București care organizează această formă de concurs (Energetică, Automatică și Calculatoare, Electronică, Telecomunicații și Tehnologia Informației, Transporturi, Inginerie Aerospațială, Inginerie în Limbi Străine și Științe Aplicate) au fost extrem de accesibile (mai ușoare chiar decât cele din anii precedenți), făcând imposibilă departajarea candidaților bine pregătiți sau lăsând această departajare pe seama examenului de bacalaureat.

Criteriul examenului de bacalaureat (a cărui pondere, ca și în anii precedenți, s-a menținut la 20%) nu este foarte relevant în cazul admiterii la o facultate cu profil tehnic, putând fi invocate în acest sens mai multe motive:

  • existența unei probe la limba și literatura română, al cărei aport la media finală este de o treime (25% pentru candidații care susțin și examen la limba și literatura maternă), urmărind competențe specifice a căror utilitate este destul de lipsită de importanță pentru un viitor inginer (nu mă refer la abilitatea de a scrie și de a te exprima corect sau la noțiunile de cultură generală cu privire la operele aparținând marilor scriitori, ci la stăpânirea unor concepte operaționale cu privire la curentele literare sau abilitatea de elaborare a unui text aparținând unui anumit registru)
  • structura examenului de bacalaureat poate include și alte probe lipsite de relevanță pentru un viitor inginer, care pot asigura o medie mai mare, inclusiv la examenul de admitere în facultate, în detrimentul unor candidați bine pregătiți strict pe domeniul pe care doresc să îl urmeze
  • carențele în organizare și desfășurare (suspiciunile care planează asupra corectitudinii examenului, în condițiile în care în fiecare an sunt expuse de mass-media cazuri de corupție până la nivel de inspectorat pentru favorizarea unor candidați, diferențe mari de punctaje între corectura inițială și nota de la contestație, modalitatea de alcătuire a subiectelor)

Un astfel de criteriu i-a încurajat pe unii candidați să se înscrie la facultățile la care admiterea se face pe baza mediei de la bacalaureat și – formal – al unui interviu (care cuprinde și un test grilă), susținut imediat ulterior înscrierii propriu-zise. Astfel, concurența la Facultatea de Inginerie Medicală a fost, anul acesta, de 6,51 candidați / loc iar la Facultatea de Antreprenoriat, Ingineria și Managementul Afacerilor de 4,60 candidați / loc. Nu știu câte cunoștințe din sfera medicală sau economică aveau elevii care și-au depus dosarele la aceste facultăți și nici apetența pentru aceste domenii, însă, în mod cert, aparenta facilitate de a accede la un loc în cadrul acestor instituții de învățământ superior, fără susținerea unor probe scrise, a reprezentat o atracție semnificativă.

De cealaltă parte, facultăți precum Automatică și Calculatoare sau Electronică, Telecomunicații și Tehnologia Informației au înregistrat concurențe de 2,20 candidați / loc, respectiv 1,70 candidați / loc pentru locurile finanțate de la bugetul de stat, comparabile cu cele din anii precedenți, conform site-ului de Admitere în Universitatea “Politehnica” din București. Despre absorbția pe piața muncii din România și nu numai a absolvenților acestor facultăți, în raport cu celealte, amintite mai sus, nu are rost cred să vorbim.

Poate că o astfel de concurență a fost cea care a influențat gradul de dificultate – extrem de scăzut – a subiectelor de anul acesta de la proba de algebră și elemente de analiză matematică.

Mai dificile (dar nu foarte dificile) au fost aul acesta trei subiecte, unul de algebră (clasa a IX-a) și două de elemente de analiză matematică (clasa a XI-a, respectiv a XII-a).

  1. o ecuație irațională, sub forma unei egalități între un termen care conținea necunoscuta sub un radical de ordin 3 și un alt termen care conținea necunoscuta la puterea a treia: ridicând la cub, se obține o ecuație de gradul 9!!!; totuși, una dintre soluții, x=1, era sugerată de absolut toate variantele de răspus, astfel încât, procedând la o banală împărțire de polinoame, se ajungea la o ecuație de gradul 8 care, prin mici artificii de calcul, se reducea la un produs de doi factori egal cu un număr întreg; procedând la descompunerea în factori a acestuia și la identificarea valorilor, se obțineau și celelalte două soluții reale, care trebuiau să satisfacă ambele (subecuații);
  2. o ecuație care îmbina cunoștințe de rezolvare a unei integrale (destul de facilă), operații cu logaritmi, proprietăți ale polinoamelor și probleme de reprezentare grafică a funcțiilor de o variabilă reală:
  • se explicita polinomul f[x] în funcție de proprietățile specificate în enunț;
  • se rezolva integrala (a cărei valoare era ln f(t)) și se reduceau termenii asemenea obținuți de cele două părți ale egalității, după explicitarea polinomului;
  • ecuația se reducea la egalitatea dintre două expresii (funcții), soluțiile acesteia fiind de fapt punctele de intersecție: se studia variația funcțiilor pentru intervalul (-2, ∞), se trasa graficul și se identificau intervalele din care făceau parte punctele de intersecție (enunțul problemei solicita departajarea între soluțiile negative și cele pozitive)

3. determinarea punctelor de pe graficul unei funcții, astfel încât dreapta tangentă la graficul funcției în acel punct să treacă și printr-un alt punct; candidații trebuiau să cunoască ecuația tangentei la graficul unei funcții într-un punct x0 și anume y – f(x0) = f'(x0)(x – x0), unde x și y erau coordonatele punctului prin care se impunea să treacă dreapta respectivă; se obținea astfel o ecuație în x0, ținându-se cont și de restricția domeniului de apartenență a soluțiilor ecuației – intervalul (0, ∞): problema se reducea – ca și în cazul anterior – la studierea variației a două funcții și la identificare (ceva mai precisă de data aceasta) a intervalului în care se găsesc acestea; una dintre soluții, x=1, era ușor de identificat însă cealaltă ar fi putut fi ușor omisă dacă nu se studia cu atenție intervalul [1, 5] – pentru aceasta însă ar fi fost extrem de util ca în enunț să se precizeze valorile logaritmilor naturali din acest interval, în caz contrar nu stiu cum ar fi putut să aproximeze studenții intervalul în care funcțiile se intersectau.

 Rezolvările complete ale subiectelor de algebră și elemente de analiză matematică pentru examenul de admitere la facultate în cadrul Universității “Politehnica” București pot fi descărcate de mai jos:

rezolvari_upb2014

Se impun semnalate câteva carențe și în elaborarea subiectelor din acest an:

  • gradul de acoperire al materiei este incomplet și neuniform (extrem de multe subiecte ce vizează ecuația de gradul al doilea și relațiile lui Viète, în schimb nici un subiect din sisteme de ecuații liniare, grupuri și izomorfisme de grupuri, inele și corpuri – astfel de subiecte lipsesc cu desăvârșire de foarte mulți ani, limite de funcții cu aplicarea regulii lui l’Hôspital, integrarea de funcții mai complexe);
  •  variantele de răspuns ar trebui să ascundă răspunsul corect sau să îl facă cât mai greu de identificat, exploatând greșeli posibile pe care candidatul le-ar putea face (răspunsuri obținute prin greșeli de calcul sau raționamente incorecte frecvent întâlnite);
  • includerea unor subiecte extrem de simple, sub nivelul de dificultate al claselor de liceu (inecuații de gradul întâi cu o necunoscută).

Anul trecut, la Facultatea de Automatică și Calculatoare a existat la examenul de admitere o singură medie de 10 la probele de concurs. Nu cunosc rezultatele de anul acesta (organizatorii au decis să nu mai facă publice rezultatele electronic), însă sper ca pe viitor acest filtru care este examenul de admitere la facultate să reprezinte pentru candidați nu numai un criteriu de departajare eficient, ci și un indicator fidel al nivelului de pregătire pe care trebuie să îl aibă pentru a putea face față onorabil celor patru ani de studii universitare de licență.

Rezolvarea subiectelor de informatică de la examenul de bacalaureat național, sesiunea iulie 2014 (1)

Filiera teoretică, profilul real, specializările: matematică-informatică, matematică-informatică intensiv informatică

Filiera vocațională, profilul militar, specializarea matematică-informatică

 

Enunțul subiectelor precum și baremul de corectare pot fi descărcate de pe site-ul Ministerului Educației Naționale.

Pe contul de GitHub poate fi consultat codul sursă corespunzător subiectelor care solicită elaborarea de programe C/C++.

SUBIECTUL I (30 de puncte)


1. Subiectul își propune să verifice cunoașterea ordinii precedenței operatorilor în C/C++ precum și rezultatul operațiilor cu întregi. Operatorii * și / au aceeași precedență, deci evaluarea expresiei se face de la stânga la dreapta:
42/10*29/10=4*29/10=116/10=11
Răspunsul corect este c.

 

2. Algoritmul descris în pseudocod este:

citește n (număr natural nenul)

d ← 2

cât timp d ≤ n execută

    p ← 0

    cât timp n%d=0 execută (pentru dezambiguizare, mai corect ar fi fost n%d==0)

        p ← p + 1

        n ← [n / d]

    dacă p%2=0 și p≠0 atunci

        scrie d, ‘ ‘

    d ← d + 1

scrie n

a) În cazul în care se citește n = 2352, execuția algoritmului este următoarea:

d ← 2

2 ≤ 2352

    iterația 1 a primului ciclu cât timp

       p ← 0

       2352%2=0

          iterația 1 a celui de-al doilea ciclu cât timp

             p ← 1

             n ← 1176

       1176%2=0

          iterația 2 a celui de-al doilea ciclu cât timp

             p ← 2

             n ← 588

       588%2=0

          iterația 3 a celui de-al doilea ciclu cât timp

             p ← 3

             n ← 294

       294%2=0

          iterația 4 a celui de-al doilea ciclu cât timp

             p ← 4

             n ← 147

       147%2≠0

       4%2=0 și 4≠0

          scrie 2, ‘ ‘

d ← 3

3 ≤ 147

    iterația 2 a primului ciclu cât timp

       p ← 0

       147%3=0

          iterația 1 a celui de-al doilea ciclu cât timp

             p ← 1

             n ← 49

       49%3≠0

       1%2≠0

d ← 4

4 ≤ 49

    iterația 3 a primului ciclu cât timp

       p ← 0

       49%4≠0

       p%2=0, dar p=0

d ← 5

5 ≤ 49

    iterația 4 a primului ciclu cât timp

       p ← 0

       49%5≠0

       p%2=0, dar p=0

d ← 6

6 ≤ 49

    iterația 5 a primului ciclu cât timp

       p ← 0

       49%6≠0

       p%2=0, dar p=0

d ← 7

7 ≤ 49

    iterația 6 a primului ciclu cât timp

       p ← 0

       49%7=0

          iterația 1 a celui de-al doilea ciclu cât timp

             p ← 1

             n ← 7

       7%7=0

          iterația 2 a celui de-al doilea ciclu cât timp

          p ← 2

          n ← 1

       1%7≠0

       2%2=0 și 2≠0

          scrie 7, ‘ ‘

d ← 8

8 > 1

scrie 1

Așadar, în urma execuției algoritmului se va afișa 2 7 1.

Se observă că algoritmul determină divizorii numărului n nenul, citit de la tastatură, afișându-i doar pe aceea care apar la puteri pare în descompunerea în factori primi.

Algoritmul nu este unul eficient întrucât verifică divizorii secvențial, fără a ține cont de faptul că unii dintre aceștia, nefiind primi, au mai fost testați în iterațiile anterioare ale structurii repetitive cât timp (de exemplu 4=22, 6=2*3).

b) Pentru a se afișa valoarea 5, înseamnă că numărul respectiv trebuie să fie o putere pară a lui 5, iar 5 trebuie să fie singurul său divizor sau 5 trebuie să fie singurul său divizor aflat la o putere pară.

Dacă puterea pară este p = 2, numărul va fi un multiplu de 52=25, ceea ce satisface condiția ca numărul  să aibă maxim două cifre.

Dacă puterea pară este p = 4 sau mai mare, numărul va fi un multiplu de 54=625 sau mai mult, ceea ce nu mai satisface condiția ca numărul  să aibă maxim două cifre.

Așadar, numerele cerute pot fi 25*1=25, 25*2=50, 25*3=75, alte valori nemairespectând condiția ca numărul să fie format din maxim două cifre.

c) Alte structuri repetitive cunoscute sunt execută … cât timp (structură repetitivă cu test final) respectiv pentru (structură repetitivă cu număr cunoscut de pași).

Soluția 1 (structură repetitivă cu test final) – verificarea inițială se face printr-o instrucțiune de tip dacă

citește n (număr natural nenul)

d ← 2

dacă d ≤ n

    execută

        p ← 0

        cât timp n%d=0 execută

            p ← p + 1

            n ← [n / d]

        dacă p%2=0 și p≠0 atunci

            scrie d, ‘ ‘

        d ← d + 1

    cât timp d ≤ n

scrie n

Soluția 2 (structură repetitivă cu număr cunoscut de pași) – are avantajul că este mai comprimată, conținând în sine inițializarea inițială, condiția de trecere la iterația următoare precum și pasul de incrementare.

citește n (număr natural nenul)

pentru d ← 2, d ≤ n, d ← d + 1 execută

    p ← 0

    cât timp n%d=0 execută

        p ← p + 1

        n ← [n / d]

    dacă p%2=0 și p≠0 atunci

        scrie d, ‘ ‘

scrie n

d) Implementarea algoritmului dat în C/C++ nu pune probleme majore:

using namespace std;

#include <iostream>

int main() {
    int n, d=2;
    cout<<"n="; cin>>n;
    while (d<=n) {
        int p=0;
        while (n%d==0) {
            p++;
            n/=d;
        }
        if (p%2==0 && p) cout<<d<<" ";
        d++;
    }
    cout<<n;
    return 0;
}

SUBIECTUL II (30 de puncte)


1. Exercițiul urmărește să verifice cunoașterea noțiunilor aferente unui graf orientat (grad extern al unui nod) precum și reprezentarea sa dându-se numărul de arce.

Graful descris prin noduri și arce are forma ca în figura 1:

Info2014MIsubIIex1Figura 1

Gradul extern al unui nod x, d+(x) reprezintă numărul arcelor care ies din nodul x.

În cazul de față, se observă că:

d+(1)=2

d+(2)=0

d+(3)=2

d+(4)=2

d+(5)=0

d+(6)=4

d+(7)=0

d+(8)=2

Vârfurile care au gradul extern nul sunt 2, 5, 7, iar numărul lor este 3. Răspunsul corect este c.

 

2. Exercițiul urmărește să verifice cunoașterea funcțiilor predefinite în C/C++ pentru lucrul cu șiruri de caractere.

strcpy(s, “1b2d3”);

Funcția strcpy are rolul de a copia un șir sursă (cel de-al doilea parametru) într-un șir destinație (primul parametru). Variabila s va reține prin urmare “1b2d3”.

s[2] = ‘a’ + 2;

Valoarea expresiei ‘a’ + 2 este ‘c’. Ținându-se cont că în C/C++ indexarea într-un tablou (și deci și într-un șir de caractere) se face pornind de la poziția 0, caracterul ‘c’ va fi stocat pe pozița a treia a șirului de caractere. Variabila s va reține acum “1bcd3″.

strcpy(s,s+1);

 Variabila s este un pointer, deci prin incrementare se obține șirul de caractere aflat de la poziția 1 până la sfârșit, adică bcd3. Acesta se copiază în variabila s, care va reține acum “bcd3“.

strcpy(s+3,s+4);

La poziția s+4 se află caracterul terminator de șir, adică ‘\0’, care va suprascrie ultimul caracter al șirului stocat de variabila s, aflat pe poziția s+3. Variabila s va conține acum “bcd“.

Răspunsul corect este d.

3. Exercițiul urmărește să verifice corectitudinea lucrului cu structuri de date definite de utilizator.

În elaborarea algoritmului trebuie să se trateze cele trei cazuri:

a) minutul de start este mai mic decât minutul de stop (momentul de start este anterior momentului de stop) ⇒ rezultat acceptat;

b) minutul de start este egal cu minutul de stop:

    1. secunda de start este mai mică decât secunda de stop (momentul de start este anterior momentului de stop) ⇒ rezultat acceptat;

    2. secunda de start este egală sau mai mare decât secunda de stop (momentul de start coincide cu momentul de stop sau este ulterior momentului de stop) ⇒ rezultat respins.

c) minutul de start este mai mare cu minutul de stop (momentul de start este ulterior momentului de stop) ⇒ rezultat respins.

using namespace std;

#include <iostream>

struct timp {
      int minut;
      int secunda;
} start, stop;

int main() {
     cout<<“start”<<endl;
      cout<<“minut:”; cin>>start.minut;
      cout<<“secunda:”; cin>>start.secunda;
      cout<<“stop”<<endl;
      cout<<“minut:”; cin>>stop.minut;
      cout<<“secunda:”; cin>>stop.secunda;
      if (start.minut<stop.minut)
      cout<<“acceptat”<<endl;
      else if (start.minut==stop.minut) {
            if (start.secunda<stop.secunda)
                  cout<<“acceptat”<<endl;
            else
                  cout<<“respins”<<endl;
      } else if (start.minut>stop.minut)
            cout<<“respins”<<endl;
      return 0;
}

4. Exercițiul urmărește să verifice cunoașterea noțiunilor aferente unui arbore oarecare drept caz particular al unui graf neorientat (rădăcină, frunză, lanț elementar).

Arborele descris prin muchiile sale are forma ca în figura 2:

Info2014MIsubIIex3Figura 2

Se observă că înălțimea maximă a arborelui este 5, aceasta obținându-se pe lanțurile elementare: 7 → 3 → 2 → 5 → 8 → 9 sau, invers 9 → 8 → 5 → 2 → 3 → 7. Prin urmare, rădăcinile pot fi 7 sau 9.

Reprezentările celor 2 arbori pot fi vizualizate în figurile 2a și 2b:

Info2014MIsubIIex3aFigura 2a
Info2014MIsubIIex3bFigura 2b

 

5. Exercițiul urmărește să verifice lucrul cu tablouri bidimensionale (manipularea indecșilor pentru accesarea elementelor de pe linii/coloane).

“Problemele” ridicate de rezolvarea acestei probleme sunt următoarele:

  • citirea numărului de linii/coloane al tabloului bidimensional cu verificarea restricțiilor referitoare la gama de valori din care acestea pot face parte;
  • alocarea dinamică a memoriei pentru stocarea elementelor tabloului bidimensional; acest spațiu de memorie trebuie dealocat la sfârșitul programului;
  • citirea și afișarea elementelor tabloului bidimensional;
  • parcurgerea unei linii/coloane specifice din matrice.
Nu este permisă crearea unui alt tablou bidimensional cu m-1 linii / n-1 coloane și copierea elementelor necesare din tabloul bidimensional inițial. Enunțul specifică foarte clar faptul că tabloul trebuie modificat în memorie.

using namespace std;

#define MIN 3
#define MAX 50

#include <iostream>

int main() {
    int m, n;
    // citirea numarului de linii si de coloane al tabloului bidimensional
    // cu verificarea restrictiilor
    do {
        cout<<“m=”;
        cin>>m;
    } while (m<MIN || m>MAX);
    do {
        cout<<“n=”;
        cin>>n;
    } while (n<MIN || n>MAX);
    // alocare memorie tablou bidimensional
    int** matrice = new int*[m];
    for (int k=0; k<m; k++)
        matrice[k]=new int[n];
    // citirea tabloului bidimensional
    for (int i=0; i<m; i++)
        for (int j=0; j<n; j++) {
            cout<<“matrice[“<<(i+1)<<“][“<<(j+1)<<“]=”;
            cin>>matrice[i][j];
        }
    // eliminare ultima coloana
    for (int k=0;k<m;k++) {
        matrice[k][n-2]=matrice[k][n-1];
        matrice[k][n-1]=0;
    }
    // eliminare ultima linie
    for (int k=0;k<n;k++) {
        matrice[m-2][k]=matrice[m-1][k];
        matrice[m-1][k]=0;
    }
    // afisarea tabloului bidimensional
    for (int i=0; i<m-1; i++) {
        for (int j=0; j<n-1; j++)
            cout<<matrice[i][j]<<” “;
        cout<<endl;
    }
    // dealocare memorie tablou bidimensional
    for (int k=0;k<m;k++)
        delete matrice[k];
    delete matrice;
    return 0;
}

Ștergerea unei valori (de pe linia/coloana rămase libere) a fost simulată prin suprascrierea valorii respective cu 0. Afișarea matricii rămase nu mai parcurge această linie/coloană alocată în memorie.

SUBIECTUL III (30 de puncte)


1. Exercițiul verifică cunoștințele legate de funcțiile recursive.

Se consideră funcția recursivă:

int f(int n) {

    if (n<10) return f(n+1)+3;

    else if (n==10) return 7;

    else return f(n-2)-1;

}

și se cere rezultatul evaluării f(15).

f(15)=f(13)-1

  f(13)=f(11)-1

    f(11)=f(9)-1

      f(9)=f(10)+3

        f(10)=7

      f(9)=7+3=10

    f(11)=10-1=9

  f(13)=9-1=8

f(15)=8-1=7

Răspunsul corect este b.

2. Exercițiul verifică înțelegerea principiului metodei de programare backtracking pentru generarea tuturor soluțiilor care îndeplinesc o anumită condiție.

Pentru generarea șiragurilor de câte 4 mărgele, se aleg – pentru fiecare poziție (de la 1 la 4) – culori din mulțimea {rosu, galben, roz, albastru, violet}, în ordine – astfel încât să se respecte condițiile ca mărgelele din șirag să fie distincte și în șirag să nu se găsească culorile roșu și galben pe poziții alăturate.

Soluția 1:

  • poziția 1: roșu (prima culoare din mulțime)
  • poziția 2: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de alăturare), roz
  • poziția 3: roșu (nu respectă condiția de distinct), galben
  • poziția 4: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de distinct), roz (nu respectă condiția de distinct), albastru

Soluția 2:

  • poziția 1: roșu (prima culoare din mulțime)
  • poziția 2: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de alăturare), roz
  • poziția 3: roșu (nu respectă condiția de distinct), galben
  • poziția 4: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de distinct), roz (nu respectă condiția de distinct), albastru (aceeași soluție ca 1), violet

În acest moment s-au epuizat toate soluțiile care au roșu pe poziția 1, roz pe poziția 2 și galben pe poziția 3. Următoarele soluții au în vedere găsirea altei culori pe poziția 3 în afară de galben.

Soluția 3:

  • poziția 1: roșu (prima culoare din mulțime)
  • poziția 2: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de alăturare), roz
  • poziția 3: roșu (nu respectă condiția de distinct), galben (toate soluțiile cu galben pe această poziție au fost epuizate), roz (nu respectă condiția de distinct), albastru
  • poziția 4: roșu (nu respectă condiția de distinct), galben

Soluția 4:

  • poziția 1: roșu (prima culoare din mulțime)
  • poziția 2: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de alăturare), roz
  • poziția 3: roșu (nu respectă condiția de distinct), galben (toate soluțiile cu galben pe această poziție au fost epuizate), roz (nu respectă condiția de distinct), albastru
  • poziția 4: roșu (nu respectă condiția de distinct), galben (aceeași soluție ca 3), roz (nu respectă condiția de distinct), albastru (nu respectă condiția de distinc), violet

În acest moment s-au epuizat toate soluțiile care au roșu pe poziția 1, roz pe poziția 2 și albastru pe poziția 3. Următoarele soluții au în vedere găsirea altei culori pe poziția 3 în afară de galben și albastru.

Soluția 5:

  • poziția 1: roșu (prima culoare din mulțime)
  • poziția 2: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de alăturare), roz
  • poziția 3: roșu (nu respectă condiția de distinct), galben (toate soluțiile cu galben pe această poziție au fost epuizate), roz (nu respectă condiția de distinct), albastru (toate soluțiile cu albastru pe această poziție au fost epuizate), violet
  • poziția 4: roșu (nu respectă condiția de distinct), galben

Soluția 6:

  • poziția 1: roșu (prima culoare din mulțime)
  • poziția 2: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de alăturare), roz
  • poziția 3: roșu (nu respectă condiția de distinct), galben (toate soluțiile cu galben pe această poziție au fost epuizate), roz (nu respectă condiția de distinct), albastru (toate soluțiile cu albastru pe această poziție au fost epuizate), violet
  • poziția 4: roșu (nu respectă condiția de distinct), galben (aceeași soluție ca 5), roz (nu respectă condiția de distinct), albastru

Așadar, următoarea soluție generată este {roșu, roz, violet, albastru}.

În acest moment s-au epuizat toate soluțiile care au roșu pe poziția 1, roz pe poziția 2. Următoarele soluții au în vedere găsirea altei culori pe poziția 2 în afară de roz.

Soluția 6:

  • poziția 1: roșu (prima culoare din mulțime)
  • poziția 2: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de alăturare), roz (toate soluțiile cu roz pe această poziție au fost epuizate), albastru
  • poziția 3: roșu (nu respectă condiția de distinct), galben
  • poziția 4: roșu (nu respectă condiția de distinct), galben (nu respectă condiția de distinct), roz

Așadar, următoarea soluție generată este {roșu, albastru, galben, roz}.

3. Exercițiul își propune să verifice lucrul cu subprograme și transmiterea de parametrii prin valoare, scrierea modularizată a programelor precum și elaborarea de algoritmi eficienți.

Este evident că trebuie respectate simultan condițiile:

  • n! ∈ [a, b]
  • (n-1)! ∉ [a, b]
  • (n+1)! ∉ [a, b]
  • b-a maxim

de unde rezultă automat faptul că a = (n-1)! + 1 și b=(n+1)! – 1.

Se poate defini o funcție care calculează factorialul unui număr pentru a determina (n-1)! și (n+1)! sau, pentru eficiență, funcția poate fi apelată o singură dată, pentru (n-1)!, (n+1)! determinându-se apoi, pe baza acestei valori, prin înmulțirea cu n*(n+1).

Atenție! Parametrii a și b sunt transmiși subprogramului interval prin referință, valorile determinate în cadrul subprogramului fiind furnizate prin intermediul acestora.

using namespace std;

#include <iostream>

int factorial(int n) {
    int rezultat = 1;
    for (int k=2; k<=n; k++)
        rezultat*=k;
    return rezultat;
}

void interval(int n, int* a, int* b) {
    int baza = factorial(n-1);
    *a = baza + 1;
    *b = baza * n * (n+1) – 1;
}

int main() {
    int n;
    do {
        cout<<“n=”;
        cin>>n;
    } while (n<2 || n>10);
    int a, b;
    interval(n, &a, &b);
    cout<<“a=”<<a<<” b=”<<b<<endl;
    return 0;
}

4. Exercițiul vizează verificarea aptitudinilor de lucru cu fișiere în C/C++ precum și elaborarea unui algoritm eficient, în timp polinomial, cu argumentarea alegerii unei astfel de soluții.

a) Se determină toate subnumerele unui număr ca rest al împărțirii la 100 al numărului respectiv (întrucât un subnumăr poate conține exact 2 cifre), eliminându-se succesiv ultima cifră (prin împărțirea sa la 10) până când nu mai există subnumere. Valorile subnumerelor și numărul de apariții al fiecărui subnumăr va fi contorizat în cadrul a doi vectori, unul care reține valorile (subnumere), iar celălalt care stochează numărul de apariții (ocurente). De fiecare dată se verifică, prin căutare, dacă subnumărul respectiv există anterior. Se determină maximul numărului de ocurențe și valoarea (valorile) corespunzătoare acestui maxim se afișează.

Complexitatea algoritmului propus este O(n) întrucât vectorul este parcurs de 2 ori, odată pentru determinarea subnumerelor și odată pentru determinarea maximului numărului de ocurențe (stocarea valorilor subnumerelor în vector presupune și ea o parcurgere pentru căutare – astfel încât să nu se rețină duplicate -, însă și aceasta se realizează tot în timp liniar).

b)

using namespace std;

#include <iostream>
#include <fstream>

#define MAX 1024

int main() {
    long numar;
    // vectori ce contin
    // – valorile subnumerelor aferente numerelor din fisier
    // – numarul de aparitii pentru fiecare subnumar
    int *subnumere, *ocurente, dimensiune = 0;
    // alocare memorie
    subnumere = new int[MAX];
    ocurente = new int[MAX];
    // deschidere fisier
    ifstream fisier(“bac.txt”);
    if (fisier.is_open()) {
        // citire numar din fisier
        while (fisier>>numar) {
            while (numar%100 > 10) {
                // determinare subnumar
                int subnumar = numar % 100, gasit = 0;
                // cautare subnumar in vector
                for (int k=0; k<dimensiune && !gasit; k++)
                    // subnumarul a fost gasit in vector, se incrementeaza numarul de ocurente
                    if (subnumere[k] == subnumar) {
                        ocurente[k]++;
                        gasit = 1;
                    }
                // subnumarul nu a fost gasit in vector, se stocheaza (numarul de ocurente este 1)
                if (!gasit) {
                    subnumere[dimensiune] = subnumar;
                    ocurente[dimensiune] = 1;
                    dimensiune++;
                }
                numar /= 10;
            }
        }
        // inchidere fisier
        fisier.close();
    }
    // determinare numar maxim de ocurente
    int maxim = 1;
    for (int k=0; k<dimensiune; k++)
        if (ocurente[k]>=maxim)
            maxim = ocurente[k];
    // afisarea subnumerelor care apar de cele mai multe ori
    for (int k=0; k<dimensiune; k++)
        if (ocurente[k]==maxim)
            cout<<subnumere[k]<<” “;
    cout<<endl;
    // dealocare memorie
    delete subnumere;
    delete ocurente;
    return 0;
}