Antrenament 10-20

PINTESCU Alina, KALMAR Violeta-Mihaela
INFORMATICĂ
Auxiliar 2 - Rezolvări propuse pentru
Simulările de bacalaureat la informatică C++,
variantele 10 – 20 și subiectul din iunie 2020
ISBN 978-973-0-32127-2
Baia Mare
2020
PINTESCU Alina, KALMAR Violeta-Mihaela
COLEGIUL NAȚIONAL ”GHEORGHE ȘINCAI” BAIA MARE
INFORMATICĂ
Auxiliar 2 - Rezolvări propuse pentru
Simulările de bacalaureat la informatică C++,
variantele 10 – 20 și subiectul din iunie 2020
Baia Mare
2020
Cuprins
Simulare 11 - prof. Pintescu Alina ....................................................... 2
Simulare 14 - prof. Kalmar Violeta.................................................... 11
Simulare 15 - prof. Pintescu Alina ..................................................... 15
Subiectul dat în 25 iunie 2020 - prof. Pintescu Alina ........................ 40
Resurse web ……………………………………………………… 46

Simulare
11
REZOLVARE PROPUSĂ DE
PROF. ALINA PINTESCU
• Toate subiectele sunt obligatorii. Se acordă 10 puncte din oficiu.

• Timpul de lucru efectiv este de 3 ore.
• Identificatorii utilizaţi în rezolvări trebuie să respecte precizările din enunţ (bold), iar în lipsa unor
precizări explicite, notaţiile trebuie să corespundă cu semnificaţiile asociate acestora (eventual în formă
prescurtată). Datele de intrare se consideră corecte, validarea lor nefiind necesară.
• În grafurile din cerințe oricare arc/muchie are extremități distincte și oricare două arce/muchii diferă prin
cel puțin una dintre extremități.
SUBIECTUL I (20 de puncte)
Pentru fiecare dintre itemii de la 1 la 5, scrieţi pe foaia de examen litera corespunzătoare
răspunsului corect. Fiecare răspuns corect se notează cu 4 puncte.
Răspuns: d
d) x<=2019 && y>=2019 && y<=2020
Răspuns: d
Răspuns: a
f(2020,2) = 1 + f(1010,2) = 1 + 1 + f(505,2) = 2 + 2020 = 2022
Răspuns: b
Propoziț ie: Un arbore cu n vârfuri are n-1 muchii.
Răspuns: c
4
SUBIECTUL al II-lea (40 de puncte)
a) Răspuns corect: 10
b) Se acordă câte 2p. pentru fiecare dintre cele trei numere conform cerinţei (1000 1100
1110 1111).
c) d)
citeşte n (număr natural)
m0
┌dacă n=0 atunci
│ m10
│altfel
│ cn%10; n[n/10] //nu e oblig
│┌dacă c≥m atunci
││ mc
││altfel
││ m10
│└■
│┌cât timp n≠0 execută
││ cn%10; n[n/10]
││┌dacă c≥m atunci
│││ mc
│││altfel
│││ m10
││└■
│└■
└■
scrie m
struct sera
{ int numar;
struct [denumiri]
{
char denumireStiintifica[21];
char denumirePopulara[21];
} specie[100];
} s;
p=1;
for(i=1; i<=7; i++)
p=p*a[i][i];
for(i=7; i>=1; i--)
{ cout<<p <<' ';
p=p/a[i][i]; }
5
SUBIECTUL al III-lea (30 de puncte)
Metoda 1 Metoda 2
void patrate(int x, int y)
#include <cmath>
{int ok=0,i=1,s=0;
void patrate(int x, int y)
while (i*i<y){
{
if(i*i>=x){
int i,s=0,ok=0;
cout<<i*i;
for(i=x;i<=y;i++)
s=s+i*i;
if(sqrt(i)*sqrt(i)==i)
if((i+1)*(i+1)<=y) cout <<"+";
{cout<<i; s=s+i;
else cout << "=" << s;
if(i<y-1) cout<<'+';
ok=1; }
ok=1;
i++;
}
}
if(ok==0) cout<<”nu exista”;
if(ok==0) cout<< "nu exista";
else cout<<'='<<s;}
}
a b
Am citit pe rând numerele din fișier. Am salvat în ante
#include <iostream>
numărul precedent citirii și am citit în variabila x
#include <fstream>
numărul curent. Am verificat dacă numărul curent este
using namespace std;
egal cu numărul anterior, iar în caz afirmativ un contor k
ifstream fin("bac.txt");
crește, în caz contrar contorul k se modifică/actualizează
int main()
și devine 1. Înainte de a reseta contorul se afișează
{int x,k,ante;
numărul citit și de câte ori a apărut consecutiv în șirul
fin>>ante;
citit.
k=1;
Rezolvarea propusă este eficientă dpdv al memoriei
while(fin>>x)
deoarece am folosit un număr minimal de valori posibile
{if(x==ante) k++;
(3 variabile simple) și este eficientă dpdv al timpului
else
de executare deoarece algoritmul este de complexitate
{ cout<<ante<<' '<<k<<' ';
liniară [O(n) unde n=nr de nr citite] – adică la o singură
k=1; }
parcurgere a valorilor se oferă soluția dorită. Am folosit
ante=x;
faptul că numerele citite erau date sub forma unui șir
}
crescător, fiind astfel posibilă afișarea rezultatului
cout<<ante<<' '<<k; return 0;}
obținut conform cerinței, printr-o singură parcurgere.
6
12
Simulare

Răspuns: d
d) x*(y-20)>0
{ {
Răspuns: a
b) și d) nu sunt tablou bidimensional

c) are 2x40 = 80 elemente
Răspuns: b
Răspuns: b
Răspuns: c
7

b) Se acordă câte 2p. pentru fiecare dintre cele trei numere conform cerinţei (oricare
dintre numerele 2000 2002 2020 2022 2200 2202 2220).
c) d)
citește n (număr natural nenul)

nr0
┌pentru c9, 0, -1 execută
│ mn
│┌cât timp m≠0 și m%10≠c execută
││ m[m/10]
│└■
│┌dacă m≠0 atunci
││ nrnr*10+m%10
│└■
└■
scrie nr
struct flori
{ int cod;
int nrVarietati;
int nrExemplare[10];
} f[20];
Răspuns corect:
12456 – antepenultima val

