Problema 2 - defrag 100 puncte

Discul dur (hard disk) este un dispozitiv utilizat pentru stocarea datelor. Stocarea se face pe o suprafață
magnetică dispusă pe platane rotunde metalice. Pe un platan, datele sunt organizate în piste și sectoare, iar zona
aflată la intersecția dintre o pistă și un sector poartă denumirea de cluster.
Un cluster poate avea două stări: liber, dacă nu conține date, sau ocupat, atunci când conține date.
Un platan se numește defragmentat dacă toți clusterii ocupați de pe fiecare pistă sunt așezați în ordine
consecutivă. Defragmentarea se realizează prin mutarea unor clusteri ocupați și are rolul de a micșora timpul de
acces la date. Mutarea unui cluster reprezintă transferul datelor de la un cluster ocupat către un cluster liber de pe
aceeași pistă.

Cerință
Cunoscând numărul de piste P și de sectoare S al unui platan, numărul și poziția clusterilor ocupați, să se scrie
un program care determină :
1. numărul de piste care au toți clusterii liberi;
2. numărul minim de mutări de clusteri, pentru fiecare pistă în parte, astfel încât platanul să devină defragmentat.

Date de intrare
Pe prima linie a fişierului de intrare defrag.in se găsește numărul natural V a cărui valoare poate fi doar 1 sau 2.
Pe a doua linie a fișierului de intrare se găsesc două numere naturale P și S, separate printr-un spaţiu, cu
semnificaţia din enunţ.
A treia linie conţine un număr natural C reprezentând numărul total de clusteri ocupați de pe platan, iar pe
fiecare din următoarele C linii se găsește câte o pereche de valori pi şi si, 1 ≤ i ≤ C, separate printr-un spaţiu,
reprezentând pista, respectiv sectorul unde se află fiecare cluster ocupat.

Date de ieşire
Fișierul de ieșire este defrag.out.
Dacă valoarea lui V este 1 atunci fişierul de ieşire va conţine pe prima linie un număr natural ce reprezintă
numărul de piste care au toți clusterii liberi.
Dacă valoarea lui V este 2 atunci fişierul de ieşire va conține pe prima linie P numere naturale notate Mi,
1 ≤ i ≤ P, separate prin câte un singur spațiu, unde Mi reprezintă numărul minim de mutări de clusteri, dintre cei
aflați pe pista i, astfel încât pe pista i clusterii ocupați să se găsească într-o ordine consecutivă.

Restricţii şi precizări
1 ≤ P ≤ 100
1 ≤ S ≤ 360
1 ≤ C ≤ P*S
pistele sunt numerotate de la 1 la P începând cu pista exterioară;
sectoarele sunt numerotate de la 1 la S în sensul acelor de ceasornic începând cu sectorul 1;
dacă o pistă are toți clusterii liberi, atunci valoarea cerută la a doua cerință este 0;

_______________
Problema 2 – defrag pag. 1 din 18
 20% din teste vor avea valoarea V = 1, iar 80% din teste vor avea valoarea V = 2.

defrag.in defrag.out Explicaţii

1 1 Datele corespund figurilor anterioare :
4 8 V = 1, deci se rezolvă NUMAI prima cerință.
10
1 1  Numărul de piste P = 4 , numărul de sectoare S = 8
1 3  Numărul total de clusteri ocupați este C = 10 (cei marcați cu negru)
1 5
1 7  Pe prima pistă sunt 4 clusteri ocupați, în sectoarele 1, 3, 5 si 7.
4 5  Pe a doua pistă sunt 2 clusteri ocupați, în sectoarele 2 și 4.
4 1  Pe a treia pistă nu sunt clusteri ocupați.
4 6  Pe a patra pistă sunt 4 clusteri ocupați, în sectoarele 1, 5, 6 și 8.
4 8
2 2 O singură pistă are toți clusterii liberi, pista numărul 3, deci valoarea cerută
2 4 este 1;

Exemple

defrag.in defrag.out Explicaţii

