Skip to content

Instantly share code, notes, and snippets.

@ovidiudeica

ovidiudeica/A.1.citire_afisare_vector.cpp

Last active March 10, 2024 22:30
Show Gist options
  • Star 1 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save ovidiudeica/5d9cbabf71995940c1d63516f0033308 to your computer and use it in GitHub Desktop.
Save ovidiudeica/5d9cbabf71995940c1d63516f0033308 to your computer and use it in GitHub Desktop.
Download ZIP
Algoritmi cu tablouri in C++
Raw
A.1.citire_afisare_vector.cpp
// citire-afisare vector
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
unsigned n, i, v[50];
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 50): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// afisarea vectorului:
cout << "Vectorul v este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
A.1.citire_afisare_vector.doc
Citirea si afisarea unui vector.
Rezolvare: Aplicatia se reduce la citirea si afisarea unui vector.
Raw
A.2.citire_afisare_matrice.cpp
// citire-afisare matrice
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, m, n, A[10][20];
// citirea matricei (mxn):
cout << "Introduceti dimensiunile matricei (mxn): \n";
// citirea dimensiunilor matricei (mxn):
cout << "m = "; cin >> m; // citeste m
cout << "n = "; cin >> n; // citeste n
// citirea elementelor matricei pe linii:
cout << "Introduceti elementele matricei: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
{
cout << "A[" << i << "][" << j << "] = "; cin >> A[i][j]; // citeste A[i,j]
}
// afisarea matricei introduse:
cout << "Matricea introdusa este: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
for (j = 1; j <= n; j++) // pentru j=1, n executa
cout << A[i][j] << " "; // scrie A[i,j]
// trece pe linia urmatoare:
cout << endl;
}
} // stop
Raw
A.2.citire_afisare_matrice.doc
Citeste o matrice de dimensiune mxn si afiseaza elemntele acesteia.
Rezolvare: Aplicatia se reduce la citirea si afisarea unei matrici cu m linii si n coloane (secventele corespunzatoare au fost
prezentate anterior).
Raw
B.1.suma_vector.cpp
// suma elementelor unui vector
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
unsigned n, i, v[50], S;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 50): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// initializeaza suma cu 0:
S = 0; // atribuie S<-0
// calculul sumei elementelor:
for (i = 1; i <= n; i++) // pentru i=1, n,2 executa
S += v[i]; // atribuie S<-s+v[i]
// afisarea sumei elementelor vectorului:
cout << "Suma elementelor vectorului v este: " << S << endl; // scrie S
} // stop
Raw
B.1.suma_vector.doc
Calculeaza suma elementelor unui vector cu n elemente numere naturale.
Rezolvare: Dupa citirea vectorului, se initializeaza variabila S (care va retine suma elementelor) cu 0, dupa care pentru
fiecare valoare a variabilei de ciclare i, la suma anterioara S, se adauga elementul vectorului v, aflat pe pozitia i.
Raw
B.2.a.suma_diag_principala_matrice.cpp
// diagonala principala
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n, S1, S2, S3, A[10][10];
// citirea matricei patratice (nxn):
cout << "Introduceti dimensiunea matricei patratice (nxn): \n";
// citirea dimensiunilor matricei patratice (nxn):
cout << "n = "; cin >> n; // citeste n
// citirea elementelor matricei patratice pe linii:
cout << "Introduceti elementele matricei patratice: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
{
cout << "A[" << i << "][" << j << "] = "; cin >> A[i][j]; // citeste A[i,j]
}
// initializeaza sumele S1, S2, S3 cu 0:
S1 = 0; // atribuie S1<-0
S2 = 0; // atribuie S2<-0
S3 = 0; // atribuie S3<-0
// sau S1 = S2 = S3 = 0;
// calculul sumei elementelor de pe diagonala principala:
for (i = 1; i <= n; i++) // pentru i=1, n executa
S1 += A[i][i]; // atribuie S1<-S1+A[i,i]
// sau S1 = S1 + A[i][i];
// afisarea sumei elementelor de pe diagonala principala
cout << "Suma elementelor de pe diagonala principala este: " << S1 << endl; // scrie S1
// calculul sumei elementelor de deasupra diagonalei principale:
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
for (j = i + 1; j <= n; j++) // pentru j=i+1, n executa
S2 += A[i][j]; // atribuie S2<-S2+A[i,j]
// sau S2 = S2 + A[i][j];
// afisarea sumei elementelor de deasupra diagonalei principale
cout << "Suma elementelor de deasupra diagonalei principale este: " << S2 << endl; // scrie S2
// calculul sumei elementelor de sub diagonala principala:
for (i = 2; i <= n; i++) // pentru i=2, n executa
for (j = 1; j <= i - 1; j++) // pentru j=1, i-1 executa
S3 += A[i][j]; // atribuie S3<-S3+A[i,j]
// sau S3 = S3 + A[i][j];
// afisarea sumei elementelor de sub diagonala principala
cout << "Suma elementelor de sub diagonala principala este: " << S3 << endl; // scrie S3
} // stop
Raw
B.2.a.suma_diag_principala_matrice.doc
Calculeaza intr-o matrice patratica A(nxn), de numere reale, suma elementelor:
- de sub,
- deasupra si
- de pe diagonala principala
Rezolvare: Diagonala principala contine elementele: A[1][1], A[2][2], ..., A[n][n].
Tinand cont de aceasta, elementele de deasupra diagonalei principale sunt:
- pe prima linie: A[1][2], A[1][3], ..., A[1][n];
- pe a doua linie: A[2][3], A[2][4], ..., A[2][n] s.a.m.d, iar
- pe ultima linie va fi elementul A[n-1][n].
Elementele de sub diagonala principala sunt:
- pe prima linie: A[2][1],
- pe a doua linie: A[3][1], A[3][2] s.a.m.d, iar
- pe ultima linie vor fi elementele A[n][1], A[n][2], ..., A[n-1][n].
NotaM cu:
- S1 suma elementelor de pe diagonala principala,
- S2 suma elementelor de deasupra diagonalei principale,
- S3 suma elementelor de sub diagonala principala.
Raw
B.2.b.matrice_patratica.cpp
// matrice patratica
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, k1, k2, n;
float A[10][10], x[50], y[50], S;
// citirea matricei patratice (nxn):
cout << "Introduceti dimensiunea matricei patratice (nxn): \n";
// citirea dimensiunilor matricei patratice (nxn):
cout << "n = "; cin >> n; // citeste n
// citirea elementelor matricei patratice pe linii:
cout << "Introduceti elementele matricei patratice: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
{
cout << "A[" << i << "][" << j << "] = "; cin >> A[i][j]; // citeste A[i,j]
}
// initializeaza indicii vectorilor x (k1) si y (k2) cu 0:
k1 = 0; // atribuie k1<-0
k2 = 0; // atribuie k2<-0
// initializeaza suma elementelor de pe diagonala principala cu 0:
S = 0; // atribuie S<-0
// sau k1 = k2 = S = 0;
// testeaza fiecare element al matricei:
for (i = 1; i <= n; i++) // pentru i=1, n executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
// daca elementul este sub diagonala principala (i>j) se trece in vectorul x:
if (i > j) // daca i>j atunci
{
k1++; // atribuie k1<-k1+1
// sau k1 = k1 + 1;
x[k1] = A[i][j]; // atribuie x[k1]<-A[i,j]
// sau x[++k1] = A[i][j];
}
else // altfel
// daca elementul este deasupra diagonalei principale (i<j) se trece la vectorul y:
if (i < j) // daca i<j atunci
{
k2++; // atribuie k2<-k2+1
// sau k2 = k2 + 1;
y[k2] = A[i][j]; // atribuie y[k2]<-A[i,j]
// sau y[++k2] = A[i][j];
}
else // altfel
// daca elementul este pe diagonala se aduna la suma S:
S += A[i][j]; // atribuie S<-S+A[i,j]
// sau S = S + A[i][j];
// afisarea vectorului x:
cout << "Vectorul x este: ";
for (i = 1; i <= k1; i++) // pentru i=1, k1 executa
cout << x[i] << " "; // scrie x[i]
// trece pe linia urmatoare:
cout << endl;
// afisarea vectorului y:
cout << "Vectorul y este: ";
for (i = 1; i <= k2; i++) // pentru i=1, k2 executa
cout << y[i] << " "; // scrie y[i]
// trece pe linia urmatoare:
cout << endl;
// afisarea sumei:
cout << "Suma elementelor de pe diagonala principala este: " << S << endl; // scrie S
} // stop
Raw
B.2.b.matrice_patratica.doc
Transfera dintr-o matrice patratica A(nxn), de numere reale, intr-un vector x elementele de sub diagonala principala, iar
intr-un vector y elementele de deasupra diagonalei principale, dupa care calculeaza suma elementelor de pe diagonala
principala.
Rezolvare: In prima parte a programului se citeste matricea, dupa care se initializeaza cu 0 variabilele k1 si k2 reprezentand
indicii vectorului x respectiv y, precum si suma S a elementelor de pe diagonala principala.
In continuare se testeaza fiecare element al matricei si, daca este:
- sub diagonala principala (i>j) se trece in vectorul x,
- deasupra diagonalei principale (i<j) se trece la vectorul y, iar
- pe diagonala se aduna la suma S.
Raw
C.1.a.suma_pozitii_pare_vector.cpp
// suma elementelor de pe pozitiile pare
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
unsigned n, i;
float v[50], S;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 50): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// initializeaza suma cu 0:
S = 0; // atribuie S<-0
// calculul sumei elementelor de pe pozitiile pare:
for (i = 2; i <= n; i += 2) // pentru i=2, n,2 executa
S += v[i]; // atribuie S<-S+v[i]
// afisarea sumei elementelor de pe pozitiile pare:
cout << "Suma elementelor de pe pozitiile pare ale vectorului v este: " << S << endl; // scrie S
} // stop
Raw
C.1.a.suma_pozitii_pare_vector.doc
Calculeaza suma elementelor de pe pozitiile pare ale unui vector cu n elemente numere reale.
Rezolvare: Pentru a determina suma elementelor de pe pozitiile pare din sirul dat, se pleaca de la a doua pozitie din sir si
cu ajutoru structurii for, se incrementeaza cu 2 valoarea variabilei de ciclare i, parcurgand astfel doar elementele de pe
pozitiile pare, elemente care se insumeaza. Suma S are initial valoarea 0, iar la iesirea din for va reprezenta chiar suma
ceruta.
Raw
C.1.b.media_pare_matrice.cpp
// medie nr. pare
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n, m, A[10][20], S, k;
// citirea matricei (mxn):
cout << "Introduceti dimensiunile matricei (mxn): \n";
// citirea dimensiunilor matricei (mxn):
cout << "m = "; cin >> m; // citeste m
cout << "n = "; cin >> n; // citeste n
// citirea elementelor matricei pe linii:
cout << "Introduceti elementele matricei: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
{
cout << "A[" << i << "][" << j << "] = "; cin >> A[i][j]; // citeste A[i,j]
}
// initializeaza S si k cu 0:
S = 0; // atribuie S<-k
k = 0; // atribuie k<-0
// sau S = k = 0;
// testeaza fiecare element al matricei daca este par:
for (i = 1; i <= m; i++) // pentru i=1, m executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
// daca elementul este par:
if (A[i][j] % 2 == 0) // daca A[i,j]%2=0 atunci
{
// insumeaza elementul par gasit:
S += A[i][j]; // atribuie S<-S+A[i,j]
// sau s = s + a[i][j];
// contorizeaza elementul par gasit:
k++; // atribuie k<-k+1
// sau k = k + 1;
}
if (k == 0) // daca k=0 atunci
cout << "Nu exista elemnte pare. \n"; // scrie 'nu exista elemnte pare'
else // altfel
// se determina si se afiseaza media aritmetica:
cout << "Media aritmetica este: " << (float)S / k << endl; // scrie S/k
} // stop
Raw
C.1.b.media_pare_matrice.doc
Calculeaza media aritmetica a elemntelor pare dintr-un tablou bidimensional A, cu m linii si n coloane, cu elemente numere
intregi.
Rezolvare: Pentru a determina media aritmetica a elementelor pare din matricea A, vom testa fiecare element al matricei si
ori de cate ori gasim un elemnt par, il insumam si-l contorizam. Initial suma S si variabila contor k au valoarea 0. In
final, vom imparti suma obtinuta (S) la numarul de elemente pare (k), determinand astfel media aritmetica.
Raw
C.2.a.suma_pozitii_impare_vector.cpp
// suma elementelor de pe pozitiile impare
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
unsigned n, i;
float v[50], S;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 50): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// initializeaza suma cu 0:
S = 0; // atribuie S<-0
// calculul sumei elementelor de pe pozitiile impare:
for (i = 1; i <= n; i += 2) // pentru i=1, n,2 executa
S += v[i]; // atribuie S<-S+v[i]
// afisarea sumei elementelor de pe pozitiile impare:
cout << "Suma elementelor de pe pozitiile impare ale vectorului v este: " << S << endl; // scrie S
} // stop
Raw
C.2.a.suma_pozitii_impare_vector.doc
Calculeaza suma elementelor de pe pozitiile impare ale unui vector cu n elemente numere reale.
Rezolvare: Pentru a determina suma elementelor de pe pozitiile impare din sirul dat, se pleaca de la prima pozitie din sir si
cu ajutoru structurii for, se incrementeaza cu 2 valoarea variabilei de ciclare i, parcurgand astfel doar elementele de pe
pozitiile impare, elemente care se insumeaza. Suma S are initial valoarea 0, iar la iesirea din for va reprezenta chiar suma
ceruta.
Raw
C.2.b.media_impare_matrice.cpp
// media nr. impare
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n, m, A[10][20], S, k;
// citirea matricei (mxn):
cout << "Introduceti dimensiunile matricei (mxn): \n";
// citirea dimensiunilor matricei (mxn):
cout << "m = "; cin >> m; // citeste m
cout << "n = "; cin >> n; // citeste n
// citirea elementelor matricei pe linii:
cout << "Introduceti elementele matricei: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
{
cout << "A[" << i << "][" << j << "] = "; cin >> A[i][j]; // citeste A[i,j]
}
// initializeaza S si k cu 0:
S = 0; // atribuie S<-k
k = 0; // atribuie k<-0
// sau S = k = 0;
// testeaza fiecare element al matricei daca este impar:
for (i = 1; i <= m; i++) // pentru i=1, m executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
// daca elementul este impar:
if (A[i][j] % 2 == 1) // daca A[i,j]%2=1 atunci
{
// insumeaza elementul impar gasit:
S += A[i][j]; // atribuie S<-S+A[i,j]
// sau s = s + a[i][j];
// se contorizeaza elementul impar gasit:
k++; // atribuie k<-k+1
// sau k = k + 1;
}
if (k == 0) // daca k=0 atunci
cout << "Nu exista elemnte impare. \n"; // scrie 'nu exista elemnte impare'
else // altfel
// se determina si se afiseaza media aritmetica:
cout << "Media aritmetica este: " << (float)S / k << endl; // scrie S/k
} // stop
Raw
C.2.b.media_impare_matrice.doc
Calculeaza media aritmetica a elemntelor impare dintr-un tablou bidimensional A, cu m linii si n coloane, cu elemente numere
intregi.
Rezolvare: Pentru a determina media aritmetica a elementelor impare din matricea A, vom testa fiecare element al matricei si
ori de cate ori gasim un elemnt impar, il insumam si-l contorizam. Initial suma S si variabila contor k au valoarea 0. In
final, vom imparti suma obtinuta (S) la numarul de elemente impare (k), determinand astfel media aritmetica.
Raw
C.3.expresie_vector.cpp
// expresie generare vector
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int n, i, j, x[20], S, max;
float y[20];
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului x (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului x: \n";
for (i = 1; i <= n; i++) // pentru i=1; n executa
{
cout << "x[" << i << "] = "; cin >> x[i]; // citeste x[i]
}
// initializeaza suma cu 0:
S = 0; // atribuie S<-0
// calculul sumei celor n numere:
for (i = 1; i <= n; i++) // pentru i=1, n executa
S += x[i]; // atribuie S<-S+x[i]
// sau S = S + x[i];
// testeza daca numarul este impar sau par:
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
// daca i este un numar impar:
if (i % 2 != 0) // daca imod2<>0 atunci
y[i] = S / i; // y[1]<-S/i
else // altfel
{
// daca i este un numar par:
max = x[1]; // atribuie max<-x[i]
for (j = 2; j <= i; j++) // pentru j=2, i executa
if (x[j] > max) // daca x[j]>max atunci
max = x[j]; // atribuie max<-x[j]
y[i] = max; // atribuie y[i]<-max
}
}
// afisarea valorilor obtinute:
cout << "Valorile obtinute sunt: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << y[i] << " "; // scrie y[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
C.3.expresie_vector.doc
Se da un numar natural n (n>1) si numerele intregi x1,x2,x3,...,xn distincte doua cate doua. Sa se calculeze:
max {xi, j = 1, i}, daca i este par
yi = pentru i = 1, 2, 3, ..., n.
(xi + x2 + ... + xn) / i, daca i este impar
Rezolvare: Pentru a rezolva aceasta problema, se procedeaza astfel:
- se citesc cele n numere intregi in vectorul x;
- se determina suma S a celor n numere x1,x2,...,xn, suma de care este nevoie la calculul elementelor y[i], cand i este un
numar impar;
- pentru valorile impare ale lui i se calculeaza y[i] ca fiind raportul S/i, iar pentru cele pare se determina elementul maxim
dintre valorile x[i],x[2],...,x[i], maxim care este atribuit lui y[i].
Raw
D.1.a.minim_vector.cpp
// minimul dintr-un vector
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
long i, m, v[20], min;
// citirea vectorului:
do // executa
{
// citirea si validarea m>=4:
cout << "Introduceti dimensiunea vectorului v (min 4 si max 20): \n";
// citirea dimensiunii vectorului:
cout << "m = "; cin >> m; // citeste m
} while (m < 4); // cat timp m<4
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// se presupune ca elementul de pe pozitia 1 este cel mai mic:
min = v[1]; // atribuie min<-v[1]
// determina minimul:
for (i = 2; i <= m; i++) // pentru i=2, m executa
// testeaza elementele vectorului:
if (v[i] < min) // daca v[i]<min atunci
min = v[i]; // atribuie min<-v[i]
// afisarea minimului din vector:
cout << "Elementul minim din vectorul v este: " << min << endl; // scrie min
} // stop
Raw
D.1.a.minim_vector.doc
Determina minimul dintr-un vector cu m (m>=4) elemente numere naturale.
Rezolvare: Pentru rezolvare, folosim variabila min care retine elementul minim la un moment dat. Initializam acesta variabila
cu primul element din sir si o comparam cu fiecare element al sirului. Ori de cate ori un element al acestuia este mai mic
decat valoarea variabilei min, variabila primeste valoarea elementelor respective.
Raw
D.1.b.maxim_vector.cpp
// maximul dintr-un vector
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
long i, m, v[20], max;
// citirea vectorului:
do // executa
{
// citirea si validarea m>=4:
cout << "Introduceti dimensiunea vectorului v (min 4 si max 20): \n";
// citirea dimensiunii vectorului:
cout << "m = "; cin >> m; // citeste m
} while (m < 4); // cat timp m<4
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// se presupune ca elementul de pe pozitia 1 este cel mai mare:
max = v[1]; // atribuie max<-v[1]
// determina maximul:
for (i = 2; i <= m; i++) // pentru i=2, m executa
// testeaza elementele vectorului:
if (v[i] > max) // daca v[i]>max atunci
max = v[i]; // atribuie max<-v[i]
// afisarea maximului din vector:
cout << "Elementul maxim din vectorul v este: " << max << endl; // scrie max
} // stop
Raw
D.1.b.maxim_vector.doc
Determina maximul dintr-un vector cu m (m>=4) elemente numere naturale.
Rezolvare: Pentru rezolvare, folosim variabila max care retine elementul maxim la un moment dat. Initializam acesta variabila
cu primul element din sir si o comparam cu fiecare element al sirului. Ori de cate ori un element al acestuia este mai mare
decat valoarea variabilei max, variabila primeste valoarea elementelor respective.
Raw
D.1.minim_maxim_vector.cpp
// minimul si maximul dintr-un vector
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
long i, m, v[20], min, max;
// citirea vectorului:
do // executa
{
// citirea si validarea m>=4:
cout << "Introduceti dimensiunea vectorului v (min 4 si max 20): \n";
// citirea dimensiunii vectorului:
cout << "m = "; cin >> m; // citeste m
} while (m < 4); // cat timp m<4
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// initializeaza min si max cu elementul de pe pozitia 1:
min = max = v[1]; // atribuie min<-v[1] max<-v[1]
// se determina minimul si maximul:
for (i = 2; i <= m; i++) // pentru i=2, m executa
{
// testeaza elementele vectorului:
if (v[i] < min) // daca v[i]<min atunci
min = v[i]; // atribuie min<-v[i]
if (v[i] > max) // daca v[i]>max atunci
max = v[i]; // atribuie max<-v[i]
}
// afisarea minimului si maximului din vector:
cout << "Elementul minim din vectorul v este: " << min << endl; // scrie min
cout << "Elementul maxim din vectorul v este: " << max << endl; // scrie max
} // stop
Raw
D.1.minim_maxim_vector.doc
Determina minimul si maximul dintr-un vector cu m (m>=4) elemente numere naturale.
Rezolvare: Pentru rezolvare, folosim variabila min si max care retin elementul minim, respectiv maxim la un moment dat.
Initializam aceste variabile cu primul element din sir si le comparam cu fiecare element al sirului. Ori de cate ori un
element al acestuia este mai mic decat valoarea variabilei min, respectiv mai mare decat valoarea variabilei max, variabilele
primesc valoarea elementelor respective.
Raw
D.2.a.ordonare_sir_minim_matrice.cpp
// sir minim
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n, m, min, aux, ordonat;
int A[10][20], b[200];
// citirea matricei (mxn):
cout << "Introduceti dimensiunile matricei (mxn): \n";
// citirea dimensiunilor matricei (mxn):
cout << "m = "; cin >> m; // citeste m
cout << "n = "; cin >> n; // citeste n
// citirea elementelor matricei pe linii:
cout << "Introduceti elementele matricei: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
{
cout << "A[" << i << "][" << j << "] = "; cin >> A[i][j]; // citeste A[i,j]
}
// determina elementul minim de pe fiecare linie a matricei:
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
// presupune ca minimul pe linie ar fi primul element al acesteia:
min = A[i][1]; // atribuie min<-A[i,1]
for (j = 2; j <= n; j++) // pentru j=2, n executa
if (A[i][j] < min) // daca A[i,j]<min atunci
min = A[i][j]; // atribuie min<-A[i,j]
// transfera minimul in vectorul b:
b[i] = min; // atribuie b[i]<-min
}
// afiseaza vectorul b:
cout << "Vectorul b este: ";
for (i = 1; i <= m; i++) // pentru i=1, m executa
cout << b[i] << " "; // scrie b[i]
// trece pe linia urmatoare:
cout << endl;
// ordoneaza vectorul b:
do // repeta
{
ordonat = 1; // ordonat=TRUE
for (i = 1; i <= m - 1; i++) // pentru i=1, m-1 executa
if (b[i] > b[i + 1]) // daca b[i]>b[i+1] atunci
{
// interschimba elementele vectorului b:
aux = b[i]; // atribuie aux<-b[i]
b[i] = b[i + 1]; // atribuie b[i]<-b[i+1]
b[i + 1] = aux; // atribuie b[i+1]<-aux
ordonat = 0; // atribuie ordonat<-FALSE
}
} while (!ordonat); // pana cand ordonat=TRUE
// afisarea vectorului b ordonat:
cout << "Vectorul b ordonat este: ";
for (i = 1; i <= m; i++) // pentri i=1, m executa
cout << b[i] << " "; // scrie b[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
D.2.a.ordonare_sir_minim_matrice.doc
Construieste un vector b care contine elementul minim de pe fiecare linie a unei matrici A, de m linii si n coloane, cu
elemente numere reale, si apoi ordoneaza vectorul astfel obtinut.
Rezolvare: Introducem matricea, apoi determinam elementul minim de pe fiecare linie a acesteia, element pe care-l transferam
in vectorul b. Afisam vectorul astfel obtinut, dupa care-l ordonam si-l afisam.
Raw
D.2.b.ordonare_sir_maxim_matrice.cpp
// sir maxim
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n, m, max, aux, ordonat;
int A[10][20], b[200];
// citirea matricei (mxn):
cout << "Introduceti dimensiunile matricei (mxn): \n";
// citirea dimensiunilor matricei (mxn):
cout << "m = "; cin >> m; // citeste m
cout << "n = "; cin >> n; // citeste n
// citirea elementelor matricei pe linii:
cout << "Introduceti elementele matricei: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
{
cout << "A[" << i << "][" << j << "] = "; cin >> A[i][j]; // citeste A[i,j]
}
// determina elementul minim de pe fiecare linie a matricei:
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
// presupune ca maximul pe linie ar fi primul element al acesteia:
max = A[i][1]; // atribuie max<-A[i,1]
for (j = 2; j <= n; j++) // pentru j=2, n executa
if (A[i][j] > max) // daca A[i,j]>max atunci
max = A[i][j]; // atribuie max<-A[i,j]
// transfera maximul in vectorul b:
b[i] = max; // atribuie b[i]<-max
}
// afiseaza vectorul b:
cout << "Vectorul b este: ";
for (i = 1; i <= m; i++) // pentru i=1, m executa
cout << b[i] << " "; // scrie b[i]
// trece pe linia urmatoare:
cout << endl;
// ordoneaza vectorul b:
do // repeta
{
ordonat = 1; // ordonat=TRUE
for (i = 1; i <= m - 1; i++) // pentru i=1, m-1 executa
if (b[i] > b[i + 1]) // daca b[i]>b[i+1] atunci
{
// interschimba elementele vectorului b:
aux = b[i]; // atribuie aux<-b[i]
b[i] = b[i + 1]; // atribuie b[i]<-b[i+1]
b[i + 1] = aux; // atribuie b[i+1]<-aux
ordonat = 0; // atribuie ordonat<-FALSE
}
} while (!ordonat); // pana cand ordonat=TRUE
// afisarea vectorului b ordonat:
cout << "Vectorul b ordonat este: ";
for (i = 1; i <= m; i++) // pentri i=1, m executa
cout << b[i] << " "; // scrie b[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
D.2.b.ordonare_sir_maxim_matrice.doc
Construieste un vector b care contine elementul maxim de pe fiecare linie a unei matrici A, de m linii si n coloane, cu
elemente numere reale, si apoi ordoneaza vectorul astfel obtinut.
Rezolvare: Introducem matricea, apoi determinam elementul maxim de pe fiecare linie a acesteia, element pe care-l transferam
in vectorul b. Afisam vectorul astfel obtinut, dupa care-l ordonam si-l afisam.
Raw
E.suma_interval_vector.cpp
// media aritmetica
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, n, k, v[50], a, b, S;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 50): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v \n";
for (i = 1; i <= n; i++) // pentru i=1; n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// citirea valorilor a si b (a<b):
do // executa
{
cout << "Alegeti intervalul (a<b): \n";
cout << "a = "; cin >> a; // citeste a
cout << "b = "; cin >> b; // citeste b
} while (a >= b); // cat timp a>=b
// initial suma este 0:
S = 0; // atribue S<-0
// initial numarul elementelor dintre a si b este 0:
k = 0; // atribue k<-0
// calculul sumei elementelor din intervalul [a,b]:
for (i = 1; i <= n; i++) // pentru i=1, n executa
if (v[i] >= a && v[i] <= b) // daca a<=v[i]<=b atunci
{
// calculul sumei elementelor dintre a si b:
S += v[i]; // atribue s<-s+v[i]
// contorizeaza numarul elementelor dintre a si b:
k++; // atribue k<-k+1
// sau k = k + 1;
}
if (k == 0) // daca k=0 atunci
cout << "Nu exista elemente intre a si b! \n"; // scrie 'nu exista elemente'
else // altfel
// afisarea mediei aritmetice a elementelor din intervalul [a,b]:
cout << "Media aritmetica este: " << (float)S / k << endl; // scrie S/k
} // stop
Raw
E.suma_interval_vector.doc
Calculeaza media aritmetica a unui vector cu n elemente dintr-un interval inchis determinat de 2 valori a si b.
Rezolvare: Pentru a calcula media aritmetica a elementelor sirului, cuprins intre 2 valori date a si b, (a < b), calculam suma
tuturor elementelor ce apartin intervalului [a, b], numarand totodata si cate astfel de elemente avem. Impartim apoi suma
obtinuta la numarul elementelor din acest interval, obtinand astfel media cautata.
Raw
F.1.a.numere_prime_vector.cpp
// numere prime
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
unsigned i, v[50], k, j, m, ok;
// citirea vectorului:
do // executa
{
// citirea si validarea m<=20:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "m = "; cin >> m; // citeste m
} while (m > 20); // cat timp m>20
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
k = 0; // atribuie k<-0
// determina numerele prime:
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
ok = 1; // ok<-TRUE
if (v[i] == 1) // daca v[i]=1 atunci
ok = 0; // ok<-FALSE
else // altfel
{
for (j = 2; j <= v[i] / 2; j++) // pentru j=2, [v[i]/2] executa
// testeaza daca j este divizor al lui v[i]:
if (v[i] % j == 0) // daca v[i]%j=0 atunci
ok = 0; // ok<-FALSE
// contorizeaza numerele prime:
if (ok) // daca ok=TRUE atunci
k++; // atribuie k<-k+1
// sau k = k + 1;
}
}
// afisarea numarului numerelor prime:
cout << "Sunt " << k << " numere prime. \n"; // scrie k
} // stop
Raw
F.1.a.numere_prime_vector.doc
Determina cate numere sunt prime din m (m<=20) numere naturale.
Rezolvare: Un numar prim n, are exact 2 divizori (pe 1 si el insusi). Pentru a determina cate numere prime se afla in sir, vom
testa fiecare element din sir daca este prim, in caz afirmativ, vom mari valoarea variabilei k, care memoreaza numarul
elementelor prime din vector. Numarul 1 nu este prim.
Raw
F.1.b.transfer_prime_matrice.cpp
// transfer nr. prime
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int nr, j, n, m, k, i, ok, b[200], A[10][20];
// citirea matricei (nxm):
cout << "Introduceti dimensiunile matricei (nxm): \n";
// citirea dimensiunilor matricei (mxn):
cout << "m = "; cin >> m; // citeste m
cout << "n = "; cin >> n; // citeste n
// citirea elementelor matricei pe linii:
cout << "Introduceti elementele matricei: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
{
cout << "A[" << i << "][" << j << "] = "; cin >> A[i][j]; // citeste A[i,j]
}
// initializeaza variabila de ciclare nr cu 0
nr = 0; // atribuie nr<-0
// testeaza fiecare element al matricei daca este prim:
for (i = 1; i <= m; i++) // pentru i=1, m executa
for (j = 1; j <= n; j++) // pentru j=1, n executa
{
ok = 1; // atribuie ok<-1
for (k = 2; k <= A[i][j] / 2; k++) // pentru k=2, [A[i,j]/2] executa
// testeaza daca k este divizor al lui A[i,j]
if (A[i][j] % k == 0) // daca A[i,j]%k=0 atunci
ok = 0; // atribuie ok=FALSE
// daca elementul este prim:
if (ok && (A[i][j] != 1)) // daca ok=TRUE si A[i,j]<>1 atunci
{
// contorizeaza elementul prim gasit:
nr++; // atribuie nr<-nr+1
// sau nr = nr + 1;
// transfera elementul prim in vectorul b pe pozitia nr:
b[nr] = A[i][j]; // atribuie b[nr]<-A[i,j]
// sau b[++nr] = A[i][j];
}
}
if (nr == 0) // daca nr=0 atunci
cout << "Nu exista elemente prime \n"; // scrie 'nu exista elemente prime'
else // altfel
{
// afisarea vectorului b:
cout << "Vectorul va fi: ";
for (i = 1; i <= nr; i++) // pentru i=1, nr executa
cout << b[i] << " "; // scrie b[i]
// trece pe linia urmatoare:
cout << endl;
}
} // stop
Raw
F.1.b.transfer_prime_matrice.doc
Transfera intr-un vector elementele prime dintr-o matrice A (tablou bidimensional), cu n linii si m coloane, cu elemente
numere intregi.
Rezolvare: Dupa introducerea de la tastatura a matricei, initializam cu 0 variabila de ciclare nr a vectorului in care se va
face transferul elementelor prime. Testam daca fiecare element al matricei este prim si in caz afirmativ, il transferam in
vectorul b pe pozitia nr. In final afisam vectorul b astfel obtinut care va avea nr componente.
Raw
F.2.numere_perfecte_vector.cpp
// numere perfecte
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, m, v[50], S, P;
// citirea vectorului:
do // executa
{
// citirea si validarea m<=15:
cout << "Introduceti dimensiunea vectorului v (max 15): \n";
// citirea dimensiunii vectorului:
cout << "m = "; cin >> m; // citeste m
} while (m > 15); // cat timp m>15
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// initial variabila P are valoarea 1:
P = 1; // atribuie P<-1
// testeaza daca fiecare element este numar perfect:
for (i = 1; i <= m; i++) // pentru i=1, m executa
{
// initial suma divizorilor este 0:
S = 0; // atribuie S<-0
// calculul sumei divizorilor:
for (j = 1; j <= v[i] / 2; j++) // pentru j=1, [v[i]/2] executa
if (v[i] % j == 0); // daca v[i]%j=0 atunci
S += j; // atribuie S<-S+j
// sau S = S + j;
// verifica daca v[i] este perfect:
if (v[i] == S) // daca S=v[i] atunci
P *= v[i]; // atribuie P<-P*v[i]
// sau P = P * v[i];
}
if (P != 1) // daca P<>1 atunci
// afisarea produsului numerelor perfecte:
cout << "Produsul numerelor perfecte este: " << P << endl; // scrie P
else // altfel
cout << "Nu sunt numere perfecte! \n"; // scrie 'nu sunt numere perfecte'
} // stop
Raw
F.2.numere_perfecte_vector.doc
Calculeaza produsul numerelor perfecte dintr-un vector cu m (m<=15) elemente numere intregi.
Rezolvare: Un numar este perfect, daca se poate scrie ca suma a divizorilor sai naturali, mai putin el insusi. Pentru a
determina produsul numerelor perfecte din sirul dat, procedam astfel: testam daca fiecare element al sirului este numar
perfect, in caz afirmativ se calculeaza produsul P (initial variabila P are valoarea 1).
Raw
G.cmmdc_cmmmc_vector.cpp
// c.m.m.d.c. si c.m.m.m.c.
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int v[50], i, j, k, n, a, b, rest, cmmdc, cmmmc;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 50): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// citirea pozitiilor j si k:
cout << "Alegeti pozitiile: \n";
cout << "j = "; cin >> j; // citeste j
cout << "k = "; cin >> k; // citeste k
// pastreaza numerele v[j] si v[k]:
a = v[j]; // atribuie a<-v[j]
b = v[k]; // atribuie b<-v[k]
// calculul restului impartirii intregi a numarului a la b:
rest = a % b; // atribuie rest<-a mod b
while (rest != 0) // cat timp rest<>0 executa
{
// schimba variabelele intre ele:
a = b; // atribuie a<-b
b = rest; // atribuie b<-rest
rest = a % b; // atribuie rest<-a mod b
}
cmmdc = b; // atribuie cmmdc<-b
// afisarea c.m.m.d.c.:
cout << "c.m.m.d.c. este: " << cmmdc << endl; // scrie c.m.m.d.c.
// calculul c.m.m.m.c.:
cmmmc = (v[j] * v[k]) / cmmdc; // atribuie cmmmc<-(v[j]*v[k])/cmmdc
// afisarea c.m.m.m.c.:
cout << "c.m.m.m.c. este: " << cmmmc << endl; // scrie c.m.m.m.c.
} // stop
Raw
G.cmmdc_cmmmc_vector.doc
Determina c.m.m.d.c. si c.m.m.m.c. al numerelor aflate in sir pe pozitia i, k (i si k se cunosc) dintr-un vector cu n
elemente.
Rezolvare: Pentru a calcula c.m.m.d.c al numerelor de pe pozitiile indicate, folosim algoritmul lui Euclid.
Pentru a determina c.m.m.m.c al numerelor v[j] si v[k], utilizam formula: c.m.m.m.c. = (v[j] * v[k]) / c.m.m.d.c.
Raw
H.baza10_k_vector.cpp
// conversia din baza 10 in baza k
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
unsigned n, m, k, i, j, v[70];
// citirea numarului:
cout << "Introduceti numarul in baza 10: \n";
cout << "n = "; cin >> n; // citeste n
// citirea bazei k:
do // executa
{
cout << "Introduceti baza k: \n";
cout << "k = "; cin >> k; // citeste k
} while (k < 1); // cat timp k<1
// m retine prima valoare a lui n:
m = n; // atribuie k<-n
// initializeaza i cu 0:
i = 0; // atribuie i<-0
// transforma numarul din baza 10 in baza k:
do // executa
{
i++; // atribuie i<-i+1
// sau i = i + 1;
// v retine resturile obtinute:
v[i] = n % k; // atribuie v[i]<-n%k
n /= k; // atribuie n<-[n/k]
// sau n = n / k;
} while (n != 0); // cat timp n<>0
// afisarea tuturor resturile in ordinea inversa obtinerii:
cout << "Conversia numarului " << m << " din baza 10 in baza " << k << " este: ";
for (j = i; j >= 1; j--) // pentru j=i; 1, -1 executa
cout << v[j] << endl; // scrie v[i]
} // stop
Raw
H.baza10_k_vector.doc
Converteste un numar din baza 10 in baza k (k un nr. natural nenul).
Rezolvare: Pentru a transforma un numar din baza 10 in baza k, se procedeaza astfel:
- se imparte numarul dat la k si se obtine un cat si un rest;
- catul se imparte din nou la k si se obtine un alt cat si un alt rest;
- procedeul se repeta pana cand se obtine catul zero, moment in care se scriu toate resturile in ordinea inversa obtinerii.
In program, numarul n va primi de fiecare data valoarea cautarilor obtinute, iar resturile vor fi memoate intr-un vector v,
ale carui elemente vor fi apoi afisate in ordinea inversa. Valoarea numarului n citit de la tastatura, o vom retine intr-o
variabila m, tinand cont de faptul ca asupra sa se executa o serie de transformari.
Raw
I.1.a.permutari_circular_dreapta_vector.cpp
// deplasare circular dreapta
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, n, v[100], k, aux;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 100): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// deplaseaza circular la dreapta cu o pozitie elementele vectorului:
// (X1, X2, X3, ..., Xn) => (Xn, X1, X2, ..., Xn-1)
for (k = 1; k <= n; k++) // pentru k=1, n executa
{
// v[n] va fi pastrata in aux:
aux = v[n]; // atribuie aux<-v[n]
// deplaseaza cu o pozitie la dreapta:
for (i = n; i >= 2; i--) // pentru i=n, 2 executa
v[i] = v[i - 1]; // atribuie v[i]<-v[i-1]
v[1] = aux; // atribuie v[1]<-aux
// afisarea vectorului deplasat circular cu o pozitie la dreapta:
cout << "Vectorul obtinut este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
}
} // stop
Raw
I.1.a.permutari_circular_dreapta_vector.doc
Deplaseaza circular dreapta cu o pozitie a elementele vectorului v cu n elemente, fara a folosi un vector suplimentar.
Rezolvare: Pentru a deplasa circular dreapta, cu o pozitie, toate elementele vectorului v, vom pastra valoarea v[n] intr-o
variabila auxiliara, iar celelalte componente ale vectorului v[i] vor primi valoarea v[i-1] (i=n,n-1,...,2).
Raw
I.1.b.permutari_circular_stanga_vector.cpp
// deplasare circular stanga
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, n, v[100], k, aux;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 100): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// deplaseaza circular la dreapta cu o pozitie elementele vectorului:
// (X1, X2, X3, ..., Xn) => (Xn, X1, X2, ..., Xn-1)
for (k = 1; k <= n; k++) // pentru k=1, n executa
{
// v[n] va fi pastrata in aux:
aux = v[1]; // atribuie aux<-v[1]
// deplaseaza cu o pozitie la stanga:
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
v[i] = v[i + 1]; // atribuie v[i]<-v[i+1]
v[n] = aux; // atribuie v[n]<-aux
// afisarea vectorului deplasat circular cu o pozitie la stanga:
cout << "Vectorul obtinut este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
}
} // stop
Raw
I.1.b.permutari_circular_stanga_vector.doc
Deplaseaza circular stanga cu o pozitie a elementele vectorului v cu n elemente, fara a folosi un vector suplimentar.
Rezolvare: Pentru a deplasa circular stanga, cu o pozitie, toate elementele vectorului v, vom pastra valoarea v[1] intr-o
variabila auxiliara, iar celelalte componente ale vectorului v[i] vor primi valoarea v[i+1] (i=1,...,n-1).
Raw
I.2.a.ordonare_cresc_met_interschimbarii_vector.cpp
// metoda interschimbarii
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n, v[20], aux;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// Metoda interschimbarii:
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
for (j = i + 1; j <= n; j++) // pentru j=i+1, n executa
// testeaza ordonarea elementelor:
if (v[i] > v[j]) // daca a[i]>a[j] atunci
{
// schimba elementele intre ele:
aux = v[i]; // atribuie aux<-v[i]
v[i] = v[j]; // atribuie v[i]<-v[j]
v[j] = aux; // atribuie v[j]<-aux
}
// afisarea vectorului ordonat crescator:
cout << "Sirul ordonat crescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.2.a.ordonare_cresc_met_interschimbarii_vector.doc
Ordoneaza crescator, utilizand sortarea prin metoda interschimbarii, elementele unui vector cu n elemente.
Rezolvare: A ordona crescator un sir, inseamna a aseza elementele acestuia in ordine crescatoare. Metoda interschimbarii
parcurge pentru fiecare dintre primele n-1 elemente sirul si le compara cu urmatoarele elemente. Daca 2 elemente nu sunt
asezate corespunzator le schimbam locul intre ele. Pentru a schimba 2 elemente intre ele, se utilizeaza variabila auxiliara
aux, care este de acelasi tip cu elementele sirului.
Parcurgerea si compararea elementelor se face cu ajutorul a 2 structuri repetitive pentru. Dupa iesirea din structurile pentru
se afiseaza sirul ordonat.
Aceasta medota este cea mai simpla modalitate de ordonare a unui vector, dar si cea mai putin eficienta din punct de vedere al
timpului de executie.
Raw
I.2.b.ordonare_descresc_met_interschimbarii_vector.cpp
// metoda interschimbarii
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n, v[20], aux;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// Metoda interschimbarii:
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
for (j = i + 1; j <= n; j++) // pentru j=i+1, n executa
// testeaza ordonarea elementelor:
if (v[i] < v[j]) // daca a[i]>a[j] atunci
{
// schimba elementele intre ele:
aux = v[i]; // atribuie aux<-v[i]
v[i] = v[j]; // atribuie v[i]<-v[j]
v[j] = aux; // atribuie v[j]<-aux
}
// afisarea vectorului ordonat descrescator:
cout << "Sirul ordonat descrescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.2.b.ordonare_descresc_met_interschimbarii_vector.doc
Ordoneaza descrescator, utilizand sortarea prin metoda interschimbarii, elementele unui vector cu n elemente.
Rezolvare: A ordona descrescator un sir, inseamna a aseza elementele acestuia in ordine descrescatoare. Metoda interschimbarii
parcurge pentru fiecare dintre primele n-1 elemente sirul si le compara cu urmatoarele elemente. Daca 2 elemente nu sunt
asezate corespunzator le schimbam locul intre ele. Pentru a schimba 2 elemente intre ele, se utilizeaza variabila auxiliara
aux, care este de acelasi tip cu elementele sirului.
Parcurgerea si compararea elementelor se face cu ajutorul a 2 structuri repetitive pentru. Dupa iesirea din structurile pentru
se afiseaza sirul ordonat.
Aceasta medota este cea mai simpla modalitate de ordonare a unui vector, dar si cea mai putin eficienta din punct de vedere al
timpului de executie.
Raw
I.3.a.ordonare_cresc_met_bulelor_vector.cpp
// metoda bulelor (bubble sort)
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, n, v[20], aux, ordonat;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// Metoda bulelor (bubble sort):
do // executa
{
ordonat = 1; // atribuie ordonat<-1
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
// testeaza ordonarea elementelor:
if (v[i] > v[i + 1]) // daca a[i]>v[i+1] atunci
{
// schimba elementele intre ele:
aux = v[i]; // atribuie aux<-v[i]
v[i] = v[i + 1]; // atribuie v[i]<-v[i+1]
v[i + 1] = aux; // atribuie v[i+1]<-aux
ordonat = 0; // atribuie ordonat<-0
}
} while (!ordonat); // cat timp ordonat<>0
// afisarea vectorului ordonat crescator:
cout << "Sirul ordonat crescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.3.a.ordonare_cresc_met_bulelor_vector.doc
Ordoneaza crescator, ulizand sortarea prin metoda bulelor (bubble sort), elementele unui vector cu n elemente.
Rezolvare: A ordona crescator un sir, inseamna a aseza elementele acestuia in ordine crescatoare. Metoda bulelor
(bubble sort) parcurge sirul dat si ori de cate ori gaseste 2 elemente consecutive care nu sunt asezate corespunzator le
schimba locul intre ele. Operatia se repeta pana cand toate elementele sunt asezate in ordine crescatoare. Pentru a schimba
2 elemente intre ele, se utilizeaza variabila auxiliara aux, care este de acelasi tip cu elementele sirului si variabila
ordonat, care primeste valoarea 0 ori de cate ori se schimba intre ele 2 elemente.
Structura executa permite reluarea parcurgerii sirului (in functie de valoarea variabilei ordonat) pana cand toate elementele
sunt ordonate crescator. Dupa iesirea din structura executa se afiseaza sirul ordonat.
Raw
I.3.b.ordonare_descresc_met_bulelor_vector.cpp
// metoda bulelor (bubble sort)
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, n, v[20], aux, ordonat;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// Metoda bulelor (bubble sort):
do // executa
{
ordonat = 1; // atribuie ordonat<-1
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
// testeaza ordonarea elementelor:
if (v[i] < v[i + 1]) // daca a[i]>v[i+1] atunci
{
// schimba elementele intre ele:
aux = v[i]; // atribuie aux<-v[i]
v[i] = v[i + 1]; // atribuie v[i]<-v[i+1]
v[i + 1] = aux; // atribuie v[i+1]<-aux
ordonat = 0; // atribuie ordonat<-0
}
} while (!ordonat); // cat timp ordonat<>0
// afisarea vectorului ordonat descrescator:
cout << "Sirul ordonat descrescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.3.b.ordonare_descresc_met_bulelor_vector.doc
Ordoneaza descrescator, ulizand sortarea prin metoda bulelor (bubble sort), elementele unui vector cu n elemente.
Rezolvare: A ordona descrescator un sir, inseamna a aseza elementele acestuia in ordine descrescatoare. Metoda bulelor
(bubble sort) parcurge sirul dat si ori de cate ori gaseste 2 elemente consecutive care nu sunt asezate corespunzator le
schimba locul intre ele. Operatia se repeta pana cand toate elementele sunt asezate in ordine descrescatoare. Pentru a schimba
2 elemente intre ele, se utilizeaza variabila auxiliara aux, care este de acelasi tip cu elementele sirului si variabila
ordonat, care primeste valoarea 0 ori de cate ori se schimba intre ele 2 elemente.
Structura executa permite reluarea parcurgerii sirului (in functie de valoarea variabilei ordonat) pana cand toate elementele
sunt ordonate descrescator. Dupa iesirea din structura executa se afiseaza sirul ordonat.
Raw
I.4.a.ordonare_cresc_met_selectiei_vector.cpp
// metoda selectiei (select sort)
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int n, i, j, poz, min, v[20];
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// Metoda selectiei (select sort):
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
{
min = v[i]; // atribuie min<-v[i]
poz = i; // atribuie poz<-i
for (j = i + 1; j <= n; j++) // pentru j=i+1, n executa
// testeaza ordonarea elementelor:
if (v[j] < min) // daca a[j]<min atunci
{
min = v[j]; // atribuie min<-v[j]
poz = j; // atribuie poz<-j
}
v[poz] = v[i]; // atribuie v[poz]<-v[i]
v[i] = min; // atribuie v[i]<-min
}
// afisarea vectorului ordonat crescator:
cout << "Sirul ordonat crescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.4.a.ordonare_cresc_met_selectiei_vector.doc
Ordoneaza crescator, utilizand sortarea prin metoda selectiei (select sort), elementele unui vector cu n elemente.
Rezolvare: A ordona crescator un sir, inseamna a aseza elementele acestuia in ordine crescatoare. Pentru v[i] se
determina elementul minim dintre toate elementele incepand cu pozitia i pana la sfarsitul vectorului. Elementul minim astfel
obtinut se schimba cu valoarea elementului v[i]. Procedeul se aplica primelor n-1 elemente ale vectorului.
Raw
I.4.b.ordonare_descresc_met_selectiei_vector.cpp
// metoda selectiei (select sort)
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int n, i, j, poz, min, v[20];
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// Metoda selectiei (select sort):
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
{
min = v[i]; // atribuie min<-v[i]
poz = i; // atribuie poz<-i
for (j = i + 1; j <= n; j++) // pentru j=i+1, n executa
// testeaza ordonarea elementelor:
if (v[j] > min) // daca a[j]>min atunci
{
min = v[j]; // atribuie min<-v[j]
poz = j; // atribuie poz<-j
}
v[poz] = v[i]; // atribuie v[poz]<-v[i]
v[i] = min; // atribuie v[i]<-min
}
// afisarea vectorului ordonat crescator:
cout << "Sirul ordonat crescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.4.b.ordonare_descresc_met_selectiei_vector.doc
Ordoneaza descrescator, utilizand sortarea prin metoda selectiei (select sort), elementele unui vector cu n elemente.
Rezolvare: A ordona descrescator un sir, inseamna a aseza elementele acestuia in ordine descrescatoare. Pentru v[i] se
determina elementul minim dintre toate elementele incepand cu pozitia i pana la sfarsitul vectorului. Elementul minim astfel
obtinut se schimba cu valoarea elementului v[i]. Procedeul se aplica primelor n-1 elemente ale vectorului.
Raw
I.5.a.ordonare_cresc_met_insertiei_vector.cpp
// metoda insertiei (insert sort)
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, k, n, v[20], aux, gata;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// Metoda insertiei (insert sort):
for (i = 2; i <= n; i++) // pentru i=2, n executa
{
aux = v[i]; // atribuie aux<-v[i]
k = 0; // atribuie k<-0
j = i - 1; // atribuie j<-i-1
gata = 0; // atribuie gata<-0
while ((j >= 1) && (!gata)) // cat timp (j>=1) AND (NOT gata) executa
// testeaza ordonarea elementelor:
if (v[j] > aux) // daca v[j]>aux atunci
{
v[j + 1] = v[j]; // atribuie v[j+1]<-v[j]
// sau v[j + 1] = v[j--];
j = j - 1; // atribuie j<-j-1
// sau j--;
}
else // altfel
{
k = j; // atribuie k<-j
gata = 1; // atribuie gata<-1
}
v[k + 1] = aux; // atribuie v[k+1]<-aux
}
// afisarea vectorului ordonat crescator:
cout << "Sirul ordonat crescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.5.a.ordonare_cresc_met_insertiei_vector.doc
Ordoneaza crescator, utilizand sortarea prin metoda insertiei (insert sort), elementele unui vector cu n elemente.
Rezolvare: A ordona crescator un sir, inseamna a aseza elementele acestuia in ordine crescatoare. Consideram un subsir
crescator (are proprietatea v[1]<=v[2]<=...<=v[i-1] 1<=i<=n) al sirului initial. Sortarea prin insertie consta in inserarea in
subsirul v[1]<=v[2]<=...<=v[i-1] a elementului v[i]. Astfel, vom compara pe v[i] cu v[i-1], v[i-2], ..., v[1] pana cand se
ajunge la o pozitie j, astfel inca v[j]<=v[i]. Deci, vom insera pe v[i] dupa v[j], fapt ce implica deplasarea spre dreapta a
unei secvente. Initial subsirul crescator este format din primul element al sirului.
Raw
I.5.b.ordonare_descresc_met_insertiei_vector.cpp
// metoda insertiei (insert sort)
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, k, n, v[20], aux, gata;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// Metoda insertiei (insert sort):
for (i = 2; i <= n; i++) // pentru i=2, n executa
{
aux = v[i]; // atribuie aux<-v[i]
k = 0; // atribuie k<-0
j = i - 1; // atribuie j<-i-1
gata = 0; // atribuie gata<-0
while ((j >= 1) && (!gata)) // cat timp (j>=1) AND (NOT gata) executa
// testeaza ordonarea elementelor:
if (v[j] < aux) // daca v[j]<aux atunci
{
v[j + 1] = v[j]; // atribuie v[j+1]<-v[j]
// sau v[j + 1] = v[j--];
j = j - 1; // atribuie j<-j-1
// sau j--;
}
else // altfel
{
k = j; // atribuie k<-j
gata = 1; // atribuie gata<-1
}
v[k + 1] = aux; // atribuie v[k+1]<-aux
}
// afisarea vectorului ordonat crescator:
cout << "Sirul ordonat descrescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << v[i] << " "; // scrie v[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.5.b.ordonare_descresc_met_insertiei_vector.doc
Ordoneaza descrescator, utilizand sortarea prin metoda insertiei (insert sort), elementele unui vector cu n elemente.
Rezolvare: A ordona descrescator un sir, inseamna a aseza elementele acestuia in ordine descrescatoare. Consideram un subsir
crescator (are proprietatea v[1]<=v[2]<=...<=v[i-1] 1<=i<=n) al sirului initial. Sortarea prin insertie consta in inserarea in
subsirul v[1]<=v[2]<=...<=v[i-1] a elementului v[i]. Astfel, vom compara pe v[i] cu v[i-1], v[i-2], ..., v[1] pana cand se
ajunge la o pozitie j, astfel inca v[j]<=v[i]. Deci, vom insera pe v[i] dupa v[j], fapt ce implica deplasarea spre dreapta a
unei secvente. Initial subsirul descrescator este format din primul element al sirului.
Raw
I.6.a.ordonare_cresc_met_numararii_vector.cpp
// metoda numararii (counting sort)
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n, a[20], b[20], k[20];
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului a (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului a: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "a[" << i << "] = "; cin >> a[i]; // citeste a[i]
}
// Metoda numararii (counting sort):
for (i = 1; i <= n; i++) // pentru i=1, n executa
k[i] = 0; // atribuie k[i]<-0
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
for (j = i + 1; j <= n; j++) // pentru j=1+1, n executa
// testeaza ordonarea elementelor:
if (a[i] < a[j]) // daca a[i]<a[j] atunci
k[j]++; // atribuie k[j]<-k[j]+1
// sau k[j] = k[j] + 1;
else // altfel
k[i]++; // atribuie k[i]<-k[i]+1
// sau k[i] = k[i] + 1;
for (i = 1; i <= n; i++) // pentru i=1, n executa
b[k[i] + 1] = a[i]; // atribuie b[k[i]+1]<-a[i]
for (i = 1; i <= n; i++) // pentru i=1, n executa
a[i] = b[i]; // atribuie a[i]<-b[i]
// afisarea vectorului ordonat crescator:
cout << "Sirul ordonat crescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << a[i] << " "; // scrie a[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.6.a.ordonare_cresc_met_numararii_vector.doc
Ordoneaza crescator, utilixzand sortarea prin metoda numararii (counting sort), elementele unui vector cu n elemente.
Rezolvare: A ordona crescator un sir, inseamna a aseza elementele acestuia in ordine crescatoare.
Se numara pentru fiecare element a[i] din vectorul sortat cate elemente mai mici ca el exista. Aceste numere sunt memorate
intr-un vector k. Pe baza acestui vector se rearanjeaza elementele vectorului a pentru a forma un vector b, care se va copia
apoi in a.
Raw
I.6.b.ordonare_descresc_met_numararii_vector.cpp
// metoda numararii (counting sort)
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n, a[20], b[20], k[20];
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului a (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului a: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "a[" << i << "] = "; cin >> a[i]; // citeste a[i]
}
// Metoda numararii (counting sort):
for (i = 1; i <= n; i++) // pentru i=1, n executa
k[i] = 0; // atribuie k[i]<-0
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
for (j = i + 1; j <= n; j++) // pentru j=1+1, n executa
// testeaza ordonarea elementelor:
if (a[i] > a[j]) // daca a[i]>a[j] atunci
k[j]++; // atribuie k[j]<-k[j]+1
// sau k[j] = k[j] + 1;
else // altfel
k[i]++; // atribuie k[i]<-k[i]+1
// sau k[i] = k[i] + 1;
for (i = 1; i <= n; i++) // pentru i=1, n executa
b[k[i] + 1] = a[i]; // atribuie b[k[i]+1]<-a[i]
for (i = 1; i <= n; i++) // pentru i=1, n executa
a[i] = b[i]; // atribuie a[i]<-b[i]
// afisarea vectorului ordonat descrescator:
cout << "Sirul ordonat descrescator este: ";
for (i = 1; i <= n; i++) // pentru i=1, n executa
cout << a[i] << " "; // scrie a[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.6.b.ordonare_descresc_met_numararii_vector.doc
Ordoneaza descrescator, utilixzand sortarea prin metoda numararii (counting sort), elementele unui vector cu n elemente.
Rezolvare: A ordona descrescator un sir, inseamna a aseza elementele acestuia in ordine descrescatoare.
Se numara pentru fiecare element a[i] din vectorul sortat cate elemente mai mici ca el exista. Aceste numere sunt memorate
intr-un vector k. Pe baza acestui vector se rearanjeaza elementele vectorului a pentru a forma un vector b, care se va copia
apoi in a.
Raw
I.7.interclasare_vector.cpp
// interclasare (merge sort)
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int n, m, i, j, k, a[20], b[20], c[40];
// citirea vectorilor:
cout << "Introduceti dimensiunile celor 2 vectori a si b: \n";
// citirea dimensiunilor vectorilor a si b:
cout << "n = "; cin >> n; // citeste n
cout << "m = "; cin >> m; // citeste m
// citirea elementelor vectorului a:
cout << "Introduceti elementele vectorilor a si b: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "a[" << i << "] = "; cin >> a[i]; // citeste a[i]
}
// citirea elementelor vectorului b:
for (j = 1; j <= m; j++) // pentru i=1, m executa
{
cout << "b[" << j << "] = "; cin >> b[j]; // citeste a[j]
}
// incepe cu prima pozitie in a, b, c:
k = 0; // atribuie k<-0
i = 1; // atribuie i<-1
j = 1; // atribuie j<-1
// Metoda interclasarii (merge sort):
while (i <= n && j <= m) // cat timp i<=n SI j<=m executa
{
k++; // atribuie k<-k+1
// sau k = k + 1;
if (a[i] < b[j]) // daca a[i]<b[j] atunci
{
// muta in c valoarea a[i]:
c[k] = a[i]; // atribuie c[k]<-a[i]
// trece la elemntul a[i+1]:
i++; // atribuie i<-i+1
// sau i = i + 1;
// sau c[++k] = a[i++];
}
else // altfel
{
// muta in c valoarea b[j]:
c[k] = b[j]; // atribuie c[k]<-b[j]
// trece la elemntul b[j+1]:
j++; // atribuie j<-j+1
// sau j = j + 1;
// sau c[++k] = b[j++];
}
}
// testeaza daca a fost parcurs tot vectorul a:
if (i <= n) // daca i<=n atunci
// trece in c elementele ramase din a:
for (j = i; j <= n; j++) // pentru j=i, n executa
{
k++; // atribuie k<-k+1
// sau k = k + 1;
c[k] = a[j]; // atribuie c[k]<-a[j]
// sau c[++k] = a[j];
}
else // altfel
// trece in c elementele ramase din b:
for (i = j; i <= m; i++) // pentru i=j. m executa
{
k++; // atribuie k<-k+1
// sau k = k + 1;
c[k] = b[i]; // atribuie c[k]<-b[i]
// sau c[++k] = b[i];
}
// afisarea vectorului c:
cout << "Vectorul c interclasat este: ";
for (i = 1; i <= n + m; i++) // pentru i=1, n executa
cout << c[i] << " "; // scrie c[i]
// trece pe linia urmatoare:
cout << endl;
} // stop
Raw
I.7.interclasare_vector.doc
Interclaseaza 2 vectori ordonati crescator, nu neaparat de aceeasi lungime, utlizand metoda interclasarii (merge sort).
Rezolvare: Problema se poate rezolva astfel:
- se porneste in cei 2 vectori de pe prima pozitie, si atata timp cat nu am parcurs niciunul dintre vectori, comaparam
valorile acestora transferand cea mai mica valoare in vectorul c;
- dupa ce am parcurs unul dintre cei 2 vectori, elementele ramase din celalalt vector vor fi transferate in vectorul c in
ordinea existenta.
Raw
J.1.cautare_secventiala_vector.cpp
// cautare secventiala
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
int main()
{
// declarare variabile:
int n, v[20], i, ok, x;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// citirea valorii x:
cout << "x = "; cin >> x; // citeste x
// initializeaza i cu 1:
i = 1; // atribuie i<-1
// initializeaza variabila logica ok cu FALSE:
ok = 0; // atribuie ok<-FALSE
// Metoda cautarii secventiale:
while ((i <= n) && !ok) // cat timp i<=n SI NOT ok executa
{
if (v[i] == x) // daca v[i]=x atunci
ok = 1; // atribuie ok<-TRUE
else // altfel
i++; // atribuie i<-i+1
// sau i = i + 1;
}
// afisarea rezultatului:
if (ok) // daca ok=TRUE atunci
cout << "Valoarea " << x << " este in sir. \n"; // scrie 'x este in sir'
else // altfel
cout << "Valoarea " << x << " nu este in sir. \n"; // scrie 'x nu este in sir'
} // stop
Raw
J.1.cautare_secventiala_vector.doc
Indica daca o valoarea x, dintr-un vector cu n elemente neordonate, se găseşte sau nu printre elementele vectorului utlizand
metoda cautarii secventiale.
Rezolvare: Cautarea secventiala presupune parcurgerea vectorului element cu element, cu conditia ca in momentul in care
elementul cautat s-a gasit, cautarea se opreste. Pentru acesta se foloseste variabila ok, care se initializeaza cu 0 (cu
semnificatia ca la inceput presupunem ca elementul cautat nu exista in vector), iar la o comparare daca elementul cautat
exista ok=1 (adica presupunerea a fost falsa, deci elementul exista).
Raw
J.2.cautare_binara_vector.cpp
// cautare binara
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, n, v[20], x, st, dr, m, ok;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// citirea valorii x:
cout << "x = "; cin >> x; // citeste x
// initializeaza marginea din stanga cu 1:
st = 1; // atribuie st<-1 // initializeaza marginea din dreapta cu n:
dr = n; // atribuie dr<-n
// initializeaza variabila logica ok cu FALSE:
ok = 0; // atribuie ok<-FALSE
// Metoda injumatatirii intervalului (cautarea binara):
while ((st <= dr) && !ok) // cat timp st<=dr SI NOT ok executa
{
// injumatateste intervalul (st, dr):
m = (st + dr) / 2; // atribuie m<-[(st+dr)/2]
if (x == v[m]) // daca x=v[m] atunci
ok = 1; // atribuie ok<-TRUE
else // altfel
/* testeaza daca v este in dreapta elementului din mijloc,
cautarea continuand in jumatatea dreapta, altfel in cea stanga */
if (x > v[m]) // daca x=v[m] atunci
st = m + 1; // atribuie st<-m+1
else // altfel
dr = m - 1; // atribuie dr<-m-1
}
// afisarea rezultatului:
if (ok) // daca ok=TRUE atunci
cout << "Valoarea " << x << " este in sir pe pozitia " << m << endl; // scrie 'x este pe pozitia m'
else // altfel
cout << "Valoarea " << x << " nu este in sir. \n"; // scrie 'x nu este in sir'
} // stop
Raw
J.2.cautare_binara_vector.doc
Indica daca o valoarea x, dintr-un vector cu n elemnte ordonat crescator, exista in sir, daca da, precizeaza pe ce pozitie se
afla utilizand metoda cautarii binare.
Rezolvare: Metoda injumatatirii intervalului sau cautarea binara presupune:
- se initializeaza marginea din stanga cu 1 (st<-1) si pe cea din dreapta cu n (dr<-n), variabila logica ok luand valoarea
FALSE;
- cat timp nu s-a gasit valoarea cautata si marginea din stanga nu depaseste pe cea din dreapta (st<=dr), se injumatateste
intervalul (st, dr) si se testeaza daca valoarea cautata este chiar la jumatatea intervalului;
- daca valoarea v se gaseste la jumatatea intervalului (st, dr) atunci variabila logica ok primeste valoarea TRUE; in caz
contrar se continua cautarea in partea stanga (dr<-m-1), daca valoarea v este mai mica decat valoarea de la jumatatea
intervalului sau in partea dreapta (st<-m+1), daca valoarea v este mai mare decat valoarea de la jumatatea intervalului;
- algoritmul se repeta pana cand se gaseste valoarea cautata sau pana cand marginea din stanga depaseste marginea din dreapta
(st>dr).
Raw
K.palindrom_vector.cpp
// palindrom
// includere fisiere cu declaratii:
#include <iostream>
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, n, k;
long v[20], nr, nr_inv;
// citirea vectorului:
cout << "Introduceti dimensiunea vectorului v (max 20): \n";
// citirea dimensiunii vectorului:
cout << "n = "; cin >> n; // citeste n
// citirea elementelor vectorului:
cout << "Introduceti elementele vectorului v: \n";
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
cout << "v[" << i << "] = "; cin >> v[i]; // citeste v[i]
}
// initializeaza k cu 0:
k = 0; // atribuie k<-0
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
nr = v[i]; // atribuie nr<-v[i]
nr_inv = 0; // atribuie nr_inv<-0
while (nr != 0) // cat timp nr<>0 executa
{
// calculul inversului lui nr:
nr_inv = nr_inv * 10 + nr % 10; // atribuie nr_inv<-nr_inv*10+nr%10
nr /= 10; // atribuie nr<-[nr/10]
// sau nr = nr / 10;
}
// testeaza daca numarul este palindrom:
if (v[i] == nr_inv) // daca v[i]=nr_inv atunci
k++; // atribuie k<-k+1
// sau k = k + 1;
}
// afisarea numarului numerelor palindrom:
cout << "Sunt " << k << " numere palindrom. \n"; // scrie k
} // stop
Raw
K.palindrom_vector.doc
Citeste o succesiune de numere naturale si determina cate dintre acestea sunt palindrom.
Rezolvare: Spunem ca numarul n este palindrom, daca este egal cu numarul format din cifrele sale citite de la dreapta spre
stanga. Pentru a rezolva problema data, vom testa daca fiecare numar din sir este palindrom, si de cate ori gasim un astfel
de numar il contorizam in variabila k.
Raw
M.puncte_vector.cpp
// distanta dintre puncte
// includere fisiere cu declaratii:
#include <iostream>
#include <cmath> // math.h pentru C
using namespace std;
// functia principala:
int main()
{
// declarare variabile:
int i, j, n;
float max, d, a[20], b[20];
// citirea numarului de puncte:
cout << "Introduceti numarul de puncte: \n";
cout << "n = "; cin >> n; // citeste n
// citirea coordonatelor punctelor:
for (i = 1; i <= n; i++) // pentru i=1, n executa
{
// memoreaza coordonatele celor n puncte in 2 vectori a si b:
cout << "Punctul " << i << " are coordonatele: "; cin >> a[i] >> b[i]; // citeste a[i], b[i]
}
// initializeaza max cu 0:
max = 0; // atribuie max<-0
// calculul distantelor dintre puncte:
for (i = 1; i <= n - 1; i++) // pentru i=1, n-1 executa
for (j = i + 1; j < n; j++) // pentru j=i+1, n executa
{
d = sqrt((a[i] - a[j]) * (a[i] - a[j]) + (b[i] - b[j]) * (b[i] - b[j])); // atribuie d<-sqrt(a[i]-a[j])^2+(b[i]-b[j])^2
if (d > max) // daca d>max atunci
max = d; // atribuie max<-d
}
// afisarea distantei maxime:
cout << "Distanta maxima este " << max << endl; // scrie max
} // stop
Raw
M.puncte_vector.doc
Determina cea mai mare distanta dintre punctele in plan A1,A2,...,An date prin coordonatele carteziene.
Rezolvare: Pentru rezolvarea problemei, se memoreaza coordonatele celor n puncte in 2 vectori a si b, primul pastrand
abcisele, iar cel de-al doilea ordonatele punctelor. Se calculeaza distantele dintre puncte, distante care se compara cu
valoarea variabilei max, care initial primeste 0, dar care in final va pastra valoarea celor mai mari distante calculate.
Distanta dintre 2 puncte A(x1,y1) si B(x2,y2) este data de formula: d=sqrt(a[i]-a[j])^2+(b[i]-b[j])^2.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment