#91 Masini

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

de 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
Enunt:La un birou care se #include <iostream>
ocupă cu analiza proiectelor de #include<fstream>
investiţii, n investitori au depus
using namespace std;
până la termenul legal, câte un
proiect. ifstream f("proiecte.in");
ofstream g("proiecte.out");
Cerinţa : Cunoscând timpul
int n,i,j;
necesar pentru analizarea fiecărui
proiect, scrieţi un program care struct proiecte{int t,o;}v[1001];
determină ordinea în care vor fi void citire()
analizate proiectele, astfel încât { for(int i=1;i<=n;i++)
timpul mediu de aşteptare pentru {f>>v[i].t; v[i].o=i;}}
investitori să fie minim. ordonare()
Date de intrare : Pe prima {for(i=1;i<=n;i++)
linie a fişierului proiecte.in se for( j=i+1;j<=n;j++)
găseşte un număr natural n if(v[i].t>v[j].t)
reprezentând numărul de proiecte { proiecte aux=v[i];
depuse. Pe linia a doua, separate
v[i]=v[j];
prin câte un spaţiu, se găsesc n
numere naturale t1, t2, …, tn, v[j]=aux;
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>
Cerinţa :De-a lungul
principalei străzi din orașul nostru using namespace std;
există n plopi, pentru fiecare ifstream f("plopi2.in");
cunoscându-se înălțimea. Primarul ofstream g("plopi2.out");
orașului dorește ca plopii să aibă
înălțimile în ordine descrescătoare.
int n,a[101],nr,l;
Pentru aceasta, este posibilă tăierea void citire()
dintr-un plop a unei bucăți – este o { f>>n;
tehnică ecologică, nevătămătoare,
for(int i=1;i<=n;i++) f>>a[i];
în urma căreia plopul nu are de
suferit. Plopii nu pot fi înălțați în }
niciun fel. Determinați numărul void greedy()
minim de plopi din care se va tăia și { for(int i=2;i<=n;i++)
lungimea totală minimă a bucăților
tăiate.
if(a[i]>a[i-1])
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
ieșire plopi2.out va conține pe prima
{citire();
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
bucăților tăiate. g.close();
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ă {for(int i=1;i<n;i++)
câte 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];