2 2 1 0 1 Datele corespund figurilor anterioare :
4 8 V = 2, deci se rezolvă NUMAI a doua cerință.
10
1 1  Pe prima pistă sunt necesare minim două mutări de clusteri pentru ca toți
1 3 clusterii ocupați să se găsească într-o ordine consecutivă, deci valoarea
1 5 cerută este 2.
1 7
4 5  Pe a doua pistă este suficientă o singură mutare de cluster, pentru ca toți
4 1 clusterii ocupați să se găsească într-o ordine consecutivă, deci valoarea
4 6 cerută este 1.
4 8
2 2  Pe a treia pistă nu sunt clusteri ocupați, deci valoarea cerută este 0.
2 4  Pe a patra pistă este suficientă o singură mutare de cluster, pentru ca toți
clusterii ocupați să se găsească într-o ordine consecutivă, deci valoarea
cerută este 1.

Timp maxim de executare: 0,2 secunde/test.

Total memorie disponibilă: 4 MB.
Dimensiunea maximă a sursei: 10 KB.

_______________
Problema 2 – defrag pag. 2 din 18
 2.
Secventa
Numim secventa liniara o secventa de numere intregi a1, a2,…an cu proprietatea ca a i+1-
ai=i, 1<=i<=n-1.
Scrieti programul C++ care citeste sirul de numere din fisier, determina si afiseaza pe ecran
cea mai lunga secventa liniara din sir.
Elementele secventei liniare se vor afisa in fisierul numere.out cu spatiu intre ele.
Daca exista mai multe secvente liniare de lungime maxima, se va afisa ultima dintre ele.

Date de intrare
Pe prima linie a fişierului de intrare numere.in se găsește sirul de numere
Date de ieşire
Fișierul de ieșire este numere.out contine secventa liniara de numere

Restricţii şi precizări

-nr. maxim de numere din fisier este 104 numere naturale

-nr. maxim de cifre din fiecare numar este 8
numere.in numere.out
4 6 8 9 11 14 5 7 9 10 12 15 19 4 2 9 10 12 15 19

Timp maxim de executare: 0,2 secunde/test.

Total memorie disponibilă: 4 MB.
Dimensiunea maximă a sursei: 10 KB.

_______________
Problema 2 – defrag pag. 3 din 18
Problema 2 – Oferta 100 puncte

Patronul unei rețele de telefonie mobilă s-a gândit să facă periodic o ofertă de abonament clienților
săi. Fiecare client are asociat un număr natural ce reprezintă codul clientului. Codurile clienţilor nu au
neapărat acelaşi număr de cifre. Patronul i-a rugat pe angajaţii firmei să stabilească algoritmul pentru
determinarea codului câştigător.
Angajaţii firmei de telefonie au despărţit toate codurile clienților în cifrele componente și le-au
introdus într-un fișier text, apoi au obținut cel mai mare număr palindrom cu cifrele pe care le-au avut la
dispoziţie, acela fiind codul clientului câştigător. În cazul în care o cifră apare în palindrom, ea este
utilizată de câte ori apare în fișierul text.

Cerinţă:
Cunoscând cifrele obţinute de angajaţii firmei din codurile clienţilor, să se determine cel mai mare număr
palindrom ce se poate forma respectând regula de mai sus, deci codul clientului câştigător. Un număr este
palindrom dacă citit de la stânga la dreapta are aceeaşi valoare ca şi la citirea de la dreapta la stânga
(exemplu: 15351).

Date de intrare:
De pe prima linie a fişierului oferta.in se citeşte numărul n de cifre, iar de pe a doua linie a fişierului se
citesc cele n cifre.
Datele de intrare sunt în conformitate cu cerinţele problemei. Nu se cere validarea datelor de intrare.

Date de ieşire:
În fişierul oferta.out se va afişa numărul cerut.

Restricţii:
1≤n≤10000

Exemple:

oferta.in oferta.out
4 252
2452
oferta.in oferta.out
7 333
2235332

Timp maxim de execuţie: 1 secundă/test

Memorie totală disponibilă: 8 MB din care 2 MB pentru stivă.
Dimensiunea maximă a sursei: 15 KB.

_______________
Problema 2 – defrag pag. 4 din 18
Problema 1 – Magic 100 puncte

Harry Potter dispune de două baghete magice 1 şi 2. Cu ajutorul baghetei 1 el poate să mărească puterea
unei vrăji până la cel mai apropiat număr mai mare decât puterea vrăjii şi care are exact 2 divizori. Folosind
bagheta magică 2 el poate să micşoreze puterea unei vrăji până la cel mai apropiat număr de valoarea vrăjii,
mai mic decât aceasta şi care are exact 2 divizori. Se dau: o valoare N care semnifică numărul vrăjilor ale
căror puteri vor fi modificate de către Harry Potter, o valoare B care poate fi 1 sau 2 şi semnifică bagheta
pe care acesta o va folosi şi N numere naturale ce reprezintă puterile iniţiale ale celor N vrăji. Se cere să se
determine puterile finale ale vrăjilor, puterea maximă atinsă şi numărul vrăjilor pentru care s-a atins această
putere, după modificarea făcută de Harry Potter cu ajutorul unei baghete magice.

