#91 Masini

Enunt:În curtea unui atelier de #include <iostream>

reparaţii auto, sunt n maşini care #include<fstream>
trebuie sa fie reparate. Deoarece nu using namespace std;
sunt suficienţi mecanici, în fiecare ifstream f("masini.in");
moment de timp se poate lucra doar ofstream g("masini.out");
la o singură maşină. int n,m,v[1001],T;
Cerinţa:Cunoscând timpul
void citire()
necesar pentru repararea fiecărei
{for(int i=1;i<=n;i++)
maşini, scrieţi un program care
calculează numărul maxim de maşini f>>v[i];
care pot fi reparate într-un interval }
de timp T. void ordonare()
Date de intrare:Pe prima linie {for(int i=1;i<n;i++)
a fişierului masini.in se găsec două for(int j=i+1;j<=n;j++)
numere naturale n şi T separate if(v[i]>v[j])
printr-un singur spaţiu, { int aux=v[i];
reprezentând numărul de maşini din v[i]=v[j];
curtea atelierului auto şi timpul total v[j]=aux;
în care se va lucra. }
Pe linia a doua, separate prin câte }
un spaţiu, se găsesc n numere void numarare()
naturale t1, t2, …, tn, reprezentând
{int nr=0,s=0;
timpii necesari pentru repararea
for(int i=1;i<=n;i++)
fiecărei maşini.
Date de ieşire:Pe prima linie a if(s<T and s+v[i]<T)
fişierului masini.out se va găsi un {s+=v[i]; nr++;}
număr natural k, reprezentând g<<nr;
numărul maxim de maşini care pot fi }
reparate. int main()
Restricţii şi precizări:1 < n, T {f>>n>>T;
<= 1000 citire();
numerele de pe a doua linie a ordonare();
fişierului de intrare vor fi mai mici numarare();
sau egale cu 100 return 0;
}
 #92 Proiecte #include <iostream>