13456 – penultima val
23456 – ultima val
8
a b
#include <iostream>
#include <fstream> Am citit de la tastatură numărul de la acre dorim să
using namespace std; înceapă afișarea, apoi, pe rând, conform regulei date
ofstream fout("bac.out"); vom afișa numerele în fișier.
int x; Dacă numărul citit este par, pentru a obține valoarea
int main() următoare de afișat vom înjumătăți pentru a continua
{ cin>>x; afișările, iar dacă este valoare impară, vom scădea câte
if(x%2==0 && x>10) un element pentru șir conform cerinței, și, tot așa până
{ fout<<x<<' '; la valoarea 11. De la valorile 10 la valoarea 1 se vor
x=x/2; } afișa numerele conform regulii date (în ordine
while(x>10) descrescătoare, valorile consecutive).
{ fout<<x<<' '<<x-1<<' ';
x=x/2; Rezolvarea propusă este eficientă dpdv al memoriei
} deoarece am folosit un singur număr (o variabilă
while(x>=1) simplă) și este eficientă dpdv al timpului de
{ fout<<x<<' '; executare deoarece algoritmul este de complexitate
x--; logaritmică [ O(log n) unde n = nr dat] – adică
} afișările cerute se vor face împărțind succesiv numărul
fout.close(); dat.
return 0;
}
9
13
Simulare

Răspuns: a
a) n%4==0 && n%5==0
Răspuns: d
f(200200) = 2 * f(20020) = 2 * 2 * f(2002) = 2 * 2 * 2 * f(200) = 2 * 2 * 2 * 2 * f(20)

= 16 * 20 = 320
Răspuns: a
5 7 5 7 5 7 5 7
5 5 5 6 6 7 7 7 8 8 5
5 5 5 5 5 5 5 5 5 5 5 6
1 2 3 4 5 6 7 8 9 10 11 12
Răspuns: c
Graful G se numește graf complet dacă oricare două vârfuri distincte ale sale sunt adiacente.
Răspuns: b
Un subgraf al grafului G, se obține ştergând eventual anumite vârfuri şi odată cu acestea şi
muchiile care le admit ca extremitate (nu se pot şterge toate vârfurile deoarece s-ar obține un
graf cu mulțimea vârfurilor vidă).
Pentru n=6 noduri un graf complet are m=6*5/2=15 muchii
Deci, dacă am elimina doar nodul 7 (cu muchiile aferente) ar putea rămâne un graf complet
cu 6 noduri.
10

n=12345, deci se citesc câte cifre are numărul n citit (are 5 cifre, deci vor fi 5 citiri)
x = 25 (n=12345) x=2070 (n=1234) x= 49 (n=123) x=270135 (n=12) x=21(n=1)
k=0 k=1 k=2 k=3 k=4
5 7 3 0 1
b) Se acordă câte 2p. pentru fiecare număr conform cerinţei (un set are trei numere din
intervalul cerut, a, b și c unde a are cifra unităților 0, b are cifra zecilor 1, iar c are cifra
sutelor 0).
c) d)
citeşte n (număr natural)
p1; m0; k0
┌cât timp n≠0 execută
│ citește x (număr natural)
│ //nu tb ik
│ x[x/p] // x[x/(10^k)]
│┌dacă x=0 atunci cn%10
││altfel cx%10
│└■
│ mc*p+m; n[n/10]
│ pp*10; kk+1
└■
scrie m
struct cerc
{ float raza;
struct [coordonate]
{float x,y;} centru;
} c;
Răspuns corect:
ou
rosu
11
void putere(int n, int &d, int &p)
{int kp,dmin=n; d=2;p=1;
while(n!=1)
{kp=0;
while(n%d==0)
{ kp++; n=n/d; }
if(kp<=p && kp!=0)
{ p=kp;
if(d<dmin)
dmin=d; }
d++; }
d=dmin; }
Metoda 1 Metoda 2 Metoda 3

#include <iostream> for(int i = 1; i <= n * k; i++) for(int i = 0; i < n; i++)
using namespace std; { for(int j = 1; j <= n; j++) for(int j = 0; j < n; j++)
int a[401][21],n,k,i,j,x; { a[i][j] = j + x; } for(int L = 0; L < k; L++)
int main() contor++; a[i*k+L][j] = i + j + 1;
{ cin>>n>>k; if(contor == k)
for(i=1; i<=n*k; i++) { x++; contor = 0; }
{ for(j=1; j<=n; j++) }
a[i][j]=j+(i-1)/k; }
for(i=1; i<=n*k; i++)
{ for(j=1; j<=n; j++)
cout<<a[i][j]<<' ';
cout<<endl; }
return 0;}
a b
#include <iostream> Am citit de la tastatură numărul de la care dorim să înceapă
#include <fstream> afișarea (valoare care se știe că este un termen al șirului), apoi, pe
using namespace std; rând, conform regulei date vom afișa numerele în fișier. Pentru a
ofstream fout("bac.txt"); obține valoarea următoare de afișat vom înjumătăți pentru a
int x; continua afișările, și, tot așa până după afișarea valorii 1.
int main() Rezolvarea propusă este eficientă dpdv al memoriei deoarece am
{ cin>>x; folosit un singur număr (o variabilă simplă) și este eficientă dpdv
while(x>=1) al timpului de executare deoarece algoritmul este de
{ fout<<x<<' '; x=x/2; } complexitate logaritmică [ O(log n) unde n = nr dat] – adică
fout.close(); return 0;} afișările cerute se vor face împărțind succesiv numărul dat.
12
14
Simulare
PROF. VIOLETA KALMAR
Răspuns: a
!(x<-2020 || x>2020)  x>=-2020 && x<=2020
Răspuns: c
f(2020,20)=f(101,2000)
=f(0,-1899) = -1899
Răspuns: b
Dacă numerotăm
elementele mulțimii de
la 1..8, o soluție va
avea elementele
crescătoera (nu
contează ordinea
accesoriilor- modelul
combinărilor) și suma
costurilor exact 500
Răspuns: c
Exact 3 valori din
intervalul 1..6 nu
trebuie să se regăsească
în vectorul de tați
Răspuns: a
13