Date de intrare:
Datele de intrare se citesc din fişierul magic.in în această ordine:
- de pe prima linie, prima valoare N reprezentând numărul vrăjilor;
- de pe prima linie, a doua valoare B care poate fi 1 sau 2, reprezentând bagheta folosită de Harry Potter;
- de pe a doua linie se vor citi cele N numere x1, x2, …, xn reprezentând puterile vrăjilor, care sunt
numere naturale.
Datele de intrare sunt în conformitate cu cerinţele problemei. Nu se cere validarea datelor de intrare.

Date de ieşire:
Se vor afişa în fişierul magic.out, pe prima linie, N numere naturale, separate prin spaţiu, reprezentând
puterile vrăjilor după modificarea făcută de Harry Potter. Pe cea de a doua linie a fişierului magic.out se
vor afişa, separate printr-un spaţiu: valoarea maximă a puterilor vrăjilor după magie şi numărul vrăjilor
care ating această valoare.

Restricţii:
1  N  150
3  xi  32700

Exemple:

magic.in magic.out
15 1 5 7 11 13 5 7 11 11 13 7 5 11 17 17 11
3 6 8 12 3 5 7 9 12 5 3 7 14 16 10 17 2
12 2 2 5 23 5 7 19 23 7 23 3 5 13
3 6 29 7 11 21 24 9 25 5 7 14 23 3

Timp maxim de execuţie: 1 secundă/test.

Memorie totală disponibilă: 8 MB din care 2 MB pentru stivă.
Dimensiunea maximă a sursei: 15 KB.

_______________
Problema 2 – defrag pag. 5 din 18
Problema 1 - Mărgele 100 de puncte

Fetiţele din clasa întâi doresc să pregătească un micuţ cadou de ziua mamei. Ele au cumpărat mărgele şi
doresc să confecţioneze brăţări pentru fiecare mămică. Mărgelele cumpărate sunt de mai multe tipuri.
Fiecare dintre cele n fetiţe va realiza o brăţară utilizând acelaşi număr de mărgele, însă nu neapărat de
acelaşi tip. Pentru a realiza brăţări cu diferite mărgele, fetiţele trebuie să verifice ce fel de mărgele a ales
fiecare și care sunt cele mai utilizate tipuri de mărgele.

Cerinţă
Fiind dat un număr natural n, reprezentând numărul fetiţelor şi numărul natural k, reprezentând numărul de
mărgele dintr-o brăţară, să se determine:
1. perechile de fetițe care au ales același număr de mărgele din fiecare tip și numărul acestor perechi.
(50p)
2. tipurile de mărgele utilizate de cele mai multe fetițe.(50p)

Date de intrare
Fişierul de intrare mărgele.in conţine, pe prima linie, un număr natural p:
- pentru p = 1 se va rezolva prima cerință,
- pentru p=2 se va rezolva a doua cerință.
Fișierul de intrare conține, pe a doua linie, numerele naturale n, k reprezentând numărul de fetiţe şi
respectiv numărul de mărgele din fiecare brăţară. Fiecare dintre următoarele n linii conţine, pentru fiecare
fetiţă, câte k valori separate prin câte un spaţiu, reprezentând tipurile de mărgele alese.

Date de ieşire
Pentru p = 1, fişierul de ieşire mărgele.out va conţine, pe primul rând, numărul de perechi de fetițe care au
ales același număr de mărgele din fiecare tip, iar pe următoarele rânduri perechile de fetițe care au ales
același număr de mărgele din fiecare tip, pe fiecare linie câte o pereche formată din numerele de ordine ale
fetițelor, separate prin câte un spațiu, în ordine strict crescătoare, ca în exemplu.
Pentru p = 2, pe prima linie a fișierului mărgele.out se vor găsi numerele de ordine ale tipurilor de mărgele
alese de cele mai multe fetițe, separate prin câte un spațiu, în ordine strict crescătoare.