#include<fstream>
Enunt:La un birou care se
using namespace std;
ocupă cu analiza proiectelor de
investiţii, n investitori au depus până ifstream f("proiecte.in");
la termenul legal, câte un proiect. ofstream g("proiecte.out");
int n,i,j;
Cerinţa : Cunoscând timpul
necesar pentru analizarea fiecărui struct proiecte{int t,o;}v[1001];
proiect, scrieţi un program care void citire()
determină ordinea în care vor fi { for(int i=1;i<=n;i++)
analizate proiectele, astfel încât {f>>v[i].t; v[i].o=i;}}
timpul mediu de aşteptare pentru ordonare()
investitori să fie minim. {for(i=1;i<=n;i++)
Date de intrare : Pe prima linie for( j=i+1;j<=n;j++)
a fişierului proiecte.in se găseşte un if(v[i].t>v[j].t)
număr natural n reprezentând { proiecte aux=v[i];
numărul de proiecte depuse. Pe linia
v[i]=v[j];
a doua, separate prin câte un spaţiu,
se găsesc n numere naturale t1, t2, v[j]=aux;
…, tn, reprezentând timpii necesari }
pentru analizarea fiecărui proiect. }
Date de ieşire: Pe prima linie a
void afisare()
fişierului proiecte.out se vor găsi n { for(i=1;i<=n;i++)
numere naturale cuprinse între 1 şi g<<v[i].o<<" ";
n, reprezentând ordinea în care vor }
fi analizate proiectele. int main()
Restricţii şi precizări :1 ≤ n ≤ {f>>n;
1000, numerele de pe a doua linie a citire();
fişierului de intrare vor fi mai mici ordonare();
sau egale cu 100 afisare();
return 0;
}
#398 Plopi2 #include<fstream>
using namespace std;
Cerinţa :De-a lungul
principalei străzi din oraşul nostru ifstream f("plopi2.in");
există n plopi, pentru fiecare ofstream g("plopi2.out");
cunoscându-se înălţimea. Primarul int n,a[101],nr,l;
oraşului doreşte ca plopii să aibă
înălţimile în ordine descrescătoare.
void citire()
Pentru aceasta, este posibilă tăierea { f>>n;
dintr-un plop a unei bucăţi – este o for(int i=1;i<=n;i++) f>>a[i];
tehnică ecologică, nevătămătoare, în
}
urma căreia plopul nu are de suferit.
Plopii nu pot fi înălţaţi în niciun fel. void greedy()
Determinaţi numărul minim de plopi { for(int i=2;i<=n;i++)
din care se va tăia şi lungimea totală if(a[i]>a[i-1])
minimă a bucăţilor tăiate.
Date de intrare :Fişierul de
{nr++;
intrare plopi2.in conţine pe prima l=l+a[i]-a[i-1];
linie numărul de plopi n. Urmează n a[i]=a[i-1];
numere naturale nenule, separate
}
prin spaţii, care pot fi dispuse pe mai
multe linii, reprezentând înălţimile }
plopilor. int main()
Date de ieşire :Fişierul de {citire();
ieşire plopi2.out va conţine pe prima
linie numerele C T, separate prin greedy();
exact un spaţiu, reprezentând g<<nr<<' '<<l;
numărul minim de plopi din care se f.close();
va tăia şi lungimea totală minimă a
g.close();
bucăţilor tăiate.
Restricţii şi precizări: 2 ≤ n ≤ return 0;
100 }
înălţimile plopilor vor fi mai mici
decât 10000
#353 Spectacole
Enunt :La un festival sunt #include<iostream>
programate n spectacole, pentru #include<fstream>
fiecare se cunoaşte momentul de using namespace std;
început şi momentul de sfârşit, ifstream f("spectacole.in");
exprimate prin numere naturale. Un ofstream g("spectacole.out");
spectator doreşte să urmărească cât int n,nr;
mai multe spectacole în întregime. struct spectacol{int x,y;} a[101],b[101];
Determinaţi numărul maxim de void citire()
spectacole care pot fi urmărite, fără {f>>n;
ca acestea să se suprapună. for(int i=1;i<=n;i++)
Date de intrare: Fişierul de f>>a[i].x>>a[i].y;
intrare spectacole.in conţine pe }
prima linie numărul n. Pe fiecare void ord()
dintre următoarele n linii se află câte {for(int i=1;i<n;i++)
două numere naturale X Y, {for(int j=i+1;j<=n;j++)
reprezentând momentul de început if(a[i].y>=a[j].y)
şi momentul de sfârşit al unui {struct spectacol aux=a[i];
spectacol. a[i]=a[j];
Date de ieşire: Fişierul de a[j]=aux;
ieşire spectacole.out va conţine pe }
prima linie numărul S, reprezentând }
numărul maxim de spectacole care }
pot fi urmărite, fără să se void formare()
suprapună. {nr=1; b[1]=a[1];
Restricţii şi precizări: 1 ≤ n ≤ for(int i=2;i<=n;i++)
100 if(a[i].x>=b[nr].y)
momentele de început şi sfârşit ale {nr++;b[nr]=a[i]; }
spectacolelor sunt numere naturale }
mai mici decât 1000000 int main()
pentru fiecare spectacol, X < Y {citire();
dacă momentul de început al unui ord();
spectacol şi momentul de sfârşit al formare();
altui spectacol coincid, pot fi g<<nr;
urmărite ambele spectacole return 0;
}
#2271 ProdMax1
Cerinţa: Se dă un şir
cu n numere întregi.
Determinaţi cel mai mare
număr care poate fi scris
ca produs de două
elemente ale şirului.
Date de intrare:
Programul citeşte de la
tastatură numărul n, iar
apoi cele n elemente ale
şirului.
Date de ieşire:
Programul va afişa pe
ecran numărul
determinat P.
Restricţii şi precizări:
1 ≤ n ≤ 100000
elementele şirului vor fi
cuprinse în intervalul (-
1000000, 1000000)
#include <iostream>
#include <algorithm>
using namespace std;
int n,v[100001];
int main()
{cin>>n;
for(int i=1;i<=n;i++)
cin>>v[i];
sort(v+1,v+n+1);
if((v[1]*v[2])>(v[n-
1]*v[n]))
cout<<v[1]*v[2];
else
cout<<v[n-1]*v[n];
return 0;
}
#403 Concert
Enunt: Gigel este un cântăreţ începător. El ştie deja să cânte n melodii, şi pentru fiecare melodie se
cunoaşte durata, exprimată în minute şi secunde. Gigel va participa la o emisiune de televiziune, unde va putea
cânta timp de T secunde. El vrea să cânte cât mai multe melodii, pentru a-şi demonstra talentul deosebit.
Ajutaţi-l să aleagă piesele pentru emisiune, şi vă va răsplăti cu un autograf.
Date de intrare: Fişierul de intrare concert.in conţine pe prima linie numerele n T. Fiecare dintre
următoarele n linii conţine durata unei melodii, în formatul m:s, unde m şi s pot avea una sau două cifre.
Date de ieşire: Fişierul de ieşire concert.out va conţine pe prima linie numărul M, reprezentând
numărul maxim de melodii care pot fi alese. Următoarea linie va conţine M numere între 1 şi n, reprezentând
numărul de ordine al melodiilor alese, aşa cum sunt ele date în fişierul de intrare.
Restricţii şi precizări : 1 ≤ n ≤ 100
1 ≤ T ≤ 1000
0 ≤ m ≤ 10
0 ≤ s ≤ 59

#include<fstream> a[i]=a[j];
#include <cstring> a[j]=aux;
#include <iostream> }
using namespace std; }
ifstream f("concert.in"); void greedy()
ofstream g("concert.out"); { int i=1;m=0;
int n,T,m; while(i<=n&&T>a[i].t)
char s[20]; { m++;b[m]=a[i];
struct concert {int nr, t; } T=T-a[i].t;
a[1001],aux,b[1001]; i++;
void citire() }
{ f>>n;f>>T; }
for(int i=1;i<=n;i++) void afis()
{ f>>s; {g<<m<<endl;
a[i].t=0; for(int i=1;i<=m;i++)
int j=0; g<<a[i].nr<<' ';
while(j<strlen(s)&&s[j]!=':') }
{a[i].t=a[i].t+(s[j]-48)*60; j++;} int main()
j++; {citire();
a[i].t=a[i].t+(s[j]-48)*10+(s[j+1]-48); sort();
a[i].nr=i;} greedy();
} afis();
void sort() f.close();
{int i,j; g.close();
for(i=1;i<=n;i++) return 0;
for(j=i+1;j<=n;j++) }
if(a[i].t>a[j].t)
{ aux=a[i];