Algoritmul dat formează și afisează un numar în care pune pe rănd, începând de la cifra unităților
cifrele 1 în loc de 9, cifră+1 dacă cifra e impară, cifra din numărul dat dacă e cifră pară
b) Răspuns corect: o soluție poate fi 9, 90, 900 – Orice număr care conține doar o cifră 9 și
cifre de 0 (orice număr de forma 9*10k)
c) d)
citește n (număr natural)
m0
┌cat timp n≠0 executa
│ cn%10; n[n/10]
│┌dacă c=9 atunci c1
││altfel
││┌dacă c%2=1 atunci
│││cc+1
││└■
│└■
│ mm*10+c
└■
scrie m
Obs.
Dacă n=0 nu se execută niciodată instrucțiunea
cat timp..execută deci m=0.
În cazul variantei inițiale se extrage c=0 din n și
m=0*10+0=0, după care se incheie
instrucțiunea repetă...până când și m rămâne 0
struct rasa
{int cod, nrExemplare;
int varsta[10];
} r[20];
Răspuns:
for(j=0;j<7; j++)
a[0][j]=1;
for(i=0;i<5; i++)
sau for(i=0;i<5; i++) a[i][6]=1;
for(j=6;j>=0; j--) for(i=1;i<5; i++)
if(i==0 || j==6) a[i][j]=1; for(j=5;j>=0; j--)
else a[i][j]=(a[i][j+1]+a[i-1][j])%10; a[i][j]=(a[i][j+1]+a[i-1][j])%10;
14
Metoda 1 Metoda 2
#include <iostream>
#include <cstring>
int main()
{ char s[101];
int i;
cin.getline(s,101);
for(i=0;i<strlen(s);i++)
if(s[i]=='-')
{ strcpy(s+i,s+i+1); i--;}
cout << s;
return 0;
}
15
a b
O soluție posibilă parcurge șirul din fișier și

memorează cele mai mici trei numere cu
proprietatea cerută în trei variabile, fie acestea
min1, min2, min3 (min1<min2<min3); fiecare
termen curent citit se compară cu valorile
minime memorate, pe rând (min1, min2,
min3), iar acestea se actualizează după caz.
Eficiența rezolvării problemei dpdv al

memoriei datorită utilizării numai a unor
variabile simple (fără date structurate) iar
dpdv al timpului de executare eficiența
constă în faptul că este un algoritm liniar de
complexitate O(n) unde n=nr de numere citite
din fișier, parcurge fișierul o singură dată.
Metoda 2
#include <iostream>
#include <fstream>
ifstream fin ("bac.in");
int main()
{int n, mini1=INT_MAX, mini2=INT_MAX, mini3=INT_MAX;
while(fin>>n)
if(n%100==20)
{
if(n<mini1)
{ mini3=mini2;
mini2=mini1;
mini1=n; }
else
if(n<mini2)
{ mini3=mini2;
mini2=n; }
else
if(n<mini3) mini3=n;
}
cout << mini1<<' '<<mini2<<' '<<mini3;
}
16
15
Simulare

Răspuns:
b
x>=16 && x>=17 && x<=19 && x<=20 b).
Răspuns:
c
Răspuns:
a
Răspuns: C
Răspuns:
b
(2,1) și (4,3)
(2,3) și (4,5)
(4,3) si (2,3)
17
b) 28 29
c) d)
citește n (număr
natural)
nr0
in
┌cât timp i≥1 execută
│ x0; y1
│ ┌pentru j1,i
execută
│ │ r2*x-y; xy; yr
│ └■
│ ┌dacă y>0 atunci
│ │ nrnr+1
│ └■
│ii-1
└■
scrie nr
Se acordă câte 3p. pentru fiecare valoare conform cerinței

(pentru x1, valoarea 4, iar pentru x2 oricare dintre valorile 1, 2, 5, 10).
Dacă x1 = 1 atunci f(10,1)=0+f(9,1)=0+f(8,1) ....=0+f(1,1)=0+1=1
Dacă x1 = 2 atunci f(10,2)=0+f(8,2)=0+f(6,2) ....=0+f(2,2)=0+1=1
Dacă x1 = 3 atunci f(10,3)=1+f(7,3)=2+f(4,3) =3+f(1,3)=3+0+f(1,2)=3+0+f(1,1)=3+1=4
Dacă x1 = 4 atunci f(10,4)=2+f(6,4)=2+2+f(2,4) =4+0+f(2,2)=4+1=5

a[4][5]=1; for(i=0; i<4;i++)
for(j=0;j<5;j++) { a[i][0]=i+1;
for(i=0; i<4;i++)
for(i=0; i<4;i++) for(j=1;j<5;j++)
for(j=1;j<5;j++)
{a[i][j] = a[4][5]; a[i][j]=a[i][j-1]+4;
a[i][j]=4*j+i+1;
a[4][5]= a[4][5]+1;} }
a[4][5]= a[4][5]-1;
18
Metoda 1 Metoda 2
bool prim(int n)
{ int kd=0;
void divPrimMax(int n, int &p) for(int d=2;d<=n/2;d++)
{int d=2; if(n%d==0)
while(n!=1) kd++;
{if(n%d==0) if (kd==0)
{p=d; return 1;
while(n%d==0) else
n=n/d; return 0;
} }
d++; void divPrimMax(int n, int &p)
} { for(int d=2;d<=n;d++)
} if(n%d==0&&prim(d))
p=d;
}
#include <iostream>
#include <cstring>
int main()
{ char s[110], *p;
int nrv, nrc,i,nr=0;
cin.get(s,110);
p=strtok(s," ");
while(p!=0)
{ nrv=0; nrc=0;
for(i=0; i<strlen(p); i++) if(strchr("aeiou",p[i])!=0)
nrv++;
else
nrc++;
if(nrv==nrc)
nr++;
p=strtok(NULL," ");
}
cout<<nr;
return 0;
}
19
a b
#include <iostream> Indicații din barem
#include <fstream> O soluție posibilă generează numerele
using namespace std; cerute stabilind toate valorile posibile
ofstream g("bac.out"); pentru prima cifră, c1, pentru a treia cifră,
int main() c3, respectiv pentru a 6-a cifră, c6,
{int p1,p2,nr=1,v[10]={0},k=0,i,j; celelalte calculându-se direct pe baza
cin>>p1>>p2; celorlalte, având în vedere ordinea cerută
while(nr<=9) și încadrarea fiecărei cifre în intervalul
{if(p2/nr<=9&&p2%nr==0) [0,9] sau [1,9], după caz.
{v[k]=nr;
k++;
} Rezolvarea propusă este eficientă dpdv al
nr++; memoriei deoarece am folosit puține
} variabile (am stocat cifrele cerute conform
nr=1; cerinței într-un vector de apariții pt cifre)
while(nr<=9) și este eficientă dpdv al timpului de
{if(p1/nr<=9&&p1%nr==0) executare deoarece algoritmul este de
{for(i=0; i<=9; i++) complexitate constantă O(1) – adică
for(j=0;j<k;j++) afișările cerute se vor face după un nr
g<<(nr*10+p1/nr)*100000+i*111*100 constant de pași.
+v[j]*10+p2/v[j]<<endl;
}
nr++;
}
g.close();
return 0;}
Metoda 2
#include <iostream>
#include <fstream>
ofstream g("bac.out");
int a,b,c,d,e,p1,p2;
int main()
{ cin>>p1>>p2;
for(a=1; a<=9; a++)
{ if(p1%a==0&&p1/a<10)
{ b=p1/a;
for(c=0; c<=9; c++)
for(d=1; d<=9; d++)
if(p2%d==0&&p2/d<10)
{ e=p2/d; g<<a*1000000+b*100000+c*11100+d*10+e<<' ';
}}}
g.close();
}
20
16
Simulare