Restricţii şi precizări
- 1<=n<=150
- 1<=k<=100
- Tipul unei mărgele este un număr întreg din intervalul [0,100].
- Într-o pereche numerele de ordine ale fetiţelor trebuie date în ordine strict crescătoare.

Exemplu :
mărgele.in mărgele.out Explicaţii
1 2 Numărul perechilor de fetițe care au ales același
64 14 număr de mărgele din fiecare tip este 2.
1234 36 Perechile de fetițe care au ales același număr de
5666 mărgele din fiecare tip sunt 1 4 și 3 6.
1121
4213
6126

_______________
Problema 2 – defrag pag. 6 din 18
 2111
2 12 Tipurile de mărgele alese de cele mai multe fetițe
64 sunt 1 și 2, deoarece mărgeaua de tipul 1 este aleasă
1234 de 5 fetițe, iar mărgeaua de tipul 2 este de asemenea
5666 aleasă de 5 fetițe
1121
4213
6126
2111

Timp de rulare/test: 0,3 secunde

Memorie disponibilă: 1MB

_______________
Problema 2 – defrag pag. 7 din 18
Problema 2 - Numere 100 de puncte

Algoritmelestepasionat de numere.El esteelevînclasa a 9-a. Zilnic,el rezolvăprobleme de matematicăşi de

informatică cu numeremaimicisaumaimari.
Într-o zi, el şi-a propussărezolveo problemădar s-a cam împotmolitîncalculi,de
aceeavăroagăsăîlajutaţisărezolveproblema de maijos.

Cerinţa
Fiind date nnumerenaturaleşi un număr natural k, să se determine:
1. Numărul natural care se formează cu cifra de control a fiecăruinumărdintre cele n
numerenaturalecitite din fişier care au exact k divizori, înordineacitirii.
2. Celmai mare număr natural care se formează cu cifra de control a fiecăruinumărdintre cele n
numerenaturalecititedin fişier care au exact k divizori.
3. Suma celordouănumere determinate anterior.
Cifra de control a unuinumăr se obțineefectuândsumacifrelor sale, apoisumacifreloracesteisume,
pânăcândsumaobținutăeste un număr format dintr-o singurăcifră. Aceastăultimăcifrăpoartănumele de cifră
de control.
Exemplu:
Cifrade control (cc) a numărului
n=4568248:cc(4568258)=cc(38)=cc(11)=2

Date de intrare
Fişierul de intrare“numere.in”conţine, pe prima linie, un număr natural p care poateaveavaloarea 1, 2 sau
3.
Dacă p esteegal cu 1 atunci se varezolvanumaicerinţa 1 a problemei.
Dacă p esteegal cu 2 atunci se varezolvanumaicerinţa 2 a problemei.
Dacă p esteegal cu 3 atunci se varezolvanumaicerinţa 3 a problemei.
Pe a doualinie a fişierului se găsescdouănumerenaturalen şi k.
Pe a treialinie a fişierului se găsesc n numarenaturale cu maxim 9 cifrefiecare.

Date de iesire
Fişierul de ieşire“numere.out”conţine, pe prima linie,un singurnumăr natural, înfuncţie de
cerinţaproblemei.

Restricțiișiprecizări
 1 <= n<= 100000;
 2 <= k <= 200;
 0 <= numar din fisier<= 100000000;
 Celmult 200 de numere din fisier au k divizori.
 40% teste –cerinta 1
 30% teste –cerinta 2
 30% teste –cerinta 3

_______________
Problema 2 – defrag pag. 8 din 18
Exemple:
numere.in numere.out Explicaţie:
1 2482 Numerele cu 2 divizori sunt:
72 11, 13, 17, 11si au cifrele de
11 10 13 20 17 100 11 control 2,4,8,2 deci se
formeazanumarul 2482.
numere.in numere.out Explicaţie:
2 8422 Numerele cu 2 divizori sunt:
72 11, 13, 17, 11si au cifrele de
11 10 13 20 17 100 11 control 2,4,8,2.
Numarul natural maxim este
8422.
numere.in numere.out Explicaţie :
2 10904 Suma numerelor
72 determinate anterior
11 10 13 20 17 100 11 (2482si 8422) este 10904.

Timp maxim de execuţie: 0.8 secundă/test

Memoria totalădisponibilă: 8MB din care 2MB pentru stivă.
Dimensiuna maximă a sursei: 5KB