Răspuns:
b
Răspuns:
3 5 7 9 5 7 9 7 9 c
2 2 2 2 4 4 4 6 6
1 1 1 1 1 1 1 1 1
1 2 3 4 5 6 7 8 9
Răspuns:
b
Vârfurile: 1, 3, și 4
Răspuns:
c
Răspuns:
n=8 m=8*7/2 = 28 d
+1 32
9 noduri + 41 izolate ==== > 42 componente conexe
21

b) Se acordă câte 2p. pentru fiecare dintre cele trei numere conform cerinței
(oricare număr de forma i0pp sau cipp, unde i este o cifră impară,
p este o cifră pară nenulă, iar c o cifră nenulă).
c) d)
citește n,k
(numere naturale)
┌dacă k=0 atunci nr-1
│altfel
│ nr0
│ p1
│ cn%10; n[n/10] //nu e oblig
│┌dacă c%2=0 atunci
│││ nrnr+c*p; pp*10
│││altfel kk-1
│ cât timp n≠0 și k≠0 execută
││ cn%10; n[n/10]
││┌dacă c%2=0 atunci
│││ nrnr+c*p; pp*10
│││altfel kk-1
││└■
│└■
└■
scrie nr
Răspuns corect:
531
12345
Răspuns corect:
15bac2020
22
int nrDivPrimi(int n)
{int nr=0, d=2, nrd;
while(n!=1)
{nrd=0;
while(n%d==0)
{n=n/d;
nrd++;
}
if(nrd%2==1)
nr++;
d++;
}
return nr;
}
#include <iostream>
int main()
{int a[102][102]={0},n,m,i,j,
k=1;
cin>>n>>m;
for(i=n; i>=1; i--)
for(j=m; j>=1; j--)
{a[i][j]=k*k;
k=k+2;
}
for(i=1;i<=n;i++)
{for(j=1;j<=m;j++)
cout<<a[i][j]<<" ";
cout<<endl;
}
return 0;
}
23
a b
Interclasare
#include <iostream> #include <fstream> Citim primul șir într-un tablou v, al
using namespace std; doilea șir într-un tablou u și obținem
ifstream f("bac.in"); rezultatul aplicând algoritmul de
int v[1000001], u[1000001], i=1, j=1, n, m, ok, k1, k2; interclasare, având în vedere valoarea
int main()
curentă din primul șir, v, valoarea curentă
{ f>>m>>n;
for(i=1; i<=m; i++) f>>v[i]; din al doilea șir, u, precum și ultima
for( j=1; j<=n; j++) f>>u[j]; valoare afișată, ok; valoarea min(v,u) este
i=j=1; selectată dacă are paritatea diferită de ok.
if(v[i]<u[j]) La fiecare pas, se realizează avansul doar
{ cout<<v[i]<<" "; în șirul corespunzător minimului
ok=v[i]; menționat și se actualizează, după caz,
i++; } variabila ok.
else
{ cout<<u[j]<<" ";
ok=u[j]; Rezolvarea propusă este eficientă dpdv
j++; }
al timpului de executare deoarece
while(i<=m && j<=n)
{ k1=k2=0; algoritmul este de complexitate liniară
if(v[i]<u[j]) [ O(m n) unde n și m = nr de elem ale
{ if(ok%2!=v[i]%2) șirurilor date] – adică afișările cerute se
{ cout<<v[i]<<" "; vor face parcurgând alternativ cele două
ok=v[i]; șiruri.
i++; }
else i++;
}
else {if(ok%2!=u[j]%2)
{ cout<<u[j]<<" ";
ok=u[j];
j++; }
else j++;
}
}
while(i<=m)
{ if(v[i]%2!=ok%2)
{cout<<v[i]<<" ";
ok=v[i];}
i++; }
while(j<=n)
{ if(u[j]%2!=ok%2)
{cout<<u[j]<<" ";
ok=u[j];}
j++; } return 0;}
24
Rezolvare propusă de: Rezolvare propusă de:
eleva Iulia Ilieș elevul Florin Ciocan
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>
using namespace std; using namespace std;
ifstream f("bac.in"); ifstream f("bac.in");
int main() int main()
{ int m, n, v[1000005]= {0}, i, x, j=1, k, minn; 1. {{int n, m, i, j, a[1000001], b, c;
f>>m>>n; 2. f >> n >> m;
for(i=1; i<=m; i++) 3. for(i = 0; i < n; i++)
f>>v[i]; 4. f >> a[i];
i=1; 5. i = j = 0;
f>>x; 6. f >> b;
if(v[i]<=x) 7. c = min(a[i], b);
k=(v[i]+1)%2; 8. if(a[i] < b)
else 9. { cout << a[i] << ' ';
k=(x+1)%2; 10. c = a[i];
while(i<=m&&j<=n) 11. i++; }
{ 12. else
if(v[i]<x) 13. { cout << b << ' ';
{ 14. c = b;
minn=v[i]; 15. if(m > 1) f >> b;
i++; 16. j++;
} 17. }
else 18. while(i < n && j < m)
{ 19. {
minn=x; 20. if(a[i] < b)
f>>x; 21. { if((a[i] + c) % 2 && a[i] != c)
j++; 22. { cout << c << ' ';
} 23. c = a[i];
if(minn%2!=k) 24. }
{ 25. i++;
cout<<minn<<" "; 26. }
k=minn%2; 27. else
} 28. { if((b + c) % 2 && b != c)
} 29. { cout << c << ' ';
if(i<=m) 30. c = b; }
for(j=i; j<=m; j++) 31. f >> b;
if(v[j]%2!=k) 32. j++;
{ 33. }
cout<<v[j]<<" "; 34. }
k=v[j]%2; 35. while(i < n)
} 36. {
if(j<=n) 37. if((a[i] + c) % 2 && a[i] != c)
for(i=j; i<=n; i++) 38. { cout << a[i] << ' ';
{ 39. c = a[i]; }
if(x%2!=k) 40. i++;
{ 41. }
cout<<x<<" "; 42. while(j < m)
k=x%2; 43. { if((b + c) % 2 && b != c)
} 44. { cout << b << ' ';
f>>x; 45. c = b; }
46. f >> b;
} 47. j++;
return 0;} 48. }}
25
17
Simulare

Răspuns:
d
Răspuns:
d
Răspuns:
b
T T H S TK T
H S T T T TK
M M M M M M
1 2 3 4 5 6
Răspuns:
a
Nodurile care nu apar în vector sunt frunzele: 1, 2, 3, 4
Răspuns:
b
26
b) Răspuns corect:
1 9 sau 2 8 sau 10 10
c) d)
citește x,y
(numere naturale x≤y)
ix; jy; s0
citește x,y ┌repetă
(numere naturale x≤y) │┌dacă i%2=0 atunci
s0 ││ ss+j
┌pentru i x,y,+1 execută │└■
│┌dacă i%2=0 atunci │┌dacă j%2=0 atunci
││ ss+i ││ ss+i
│└■ │└■
└■ │ii+1; jj-1
scrie s └până când i>j
scrie s
struct data
{int zi,luna;}
struct obiectiv
{int cod;
data dataInceput, dataFinal;
}ob;

a[3][4]=1;
for(j=0;j<5;j++) for(i=2;i>=0;i--)
for(i=0;i<4;i++) a[i][4]= a[i+1][4]+1;
a[i][j]=4*(5-j)-i; for(j=3;j>=0;j--)
for(i=0;i<4;i++)
a[i][j]= a[i][j+1]+4;
27
int maxim(int n)
{int maxx=-1, c;
while(n!=0)
{c=n%10;
n=n/10;
if(c%2==1&&c>maxx)
maxx=c;
}
return maxx;
}
#include <iostream>
#include <cstring>
char s[205],*p,t[205];
int i, ok, ok2;
int main()
{cin.get(s,205);
p=strtok(s," ");
while(p!=0)
{ok=1;
for(i=0;i<strlen(p);i++)
if(strchr("aeiou",p[i])==0)
ok=0;
strcat(t,p);
strcat(t," ");
if(ok==1)
{ strcat(t,p);
strcat(t," ");
ok2=1;
}
p=strtok(NULL," ");
}
t[strlen(t)-1]='\0';
strcpy(s,t);
if(ok2==0)
cout<<"nu exista";
else
cout<<s;
return 0;
}
28
a b
#include <iostream> O soluție posibilă memorează termenii
#include <fstream> primului șir într-un tablou unidimensional (v)
using namespace std; și determină numărul cerut (nr) pe măsura
ifstream f("bac.txt"); citirii celorlalte valori din fișier: pentru fiecare
int main() pereche (x,y) citită din fișier, verifică dacă x se
{int n,v[10005]={0},x,y,st,dr,mijl,i, ok, nr=0; află în tabloul v, utilizând metoda căutării
f>>n; binare; dacă st și dr reprezintă cele două
for(i=1; i<=n; i++) valori care delimitează secvența curentă
f>>v[i]; specifică metodei, atunci, dacă x nu aparține
while(f>>x&&f>>y) tabloului (st>dr), iar y<v[st], se incrementează
{st=1; dr=n; nr.
ok=0;
while(st<=dr&&ok==0)
{mijl=(st+dr)/2;
if(x==v[mijl])
ok=1;
else
{if(x<v[mijl])
dr=mijl-1;
else
st=mijl+1;
}
}
if(ok==0)
if(y<v[st])
nr++; Rezolvarea propusă este eficientă dpdv al
} timpului de executare deoarece algoritmul
cout<<nr; este de complexitate liniară [ O( n+m * ln(b-
f.close(); return 0; } a+1) ) unde n=nr de nr date și m = nr de
intervale, a si b sunt capete de intervale citite].
int n, a, b,ap[10005]={0},k =0,i,x;
fin >> n;
for(i = 0; i < n; i++)
{ fin >> x;
ap[x]++; }
for(i = 1; i < 10005; i++)
ap[i] = ap[i] + ap[i-1];
while (fin >> a >> b)
if(ap[a-1] == ap[b])
k++;
cout << k;
29
18
Simulare

Răspuns:
d
Răspuns:
c
Răspuns:
a
Răspuns: d
Răspuns: b
Teorie: Pentru G un graf orientat cu n vârfuri şi m arce - numărul de

grafuri parţiale ale lui G este 2m.
30
a) Răspuns corect: 3 2 1 1 2 3 2 1 1 2
b) Se acordă câte 3p. pentru fiecare dintre cele două seturi conform cerinței
(orice pereche de forma x, x+19 din intervalul cerut).
c) d)
#include <iostream> citește n,k
using namespace std; (numere naturale nenule)
int main() i1
{ int n,k,i,j; ┌cât timp i≤n execută
cin>>n>>k; │┌pentru jk,1,-1 execută
for (i=1; i<=n; i++) ││ scrie j,' '
{ for (j=k; j>=1; j--) │└■
cout<<j<<" "; │┌pentru j1,k execută
for (j=1; j<=k; j++) ││ scrie j,' '
cout<<j<<" "; │└■
k=k-1; │ kk-1
} │ ii+1
return 0; └■
}
Se acordă câte 3p.
pentru fiecare valoare
conform cerinței:
f(23575209)= 1+f(235752)= 1+0+f(2357) = 1+0+1+f(235) = f(0)=0
1+0+1+1+f(2) = 1+0+1+1+0 = 3 f(23575209)=3
Răspuns corect:
4 2
31
void suma(int n, int &s)
{ int v[10]={0}; s=0;
while (n>0)
{ v[n%10]=1; n=n/10; }
for (int i=2;i<=8;i=i+2)
if (v[i]>0) s=s+i;
}
#include <iostream> #include <bits/stdc++.h>