_______________
Problema 2 – defrag pag. 9 din 18
Margele
#include <iostream>
#include<fstream>
using namespace std;

int a[151][101], n, k,b[101], x[11176], y[11176];

ifstream f("margele.in");
ofstream g("margele.out");
int main()
{
int i,j,ok,x1, p;
f>>p;
f>>n>>k;

for(i=1; i<=n; i++)

for(j=1; j<=k; j++)
{
f>>x1;
a[i][x1]++;
}
int nr=0;
for(i=1; i<=n-1; i++)
for(j=i+1; j<=n; j++)
{
ok=1;
int t;
for(t=0; t<=100; t++)
if(a[i][t]!=a[j][t])
{
ok=0;
break;
}
if(ok==1)
{
nr++;
x[nr]=i;
y[nr]=j;
}
}
if(p == 1)
{
g<<nr<<'\n';
for(i=1; i<=nr; i++)
g<<x[i]<<" "<<y[i]<<'\n';

else
{

_______________
Problema 2 – defrag pag. 10 din 18
 int max1=0;
for(j=0; j<=100; j++)
{
b[j]=0;
for(i=1; i<=n; i++)
if(a[i][j]!=0)
b[j]++;
if(b[j]>max1)
max1=b[j];
}

for(j=0; j<=100; j++)

if(b[j]==max1)
g<<j<<" ";
}

return 0;
}

Magic
#include <fstream>
using namespace std;
ifstream f("magic.in");
ofstream g("magic.out");
int n,b,x,maxi,nr,z,ok,k;
int main()
{
f>>n>>b;
maxi=0;
if(b==1)
{
for(int i=1;i<=n;i++)
{
f>>x;
z=x+1;
k=0;
while(k==0)
{
ok=1;
if(z%2==0 && z>=4)
ok=0;
for(int d=3;d*d<=z && ok==1;d+=2)
if(z%d==0)
ok=0;
if(ok==1)
k=1;
else
z++;
}
g<<z<<" ";

_______________
Problema 2 – defrag pag. 11 din 18
 if(z>maxi)
{
maxi=z;
nr=1;
}
else
if(z==maxi)
nr++;
}
g<<endl<<maxi<<" "<<nr;
}
else
if(b==2)
{
for(int i=1;i<=n;i++)
{
f>>x;
z=x-1;
k=0;
while(k==0)
{
ok=1;
if(z%2==0 && z>=4)
ok=0;
for(int d=3;d*d<=z && ok==1;d+=2)
if(z%d==0)
ok=0;
if(ok==1)
k=1;
else
z--;
}
g<<z<<" ";
if(z>maxi)
{
maxi=z;
nr=1;
}
else
if(z==maxi)
nr++;
}
g<<endl<<maxi<<" "<<nr;
}
return 0;
}
Secventa
…………
int main()
{
int v[10001],i,j,lcrt,lmax,x,b[100001],y;

f>>v[1];lcrt=1;lmax=1;x=1;i=1;
while(f>>x)
{

_______________
Problema 2 – defrag pag. 12 din 18
 if(x-v[i]==lcrt)
{
i++;
v[i]=x;
lcrt++;
}
else
{
if(lcrt>lmax)

{lmax=lcrt;
for(j=1;j<=lmax;j++)
b[j]=v[j];
}
lcrt=1;

i=1;
v[i]=x;
}

}
if(lcrt>lmax)

{lmax=lcrt;
for(j=1;j<=lmax;j++)
b[j]=v[j];
}
for(i=1;i<=lmax;i++)
cout<<b[i]<<" ";

return 0;
}
……………………..
oferta
#include <fstream>
using namespace std;
int c[10],b[10],s[10001];
int n,np,u,k,i,j,f;
ifstream fin("oferta.in");
ofstream g("oferta.out");
int main()
{
fin>>n;
for(i=1;i<=n;i++)
{
fin>>k;
c[k]++;
}
i=0;
j=0;
f=0;
np=0;
for(k=9;k>=0;k--)
{

_______________
Problema 2 – defrag pag. 13 din 18
 if(c[k]%2==0)
b[k]=1;
else
if(c[k]>i &&(k!=0 || k==0 && f==1))
{i=c[k];u=k;}
if (c[k]>1 && k!=0) f=1;
}
if(i>0)
b[u]=1;
b[0]=(b[0] && f==1);
np=0;
for(k=0;k<=9;k++)
if(b[k]==1) np=np+c[k];
i=1;
for(k=9;k>=0;k--)
if(b[k]==1)
{
for(j=1;j<=c[k]/2;j++)
{
s[i]=k;s[np-i+1]=k;i=i+1;
}
if(c[k]%2==1)
s[(np+1)/2]=k;
}
for(i=1;i<=np;i++)
g<<s[i];
if(np==0)
g<<0;
return 0;
}

////////////////////////////////////////
1defragm
#include <fstream>

using namespace std;

ifstream cin("defrag.in");
ofstream cout("defrag.out");
#define MAXP 105
#define MAXS 365
bool d[MAXP][MAXS];
int nrc[MAXP*MAXS];
int n,m;
int main()
{
int k,i,j,tip,x,y;
cin>>tip;
cin>>n>>m; // PISTE & CLUSTERI
cin>>k;
for(i=1; i<=k; i++)
{

_______________
Problema 2 – defrag pag. 14 din 18
 cin>>x>>y;
d[x][y-1]=1;
nrc[x]++;
}

if(tip==1)
{
int c=0;
for(i=1; i<=n; i++)
if(!nrc[i])
c++;

cout<<c;
}
else
{
/*pt a calcula numarul minim de mutari care sunt necesare pentru a defragmenta o pista
ma folosesc de numarul total de sectoare ocupate pe acea pista si parcurg
fiecare subsecventa posibila de forma ( i , i + nr_de_sectoare_ocupate )
si in functie de cate sunt ocupate in acea subsecventa vad cam cate ar mai trebui mutate
acolo din restul ramase, si astfel gasesc minimul*/
int b,crt;
for(i=1; i<=n; i++)
{
crt=nrc[i];
for(j=0; j<nrc[i]; j++)
if(d[i][j])
crt--;
b=crt;

for(j=0; j<m; j++)

{
if(d[i][j])
crt++;

if(d[i][ (j+nrc[i])] )
crt--;

if(crt<b)
b=crt;
}
cout<<b<<" ";
}
}
return 0;
}

_______________
Problema 2 – defrag pag. 15 din 18
Numere
#include <fstream>
#include <math.h>
#include <iostream>
using namespace std;
ifstream f("numere.in");
ofstream g("numere.out");
int fr[10];
int nr1[205],nr2[205];
int cif(unsigned x)
{
if(x%9==0) return 9;
else return x%9;
}
void Add(int A[], int B[])
/* A <- A+B */
{ int i,T=0;

for (i=A[0];i>=1;i--)
{ A[i]+=B[i]+T;
T=A[i]/10;
A[i]%=10;
}
if (T)
{
g<<T;
for(int i=1;i<=nr1[0];i++) g<<nr1[i];}
else
for(int i=1;i<=nr1[0];i++) g<<nr1[i];

}
int main()
{

int n,k,pp,nrk,copie,nrdiv,d,i;
int p[3500];

bool ok;

f>>pp>>n>>k;

/// ciurul lui Eratostene

p[0]=1;
p[1]=2;
d=3;
while(d<=32000)
{
ok=true;
for(i=1; ok && i<=p[0] && p[i]*p[i]<=d; i++)
if(d%p[i]==0)
ok=false;

if(ok)
{

_______________
Problema 2 – defrag pag. 16 din 18
 p[0]++;
p[p[0]]=d;
}
d+=2;
}

unsigned x;
while(f>>x)
{

/// descompunerea in factori primi

nrdiv=1;
copie=x;
i=1;
while(i<=p[0] && p[i]*p[i]<=copie && copie>1)
{
d=0;
while(copie%p[i]==0)
{
d++;
copie/=p[i];
}
nrdiv*=(d+1);
i++;
}

if(copie>1)
nrdiv*=2;

if(nrdiv==k)
{ int c=cif(x);
nr1[0]++;
nr1[nr1[0]]=c;
fr[c]++;
if(pp==1)
{
g<<c;
}
}
}

nr2[0]=0;
for(int i=9;i>=0;i--)
for(int j=1;j<=fr[i];j++)
{
if(pp==2) g<<i;
nr2[0]++;
nr2[nr2[0]]=i;

if(pp==3)

_______________
Problema 2 – defrag pag. 17 din 18
 Add(nr1,nr2);

return 0;
}

_______________
Problema 2 – defrag pag. 18 din 18