#include <cstring> using namespace std;
#include <iostream>
using namespace std; bool verificare (char p[],
#include <cstring>
char cuv[25], s[21][25]; char sufix[])
int n,k,i,ok,x,c,st; { int l1=strlen(p);
bool test(char cuv[30],char suf[30])
int main() int l2=strlen(sufix);
{
{ cin>>n>>k; if (l1<=l2) return 0;
while(strlen(cuv)>strlen(suf))
cin.get(); for (int i=0; i<l2; i++)
strcpy(cuv,cuv+1);
for(i=1;i<=n;i++) if (sufix[i]!=p[l1-l2+i])
if(strcmp(cuv,suf)==0)
{ cin.getline(cuv,25); return 0;
return 1;
strcpy(s[i],cuv); return 1;
else
} }
return 0;
for(i=1;i<=n;i++) int main()
}
{ if(i!=k) { int n,k,gasit=0;
int main()
{x=strlen(s[k])-1; char cuvant[25],
{
c=strlen(s[i])-1; s[500]="",sufix[25];
int n,k,i,ok=0;
st=0; cin>>n>>k;
char s[30][30], cuv[30];
while(x>=0 && st==0) for (int i=1; i<k; i++)
cin >> n >> k;
{ { cin>>cuvant;
cin.get();
if(s[i][c]!=s[k][x]) strcat(s,cuvant);
for(i=1; i<=n; i++)
st=1; strcat(s," "); }
cin.getline(s[i],30);
x--; c--; cin>>sufix;
for(i=1; i<=n; i++)
} for (int i=1; i<=n-k; i++)
if(i!=k)
if(st==0) { cin>>cuvant;
{
{ strcat(s,cuvant);
strcpy(cuv,s[i]);
ok=1; cout<<s[i]<<" "; strcat(s," "); }
if(test(cuv,s[k]))
} char *p=strtok(s," ");
{
} while (p!=NULL)
cout << s[i] <<' ';
} { if (verificare(p,sufix))
ok=1;
if(ok==0) { cout<<p<<" ";
}
cout<<"nu exista"; gasit=1;
}
return 0; }
if(ok==0)
} p=strtok(NULL," ");
cout <<"nu exista";
}
return 0;
if (gasit==0) cout<<"nu
}
exista";
return 0;}
32
a b
#include <bits/stdc++.h> Am inițializat lungimemax=0 (lungimea
using namespace std; maximă de numere consecutive care sunt
divizbile cu 10), lungimeaux=0 (lungimea de
ifstream fin("bac.txt");
numere consecutive divizibile cu 10 la
int main() momentul actual) și repetări=1 (numărul de
{ int n, lungimemax=0, lungimeaux=0, secvențe de lungime maximă, este 1 deoarece
repetari=1; știm sigur că există măcar o secvență).
while (fin>>n) Citim numerele n din fișier. Dacă n este
{ if (n%10==0) divizibil cu 10, creștem lungimeaux, în caz
contrar, lungimeaux=0 (pentru că am dat de
lungimeaux++;
un număr care nu e divizibl cu 0, deci
else secvența noastră de numere consecutive
lungimeaux=0; divizibile cu 10 are în momentul actual
if (lungimeaux==lungimemax && lungimea 0). Dacă lungimeaux=lungimemax,
lungimeaux>0) repetari++; creștem repetările, deoarece am mai dat de o
if (lungimeaux>lungimemax) secvență cu lungimea egală cu lungimea
maximă.
{
În cazul în care lungimemax>lungimeaux,
lungimemax=lungimeaux; înseamnă că am găsit o secvență mai lungă de
repetari=1; numere consecutive divizibile cu 10. Astfel,
} numărul repetărilor devine 1, iar lungimemax
} preia valoarea lungimii auxiliare.
cout<<lungimemax<<" "<<repetari; La final, afișăm lungimemax, iar la un spațiu
distanță, repetari.
return 0;
} Rezolvarea propusă este eficientă din punct
de vedere al memoriei deoarece nu ne-am
folosit de vectori, am folosit un număr
minimal de variabile: 4.
Rezolvarea este eficientă din punct de

vedere al timpului de executare deoarece
algoritmul este linear de complexitate liniară
[O(n), unde n = numărul elementelor citite],
adică, la o singură parcurgere a valorilor
(chiar în momentul în care sunt citite),
programul afișează răspunsul dorit.
33
19
Simulare

Răspuns:
d
Răspuns:
b
f(10,20) = 1+f(9,f(10,10))
f(10,10)=1+f(9,f(10,0)) { f(10,0)=0 } =1+ f(9,0) { f(9,0)=0 } =1
Im T S V Im T S
W W In In W W In
N N N N M M M Răspuns:
M M M M N N N a
C C C C C C C
1 2 3 4 5 6 7
Răspuns:
c
Răspuns:
Într-un graf neorientat, se numește lanț hamiltonian un lanț c
elementar care conține toate vârfurile grafului.
Într-un graf neorientat, se numește ciclu hamiltonian un
ciclu elementar care conține toate vârfurile grafului.
Un graf neorientat se numește graf hamiltonian dacă conține un
ciclu hamiltonian.
34

b) Se acordă câte 2p. pentru fiecare dintre cele trei numere conform cerinței
(oricare dintre numerele 77, 78, 87, 88)
c) d)
#include <iostream>
int main() citește n (număr natural nenul)
{int n,c; ┌cât timp n≠0 execută
cin>>n; │ cn%10; n[n/10]
while(n!=0) │┌dacă c%2≠0 atunci
{ c=n%10; ││ cc+1
n=n/10; │└■
if(c%2!=0) │ dacă c>0 și c<10
c++; │┌repetă
while(c>0 && c<10) ││ scrie c
{ cout << c; ││ cc*2
c=c*2; } │└ până când c≤0 sau c≥10
} └■
return 0;
}
struct proiect
{ char tema[21];
int nrSurse;
char denAdrSursa[10][100];
}p;
Răspuns corect:
nnfrrmmtii
35
void paritate(int n, int &nr)

{ nr=0;
for(int d=1; d<=n;d++)
if(n%d==0 && n%2==d%2)
nr++;
}
#include <iostream>
int a[21][21],n,m,k,i,j,ok=0;
int main()
{ cin>>m>>n>>k;
for(i=1; i<=m; i++)
for(j=1; j<=n; j++)
cin>>a[i][j];
for(i=1; i<=m; i++)
if(i!=k)
{ int ok1=1;
for(j=1; j<=n; j++)
if(a[i][j]==a[k][j])
ok1=0;
if(ok1==1)
ok=1;
}
if(ok==1)
cout<<"DA";
else
cout<<"NU";
return 0;
}
36
a b
#include <iostream> Am parcurs șirul din fișier, memorând

#include <fstream> valoarea curentă (x) și valoarea anterioară
using namespace std; acesteia (nrafisat); la întâlnirea unei
ifstream fin("bac.txt"); valori x diferită de nrafisat, se afișează x,
int x,nrafisat=-1; dacă aceasta este pară, și se actualizează
int main() corespunzător variabila nrafisat. În
{while(fin>>x) funcție de valoarea finală a variabilei
if(x%2==0 && x!=nrafisat) nrafisat, respectiv dacă ea rămâne
{ nemodificată, se afișează mesajul conform
cout<<x<<' '; cerinței pentru această situație: nu
nrafisat=x; exista.
}
if(nrafisat==-1)
cout << "nu exista" ; Rezolvarea propusă este eficientă din punct
fin.close(); de vedere al memoriei deoarece nu ne-am
return 0; folosit de vectori, am folosit un număr
} minimal de variabile: 2.

adică, la o singură parcurgere a valorilor
(chiar în momentul în care sunt citite),
programul afișează răspunsul dorit.
37
20
Simulare

Răspuns:
b
Răspuns:
d
Pa S Pa Pa Pa S
T Pa S T Pe Pa
S T T Pe T Pe
Pe Pe Pe S S T
L L L L L L
C C C C C C Răspuns:
1 2 3 4 5 6 c
Răspuns:
b
Răspuns:
b
38
b) Răspuns corect: 8, 81
c) d)
citește n
(număr natural nenul)
d1; s0
dacă d*d<n atunci
┌repetă
│┌dacă n%d=0 și d%2≠[n/d]%2 atunci
││ ss+d+[n/d]
│└■
│ dd+1
└până când d*d≥n
┌dacă d*d=n atunci ss+d
└■
scrie s
struct prajitura
{ int numar;
struct [nume]
{int cod;
int cantitate;
}ingredient[25];
}p;
for(i=0;i<7;i++)
for(j=0;j<7;j++)
if(i+j<6 && j>i) || (i+j>6 &&i>j)
a[i][j]=’a’;
else
a[i][j]=’b’;
{ a[i][j]=’b’;
if(i+j<6 && j>i) || (i+j>6 &&i>j)
a[i][j]=’a’;
}
39
int transformareBaza10(int b, int n)
{ int s=0, c, p=1;
while(n!=0)
{ c=n%10; n=n/10;
s=s+c*p;
p=p*b; }
return s;
}
#include <iostream>
#include <cstring>
char s[105], *p, t[105], c[105];
int i, ok;
int main()
{ cin.getline(s,105);
p=strtok(s," ");
while(p!=0)
{ if(strchr(p,',')!=0)
{ ok=0;
i=0;
while(i<strlen(s)&&ok==0)
{if(p[i]==',')
ok=1;
i++;
}
i--; // p[i]= '\0';
if(ok==1)
{ strncpy(c,p,i);
strcpy(p,c); }
}
strcat(t,p);
strcat(t," ");
p=strtok(NULL," ");
}
t[strlen(t)-1]='\0';
strcpy(s,t);
cout<<s;
return 0;
}
40
a b
#include <iostream>
#include <fstream> O soluție posibilă parcurge șirul din fișier,
using namespace std; memorând valoarea curentă (m), valoarea
ifstream f("bac.txt"); anterioară (n), suma secvenței curente (s) și
int n, m, s=0, smax=-1; suma maximă (smax); la fiecare pas, dacă
int main() valorile n și m au aceeași paritate, atunci n
{ f>>n; se adună la suma curentă, iar altfel se
s=n; smax=n; inițializează suma curentă cu valoarea n.
while(f>>m) Suma maximă se actualizează, după caz, la
{ fiecare pas.
if(n%2==m%2)
s=s+m; Rezolvarea propusă este eficientă din
else punct de vedere al memoriei deoarece nu
{ ne-am folosit de vectori, am folosit un
if(s>smax) număr minimal de variabile: 4.
smax=s;
s=m; Rezolvarea este eficientă din punct de
} vedere al timpului de executare deoarece
n=m; algoritmul este linear de complexitate
} liniară [O(n), unde n = numărul
if(s>smax) elementelor citite], adică, la o singură
smax=s; parcurgere a valorilor (chiar în momentul
cout<<smax; în care sunt citite), programul afișează la
f.close(); final răspunsul dorit.
return 0;
}
41
Subiectul
REZOLVARE PROPUSĂ DE dat în
PROF. ALINA PINTESCU 25 iunie
2020
Examenul de bacalaureat național 2020
Proba E. d) Informatică - Limbajul C/C++

Varianta 6
Filieră teoretică, profil real, specializare matematică-informatică / matematică-informatică intensiv informatică

Filieră vocațională, profil militar, specializare matematică-informatică
Toate subiectele sunt obligatorii. Se acordă 10 puncte din oficiu.
Timpul de lucru efectiv este de 3 ore.
Identificatorii utilizați în rezolvări trebuie să respecte precizările din enunț (bold), iar în lipsa unor
precizări explicite, notațiile trebuie să corespundă cu semnificațiile asociate acestora (eventual
în formă prescurtată). Datele de intrare se consideră corecte, validarea lor nefiind necesară.
În grafurile din cerințe oricare arc/muchie are extremități distincte și oricare două arce/muchii
diferă prin cel puțin una dintre extremități.
Pentru fiecare dintre itemii de la 1 la 5, scrieți pe foaia de examen litera corespunzătoare
Răspuns:
d
3 + 2.5 + 2 = 7.5
Răspuns:
b
Răspuns:
c
Răspuns:
c
Răspuns:
a
42
a. Răspuns corect: 1 1 1 0 0
b. Răspuns corect: 102468 986420
c. d.
citește a (număr natural)
c0
┌repetă
│ ba; x0
││┌dacă b%10=c atunci
│││ x1
││└■
││ b[b/10]
│┌cât timp b≠0 și x≠1
││┌dacă b%10=c atunci
│││ x1
││└■
││ b[b/10]
│└■
│ scrie x,’ ’
│ cc+2
└până când c>9
struct calculator
{ char monitor;
struct [nume]
{int interna;
int externa;
}memorie;
}c;
Metoda 1
{ a[i][j]=’>’;
if(i+j>8 && i>j)
a[i][j]=’<’;
}
Metoda 2
if(i+j>8 && i>j)
a[i][j]=’ <’;
else
a[i][j]=’>’;
43
Metoda 1 – cu despărțire în cuvinte Metoda 2– fără despărțire în cuvinte

#include <iostream> #include <iostream>
#include <cstring> #include <cstring>
using namespace std; using namespace std;
char s[105], *p, t[105],aux; int i, j, ok=0, aux;
int i, ok=0; char s[105];
int main() int main()
{ { cin.get(s,105);
cin.getline(s,105); i=0;
p=strtok(s," "); while(i<strlen(s))
while(p) {
{ while(s[i]!=' ')
if(strlen(p)>=3) i++;
{ j=i+1;
ok=1; while (s[j]!=' ' && j<strlen(s))
aux=p[0]; j++;
for(i=0; i<strlen(p)-1; i++)
p[i]=p[i+1]; if(j-i-1>=3)
p[strlen(p)-1]=aux; {
} ok=1;
strcat(t,p); aux=s[i+1];
strcat(t," "); s[i+1]=s[j-1];
p=strtok(NULL," "); s[j-1]=aux;
} }
t[strlen(t)-1]='\0'; i=j+1;
strcpy(s,t); }
if(ok==0) if (ok==0) cout<<"nu exista";
cout<<"nu exista"; else cout<<s;
else return 0;
cout<<s; }
return 0;
}
44
Metoda 1
O soluție posibilă parcurge șirul din fișier,
contorizând-alternativ pentru valoarea
curentă x numărul său de apariții. Dacă
numărul nu există în vectorul de frecvență se
marchează ca o primă apariție, iar dacă
există deja se anulează punând valoarea 0. În
același timp un contor k ne ajută să
verificăm câte numere au avut un număr
impar de apariții. Dacă este mai mult de un
astfel de număr, șirul nu va mai fi conform
cerinței.

adică, la o singură parcurgere a valorilor,
programul afișează la final răspunsul dorit.
Metoda 2
O soluție posibilă parcurge șirul din fișier,

contorizând pentru valoarea curentă x
numărul său de apariții. La final se
parcurge șirul de numere posibile din
intervalul [1,1000] verificând câte numere
au avut un număr impar de apariții. Dacă
este mai mult de un astfel de număr, șirul
nu va mai fi conform cerinței.

algoritmul este linear de complexitate
liniară [O(n), unde n = numărul elementelor
citite], adică, la o singură parcurgere a
valorilor și a valorilor posibile (din
intervalul [1,1000]), programul afișează la
final răspunsul dorit.
45
RESURSE WEB
 https://rocnee.eu/modelesubiecte/
 https://www.pbinfo.ro/articole/5546/informatica-in-liceu
LINKUL RESURSEI (auxiliar)
 https://alinapintescu.wordpress.com/c/
*** materialul este gândit ca un Ghid de pregătire a examenului de bacalaureat la

informatică C++ - Sesiunea iunie 2020
46

Antrenament 10-20

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Antrenament 10-20

Încărcat de

Drepturi de autor:

Formate disponibile

PINTESCU Alina, KALMAR Violeta-Mihaela

Simulare 12 - prof. Pintescu Alina ....................................................... 5

Simulare 13 - prof. Pintescu Alina ....................................................... 8

Simulare 14 - prof. Kalmar Violeta.................................................... 11

Simulare 15 - prof. Pintescu Alina ..................................................... 15

Simulare 16 - prof. Pintescu Alina ..................................................... 19

Simulare 17 - prof. Pintescu Alina ..................................................... 24

Simulare 18 - prof. Pintescu Alina ..................................................... 28

Simulare 19 - prof. Pintescu Alina ..................................................... 32

Simulare 20 - prof. Pintescu Alina ..................................................... 36

Subiectul dat în 25 iunie 2020 - prof. Pintescu Alina ........................ 40

Resurse web ……………………………………………………… 46

• Toate subiectele sunt obligatorii. Se acordă 10 puncte din oficiu.

d) x<=2019 && y>=2019 && y<=2020

f(2020,2) = 1 + f(1010,2) = 1 + 1 + f(505,2) = 2 + 2020 = 2022

SUBIECTUL I (20 de puncte)

b) și d) nu sunt tablou bidimensional

a) Răspuns corect: 952

citește n (număr natural nenul)

12456 – antepenultima val

SUBIECTUL I (20 de puncte)

a) n%4==0 && n%5==0

f(200200) = 2 * f(20020) = 2 * 2 * f(2002) = 2 * 2 * 2 * f(200) = 2 * 2 * 2 * 2 * f(20)

a) Răspuns corect: 10375

Metoda 1 Metoda 2 Metoda 3

SUBIECTUL I (20 de puncte)

!(x<-2020 || x>2020)  x>=-2020 && x<=2020

a) Răspuns corect: 4188262

O soluție posibilă parcurge șirul din fișier și

Eficiența rezolvării problemei dpdv al

SUBIECTUL I (20 de puncte)

Se acordă câte 3p. pentru fiecare valoare conform cerinței

Metoda 1 Metoda 2 Metoda 3

SUBIECTUL I (20 de puncte)

a) Răspuns corect: 2020

SUBIECTUL I (20 de puncte)

Metoda 1 Metoda 2 Metoda 3

SUBIECTUL I (20 de puncte)

Teorie: Pentru G un graf orientat cu n vârfuri şi m arce - numărul de

#include <iostream> #include <bits/stdc++.h>

Rezolvarea este eficientă din punct de

SUBIECTUL I (20 de puncte)

a) Răspuns corect: 484866

void paritate(int n, int &nr)

#include <iostream> Am parcurs șirul din fișier, memorând

Rezolvarea este eficientă din punct de

SUBIECTUL I (20 de puncte)

Proba E. d) Informatică - Limbajul C/C++

Filieră teoretică, profil real, specializare matematică-informatică / matematică-informatică intensiv informatică

Metoda 1 – cu despărțire în cuvinte Metoda 2– fără despărțire în cuvinte

Rezolvarea este eficientă din punct de

O soluție posibilă parcurge șirul din fișier,

Rezolvarea este eficientă din punct de

LINKUL RESURSEI (auxiliar)

*** materialul este gândit ca un Ghid de pregătire a examenului de bacalaureat la

S-ar putea să vă placă și