LABORATORUL 10"

Prob 1 - Lab 8: determinarea mediei valorilor poz/neg dintr-un tablou, cu pointeri:

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define dim 100
void citire(int* p, int n);
double mediepoz(int* p, int n);
double medieneg(int* p, int n);
void main()
{
int x[dim], n, * p;
double mp, mn;
printf("\n n = ");
scanf("%d", &n);
if (n > dim)
printf("\nAti introdus o dimensiune prea mare!");
p = x;
citire(p, n);
mp = mediepoz(p, n);
printf("\nValoarea medie a elementelor pozitive din tablou este %lf", mp);
mn = medieneg(p, n);
printf("\nValoarea medie a elementelor negative din tablou este: %lf", mn);
}
void citire(int* p, int n)
{
for (int i = 0; i < n; i++)
{
printf("\n x[%d] = ", i);
scanf("%d", p + i);
}
}
double mediepoz(int* p, int n)
{
int i, sp=0, cp=0;
double mp;
for (i = 0; i < n; i++)
{
if (*(p + i) > 0)
{
sp = sp + *(p + i);
cp++;
}
}
if (cp != 0)
mp = (double)sp / cp;
return mp;
}
double medieneg(int* p, int n)
{
int i, sn=0, cn=0;
double mn;
for (i = 0; i < n; i++)
{
if (*(p + i) < 0)
{
sn = sn + *(p + i);
cn++;
}
 }
if (cn != 0)
mn = (double)sn / cn;
return mn;
}

Prob 2 - Lab 8: Scrieti un program pentru determinarea celui mai mic element
pozitiv dintr-un tablou unidimensional, cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define dim 100
void citire(int*, int);
int elem_min(int*, int);
int main()
{
int a[dim], n, * p, m;
printf("Introduceti numarul elementelor: ");
scanf("%d", &n);
p = a;
citire(p, n);
m = elem_min(p, n);
printf("\n Elementul minim este: %d", m);
}
void citire(int* p, int n)
{
int i;
for (i = 0; i < n; i++)
{
printf("\n a[%d] = ", i);
scanf("%d", p + i);
}
}
int elem_min(int* p, int n)
{
int min = *p, i;
while (min < 0)
min = *p++;
for (i = 0; i < n; i++)
if (*(p + i) < min && *(p + i) > 0)
min = *(p + i);
return min;
}

Prob 3 - Lab 8: Scrieti o aplicatie C/C++ care citeste de la tastatura un sir de 10

valori intregi.
Definiti o functie care primeste sirul ca parametru si apoi �l afiseaza ordonat
crescator, cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<conio.h>
#define dim 10
void citire(int* p);
void ordonare_crescatoare(int* p);
void afisare(int* p);
void main()
{
int v[dim], * p;
p = v;
citire(p);
 ordonare_crescatoare(p);
printf("Sirul ordonat crescator este: \n");
afisare(p);
_getch();
}
void citire(int* p)
{
int i;
for (i = 0; i < dim; i++)
{
printf("\n x[%d] = ", i);
scanf("%d", p + i);
}
}
void ordonare_crescatoare(int* p)
{
int i, j, aux;
for (i = 0; i < dim - 1; i++)
for (j = i + 1; j < dim; j++)
if (*(p + i) > * (p + j))
{
aux = *(p + i);
*(p + i) = *(p + j);
*(p + j) = aux;
}
}
void afisare(int* p)
{
int i;
for (i = 0; i < dim; i++)
{
printf("%d ", *(p + i));
}
}

Prob 4 - Lab 8: Scrieti o aplicatie C/C++ care defineste o parola (in format sir de
caractere). Programul citeste �n
mod repetat sirurile de caractere introduse de la tastatura, p�na c�nd utilizatorul
scrie parola corecta.
Sa se afiseze numarul de incercari p�na la introducerea parolei corecte, cu
pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#include <cstring>
#define dim 20
#define parola "amuitatparola"
void main()
{
char s[dim];
int ok = 1, x = 1;
do {
printf("\nIntroduceti parola:\n");
scanf("%s", s);
if (strlen(s) > dim)
{
printf("Parola depaseste numarul maxim de caractere!\n");
 _getch();
return;
}
else
{
if (strcmp(s, parola) == 0)
{
printf("Ati introdus parola corecta!\nNumarul de incercari
este de %d.", x);
ok = 0;
break;
}
else
{
x++;
printf("Parola introdusa este gresita. Incercati din
nou!\n");
}
}
} while (ok = 1);
_getch();
}

Prob 5 - Lab 8: Scrieti o aplic C/C++ care citeste de la tastatura doua siruri de
caractere reprezentand numele si prenumele unei persoane.
Afisati-le cu majuscula, separate prin doua spatii de tabulare., cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main()
{
char nume[20], prenume[20], * p1, * p2;
p1 = nume;
p2 = prenume;
printf("\nNumele: ");
scanf("%s", nume);
printf("\nPrenumele: ");
scanf("%s", prenume);
*(p1 + 0) = *(p1 + 0) - 32;
*(p2 + 0) = *(p2 + 0) - 32;
for (int i = 0; i < strlen(nume); i++)
printf("%c", *(p1 + i));
printf("\t");
for (int i = 0; i < strlen(prenume); i++)
printf("%c", *(p2 + i));
_getch();
}

Prob 6 - Lab 8: Scrieti o aplicatie C/C++ care defineste doua matrici de valori
intregi.
Dimensiunea si elementele matricilor sunt citite de la tastatura. Scrieti functiile
care:
a) afiseaza pozitiile elementelor pare din fiecare matrice;
b) afiseaza suma elementelor impare din ambele matrice;
c) afiseaza suma matricelor cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<conio.h>
void citire(int* p1, int n, int m);
void afisare_pozitii(int* p1, int n, int m);
int suma_elemimpare(int* p1, int n, int m);
void suma_matrici(int* p1, int n, int m, int* p2, int p, int q);
void main()
{
int a[100][100], b[100][100], n, m, p, q, * p1, * p2;
p1 = &a[0][0];
p2 = &b[0][0];
printf("Dimensiunea primei matrici: ");
scanf("%d %d", &n, &m);
printf("\nDimensiunea celei de a doua matrici: ");
scanf("%d %d", &p, &q);
printf("\nIntroduceti prima matrice: \n");
citire(p1, n, m);
printf("\nIntroduceti cea de-a doua matrice: \n");
citire(p2, p, q);
printf("\nPozitiile elementelor pare din fiecare matrice(cu indici de la
0): \n");
printf("Din prima matrice:\n");
afisare_pozitii(p1, n, m);
printf("Din cea de-a doua matrice:\n");
afisare_pozitii(p2, p, q);
printf("\nSuma elementelor impare din ambele matrici: \n");
printf("Suma elementelor impare din prima matrice este: %d\n",
suma_elemimpare(p1, n, m));
printf("Suma elementelor impare din prima matrice este: %d\n",
suma_elemimpare(p2, p, q));
suma_matrici(p1, n, m, p2, p, q);
_getch();
}
void citire(int* p1, int n, int m)
{
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
scanf("%d", p1 + i * m + j);
}
void afisare_pozitii(int* p1, int n, int m)
{
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (*(p1 + i * m + j) % 2 == 0)
printf("(%d, %d)\n", i, j);
}
int suma_elemimpare(int* p1, int n, int m)
{
int s = 0, i, j;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (*(p1 + m * i + j) % 2 == 1)
s += *(p1 + i * m + j);
return s;
}
void suma_matrici(int* p1, int n, int m, int* p2, int p, int q)
{
if (n != p || m != q)
printf("\nMatricile nu sunt de aceeasi dimensiune!");
 else
{
int z[100][100] = { 0 }, * p3, i, j;
p3 = &z[0][0];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
*(p3 + i * m + j) = *(p1 + i * m + j) + *(p2 + i * m + j);

printf("\nSuma celor doua matrici este matricea rezultanta:\n");

for (i = 0; i < n; i++)
{
for ( j = 0; j < m; j++)
printf("%d ", *(p3 + i * m + j));
printf("\n");
}
}
}

Prob 7 - Lab 8: Cititi de la tastatura elementele unei matrice cu elemente de tip

float, cu dimensiunea 3x3.
Rearanjati col matricei astfel ca suma elem de pe o anumita col sa fie mai mica
decat suma elem de pe coloana urmatoare, cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<conio.h>
void citire(float* p);
float suma_col(float* p, int j);
void interschimbare(float* p, int j, int k);
void afisare(float* p);
void main()
{
float x[3][3], s[3] = {0}, * p;
int i, j;
p = &x[0][0];
printf("Cititi matricea:\n");
citire(p);
for (j = 0; j < 2; j++)
{
for (i = j + 1; i < 3; i++)
if (suma_col(p, j) > suma_col(p, i))
interschimbare(p, j, i);
}
printf("\nMatricea rearanjata dupa proprietatea ceruta: \n");
afisare(p);
_getch();
}
void citire(float* p)
{
int i, j;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
scanf("%f", p + i * 3 + j);
}
float suma_col(float* p, int j)
{
float s = 0.0;
int i;
for (i = 0; i < 3; i++)
s += *(p + i * 3 + j);
 return s;
}
void interschimbare(float* p, int j, int k)
{
int i;
float aux;
for (i = 0; i < 3; i++)
{
aux = *(p + i * 3 + j);
*(p + i * 3 + j) = *(p + i * 3 + k);
*(p + i * 3 + k) = aux;
}
}
void afisare(float* p)
{
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
printf("%.2f ", *(p + i * 3 + j));
printf("\n");
}
}

Prob 8 - Lab 8: Scrieti un program care pria de la tastatura �n� valori reale �ntr-
un tablou unidimensional,
calculeaza cu o fct val medie a valorilor introduse si afis cu o alta fct doar val
din tablou > dec�t val medie calculata, cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
double valoarea_medie(double* p, int n);
void afisare(double* p, int n, double medie);
void main()
{
int n, i;
double x[100], * p;
p = x;
printf("\nNumarul de valori este: ");
scanf("%d", &n);
printf("\nValorile din tablou: \n");
for (i = 0; i < n; i++)
scanf("%lf", p + i);
printf("\nValorile din tablou mai mare decat valoarea medie %f sunt:\n",
valoarea_medie(p, n));
afisare(p, n, valoarea_medie(p, n));
}
double valoarea_medie(double* p, int n)
{
double s = 0.0;
int i;
for (i = 0; i < n; i++)
s += *(p + i);
return double(s) / n;
}
void afisare(double* p, int n, double medie)
{
int i;
for (i = 0; i < n; i++)
 if (*(p + i) > medie)
printf("%lf ", *(p + i));
}

Prob 9 _ Lab 8: Sa se scrie o aplic C/C++ �n care se cit �ntr-un tablou

unidimensional �n� val �ntregi si se determina nr elem neg impare.
Sa se afiseze acest numar si elementele respective, cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main()
{
int n, v[50], j, i, * p;
printf("\nIntroduceti numarul de elemente ale tabloului: ");
scanf("%d", &n);

if (n > 100)
printf("\nNr de elem este prea mare!");

p = v;

printf("\nIntroduceti elementele tabloului: ");

for (i = 0; i < n; i++)
{
printf("\nElementul %d:", i + 1);
scanf("%d", p + i);
}

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

{
if ((p + i) >= 0 || ((p + i) <= 0 && *(p + i) % 2 == 0))

{
for (j = i; j < n; j++)
*(p + j) = *(p + j + 1);
n--;
i--;

}
}
if (n != 0)
{
printf("\nElem negative si impare din tablou sunt in numar de: %d", n);
printf("\nElem sunt: ");
for (i = 0; i < n; i++)
printf("%d ", *(p + i));
}
else
printf("\nNu sunt elem impare si negative in vector!");

Prob 10 - Lab 8: Scrieti programul care cit elem �ntregi ale unui tablou unidimens
si construieste �ntr-o fct un alt tablou unidimens
�n care se vor stoca resturile �mpartirii elem primului tablou la nr elem poz din
acesta, cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void f(int*, int n, int*);
int main()
{
int n, a[30], b[30], i, * p, * t;
printf("\n n= ");
scanf("%d", &n);
p = a;
t = b;
printf("\nIntroduceti elementele tabloului: ");
for (i = 0; i < n; i++)
{
printf("\nElementul %d este:", i + 1);
scanf("%d", p + i);
}
f(a, n, b);
printf("\nResturile impartirii elem tabloului la nr elem poz din tablou sunt:
\n");
for (i = 0; i < n; i++)
printf("%d ", *(t + i));
}
void f(int* p, int n, int* t)
{
int i, x = 0;
for (i = 0; i < n; i++)
if (*(p + i) >= 0)
x++;
for (i = 0; i < n; i++)
*(t + i) = *(p + i) % x;
}

Prob 11 - Lab 8: Se citeste de la tastatura un sir de caractere. Scrieti functia

care inverseaza sirul si
apoi formeaza un alt sir de caractere ce va contine elementele de pe pozitiile pare
ale sirului inversat.
Afisati sirurile obtinute. Cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<conio.h>
void transformare(char* s1, char* s2, int n);
void main()
{
char s[100], s2[100], * S1, * S2;
int n;
printf("\nIntroduceti sirul de caractere: \n");
scanf("%s", s);
n = strlen(s);
S1 = s;
S2 = s2;
transformare(S1, S2, n);
_getch();
}
void transformare(char* s1, char* s2, int n)
{
int k = 0, i;
char c;
for (i = 0; i < n / 2; i++)
 {
c = *(s1 + i);
*(s1 + i) = *(s1 + n - i - 1);
*(s1 + n - i - 1) = c;
}
for (i = 0; i < n; i++)
{
if (i % 2 == 0) {
*(s2 + k) = *(s1 + i);
k++;
}
}
printf("\nSirul inversat este: \n");
for (i = 0; i < n; i++)
printf("%c", *(s1 + i));
printf("\nSirul format din elementele de pe pozitiile pare ale sirului
format:\n");
for (i = 0; i < k; i++)
printf("%c", *(s2 + i));
}

Prob 12 - Lab 8: Sa se citeasca de la tastatura elem �ntregi ale unei matrice de

dimensiune m x n.
Daca matricea este patratica sa se afiseze elementele diagonalei secundare, altfel
sa se afiseze suma elem de pe o coloana data, c.
Valorile m, n si c se citesc de la tastatura si se vor scrie functii pentru
operatiile cerute, cu pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<conio.h>
#define dim 100
#define DIM 100
void afisare_diag_sec(int* t, int n);
void suma_col(int* t, int n, int c);
void main()
{
int n, m, c, v[dim][DIM], * t, i, j;
t = &v[0][0];
printf("Introduceti dimensiunea matricii:\n");
scanf("%d %d", &n, &m);
if (n > dim || m > DIM)
{
printf("Dimensiunea matricii este prea mare!");
_getch();
return;
}
printf("\nIntroduceti coloana:\n");
scanf("%d", &c);
if (c > m)
{
printf("Coloana introdusa nu se afla in matrice!");
_getch();
return;
}
printf("\nCititi matricea:\n");
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++)
 {
scanf("%d", t + i * m + j);
}
}
if (n == m)
afisare_diag_sec(t, n);
else
suma_col(t, n, c);
_getch();
}
void afisare_diag_sec(int* t, int n)
{
int i;
printf("\nAvem o matrice patratica, asa ca afisam elem de pe diag
secundara:\n");
for (i = 0; i < n; i++)
printf("x[%d][%d]=%d\n", i, n - i - 1, *(t + i * n + (n - i - 1)));
}
void suma_col(int* t, int n, int c)
{
int s = 0, i;
for (i = 0; i < n; i++)
s += *(t + i * n + (c - 1));
printf("\nAvem o matrice n x m, cu n!=m, asa ca afisam suma elem de pe
coloana data: %d", s);
}

Prob 2: Se considera doi parametri �ntregi si alti doi flotanti din linia de
comanda. Sa se afiseze suma si produsul lor:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void main(int argc, char* argv[])
{
int n = atoi(argv[1]);
int m = atoi(argv[2]);
printf("\n\tSuma argumentelor intregi din linia de comanda: %d", n + m);
printf("\n\tProdusul argumentelor intregi din linia de comanda: %d", n * m);
double p = atof(argv[3]);
double q = atof(argv[4]);
printf("\n\tSuma argumentelor double din linia de comanda: %lf", p + q);
printf("\n\tProdusul argumentelor double din linia de comanda: %lf", p * q);
}

Prob 3: Scrieti o aplicatie care citeste de la tastatura un sir de caractere cu

lungimea mai mare dec�t 7.
Folositi un pointer pt. a accesa si afisa caracterele de pe pozitiile 1, 3, 5 si 7:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main(int argc, char* argv[])
{
char s[20], * p;
strcpy(s, argv[1]);
p = s;
if (strlen(s) < 7) {
printf("\nSirul de caractere are lungimea prea mica!");
return;
 }
for (int i = 0; i < 8; i++)
if (i % 2 == 1)
printf("%c", *(p + i));
}

Prob 4: Cititi de la tastatura elementele a 2 matrici de valori �ntregi.

Scrieti o functie care primeste ca parametri pointerii la cele 2 matrici si
returneaza un pointer la matricea suma.
Rezultatul �nsumarii matricelor va fi afisat �n functia main.
Afisati elementele de pe diagoanala secundara a matricii suma, folosind acelasi
pointer:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <conio.h>
#define max 20
void afisare(int* p, int n, int m);
int* suma(int* a, int* b, int* ps, int n, int m);
void main()
{
int x[max][max], y[max][max], z[max][max], n, m, p, q, i, j;
printf("Introduceti dimensiunile primei matrici:\n");
scanf("%d %d", &n, &m);
printf("\nIntroduceti dimensiunile celei de-a doua matrici:\n");
scanf("%d %d", &p, &q);
if (n > 20 || m > 20 || p > 20 || q > 20)
printf("\nDimensiunile matricelor introduse sunt prea mari!");

int* a, * b, * ps;
a = &x[0][0];
b = &y[0][0];
ps = &z[0][0];
printf("\nIntroduceti prima matrice:\n");
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
scanf("%d", a + i * m + j);
printf("\nIntroduceti cea de-a doua matrice:\n");
for (i = 0; i < p; i++)
for (j = 0; j < q; j++)
scanf("%d", b + i * q + j);
if (n == p && m == q)
{
ps = suma(a, b, ps, n, m);
printf("\nAfisare matricea suma:\n");
afisare(ps, n, m);
if (n == m)
{
printf("Elementele de pe diagonala secundara a matricii suma
sunt:\n");
for (i = 0; i < n; i++)
printf("%d ", *(ps + i * n + (n - i - 1)));
printf("\n");
}
else printf("\nMatricea suma nu este patratica, deci nu are diagonala
secundara.");
}
else printf("\nMatricile nu au aceleasi dimensiuni, deci nu putem calcula
matricea suma!");
}
void afisare(int* p, int n, int m)
{
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++)
printf("%d ", *(p + i * m + j));
printf("\n");
}
}
int* suma(int* a, int* b, int* ps, int n, int m)
{
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
*(ps + i * m + j) = *(a + i * m + j) + *(b + i * m + j);
return ps;
}

Prob 5: Definiti un tablou de pointeri catre siruri de caractere.

Fiecare locatie a tabloului contine adrese catre unul din urmatoarele siruri de
caractere:
- "valoare prea mica"
- "valoare prea mare"
- "valoare corecta"
Aplic genereaza un nr aleator �ntre 1 si 100 si apoi cit �n mod repetat intrarea de
la tastatura p�na c�nd utilizatorul intro val corecta.
Folositi msj definite pentru a informa utilizatorul, la fiecare pas, despre relatia
existenta �ntre nr generat si ultima val citita:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define max 20
void main()
{

char s1[] = "valoare prea mica";

char s2[] = "valoare prea mare";
char s3[] = "valoare corecta";
char* t1, *t2, *t3;
t1 = s1;
t2 = s2;
t3 = s3;
char* p[3] = { t1, t2, t3 };
int capatul_inferior = 1;
int capatul_superior = 100;
int x;
srand((unsigned)time(NULL)); //pentru generarea numerelor diferite
int r = rand() % 100;
do {
printf("\nIntroduceti un numar intreg intre 1 si 100: ");
scanf("%d", &x);
if (x != r)
{
if (x < r)
printf("%s\n", p[0]);
else
printf("%s\n", p[1]);
}
 else
printf("%s", p[2]);
} while (x != r);
}

Prob 6: Scrieti un program �n care sa definiti un tablou de pointeri spre siruri de

caractere, pe care sa-l initializati cu dif mesaje.
Afisati mesajele.:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void main()
{
char s1[] = "Craciunul";
char s2[] = "este";
char s3[] = "frumos";
char s4[] = "petrecut";
char s5[] = "in";
char s6[] = "familie";
char* a, * b, * c, * d, * e, *f;
a = s1; b = s2; c = s3; d = s4; e = s5; f = s6;
char* mesaje[6] = { a, b, c, d, e, f};
int i;
printf("Mesajele sunt:\n");
for (i = 0; i < 6; i++)
printf("%s ", mesaje[i]);
}

Prob 7: Sa se scrie un program care preia din linia de comanda siruri de caractere
si afiseaza sirul rezultat din
concatenarea acestora*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
void main(int argc, char* argv[])
{
char s[100] = "";
int i;
if (argc == 1)
printf("Nu ati introdus nimic in linia de comanda!");
for (i = 1; i < argc; i++)
{
strcat(s, argv[i]);
}
printf("\nSirul rezultat din concatenarea acestora este: %s", s);

Prob 8: Sa se scrie un program care inverseaza sirul de caractere citit din linia
de comanda:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
void main(int argc, char* argv[])
{
char s[100] = "";
if (argc == 1)
printf("Nu ati introdus nimic in linia de comanda!");
_strrev(argv[1]);
printf("Sirul de caractere inversat este: %s", argv[1]);
}

Prob 9: Scr un prog care cit de la tastatura elem de tip float ale unui tabl
unidim,
elem ce repr mediile unei grupe de studenti.
Sa se scrie o functie care determina numarul studentilor cu media >= 8.
Afisati rezultatul �n main:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define DIM 50
void citire(float* p, int n);
int numarstud(float* p, int n);
void main()
{
float x[DIM], * p;
int n, nr;
p = x;
printf("\nIntroduceti numarul de elevi din grupa:\n");
scanf("%d", &n);
if (n > DIM)
printf("\nAti introdus un numar prea mare de elevi!");
citire(p, n);
nr = numarstud(p, n);
if (nr == 0)
printf("\nNiciun elev nu are media mai mare sau egala cu 8");
else
{
printf("\nNumarul studentilor cu media mai mare sau egala cu 8 este:
%d", nr);
}
}
void citire(float* p, int n)
{
int i;
for (i = 0; i < n; i++) {
do {
printf("\nMedia studentului %d: ", i + 1);
scanf("%f", p + i);
} while (*(p + i) < 1 || *(p + i) > 10);
}
}
int numarstud(float* p, int n)
{
int nr = 0, ok = 0, i;
for (i = 0; i < n; i++)
if (*(p + i) >= 8)
{
nr += 1;
ok = 1;
}
if (ok == 1) return nr;
return ok;
}

Prob 10: Scrieti un program C/C++ �n care se citesc de la tastatura elem de tip
�ntreg ale unui tablou unidim a,
utiliz�nd o functie.
Scrieti o functie care completeaza un alt tablou unidim b, fiecare elem al acestuia
fiind obtinut prin scaderea
mediei aritmetice a elem din a din elem coresp din a.
Scrieti o functie care permite afisarea unui tablou unidim si afisati tablourile
unidim a si b:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <conio.h>
#define dim 20
void citire(float* p, int n);
void completare(float* p, float* t, int n, float med);
void afisare(float* p, int n);
float medie(float* p, int n);
void main()
{
int n;
float a[dim], b[dim], * p, * t;
p = a;
t = b;
printf("\nIntroduceti dimensiunea lui a: ");
scanf("%d", &n);
if (n > dim)
printf("\nAti introdus o dimensiune prea mare!");
printf("\nCititi tabloul a:\n");
citire(p, n);
float med = medie(p, n);
completare(p, t, n, med);
printf("\nTabloul a:\n");
afisare(p, n);
printf("\nTabloul b:\n");
afisare(t, n);
}
void citire(float* p, int n)
{
int i;
for (i = 0; i < n; i++)
scanf("%f", p + i);
}
void completare(float* p, float* t, int n, float med)
{
int i;
for (i = 0; i < n; i++)
*(t + i) = *(p + i) - med;
}
void afisare(float* p, int n)
{
int i;
for (i = 0; i < n; i++)
{
if ((int)(*(p + i)) == *(p + i))
printf("%.0f ", *(p + i));
else
printf("%f ", *(p + i));
}
}
float medie(float* p, int n)
{
float s = 0.0;
int i;
for (i = 0; i < n; i++)
s += *(p + i);
 return (float)(s / n);
}

Prob 11: Scrieti un prog �n care se citesc de la tastatura elem de tip �ntreg ale
unei matr patr, utiliz o fct.
Scrieti o functie care determina numarul de elemente negative de deasupra
diagonalei secundare.
Afisati rezultatul �n main():
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <conio.h>
#define dim 20
void citire(int* p, int n);
int nr_elemneg(int* p, int n);
void main()
{
int x[dim][dim], n, * p;
p = &x[0][0];
printf("\nIntroduceti dimensiunea matricii patratice:\n");
scanf("%d", &n);
if (n > dim)
printf("Dimensiunea este prea mare!");
printf("\nCititi matricea:\n");
citire(p, n);
printf("\nNumarul elementelor negative de deasupra diagonalei secundare este:
%d", nr_elemneg(p, n));
}
void citire(int* p, int n)
{
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
scanf("%d", p + i * n + j);
}
int nr_elemneg(int* p, int n)
{
int c = 0, i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (i + j < n - 1 && *(p + i * n + j) < 0)
c++;
return c;
}

Prob 12: Scrieti un program �n care se citesc de la tastatura elem de tip �ntreg
ale unei matrici patratice,
utiliz�nd o functie. Scrieti o functie care interschimba doua linii ale matricii.
Afisati cu o functie matricea
initiala si cea obtinuta. Dimensiunea matricii si nr ce identifica liniile care vor
fi interschimbate se citesc
de la tastatura, �n functia main:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define dim 20
void citire(int* p, int n);
void interschimbare(int* p, int n, int l1, int l2);
void afisare(int* p, int n);
void main()
{
 int a[dim][dim], n, * p, l1, l2;
p = &a[0][0];
printf("Introduceti dimensiunea matricii patratice:\n");
scanf("%d", &n);
if (n > dim)
printf("Dimensiunea este prea mare!");
printf("\nCititi matricea:\n");
citire(p, n);
printf("\nIntroduceti cele doua linii pe care doriti sa le
interschimbati:\n");
scanf("%d %d", &l1, &l2);
if (l1<1 || l1>n || l2 < 1 || l2>n)
printf("Cel putin una dintre linii nu apartine matricii!");
printf("\nMatricea initiala:\n");
afisare(p, n);
interschimbare(p, n, l1, l2);
printf("\nMatricea cu liniile precizate interschimbate:\n");
afisare(p, n);
}
void citire(int* p, int n)
{
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
scanf("%d", p + i * n + j);
}
void interschimbare(int* p, int n, int l1, int l2)
{
int i, aux;
for (i = 0; i < n; i++)
{
aux = *(p + n * (l1 - 1) + i);
*(p + n * (l1 - 1) + i) = *(p + n * (l2 - 1) + i);
*(p + n * (l2 - 1) + i) = aux;
}
}
void afisare(int* p, int n)
{
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
printf("%d ", *(p + i * n + j));
printf("\n");
}
}

Prob 14: Scrieti algoritmul care interclaseaza doua tablouri unidimensionale de

tip �ntreg. Folositi pointeri:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define DIM 20
#define dim 30
void ord_cresc(int* p, int n);
void afisare(int* p, int n);
void interclasare(int* p, int* t, int n, int m);
void main()
{
int a[DIM], b[DIM], n, m, * p, * t, i;
p = a;
 t = b;
printf("\nIntroduceti dimensiunea primului tablou: ");
scanf("%d", &n);
if (n > DIM)
printf("\n\tDimensiunea primului tablou este prea mare!");
printf("\nIntroduceti dimensiunea celui de-al doilea tablou: ");
scanf("%d", &m);
if (m > DIM)
printf("\n\tDimensiunea celui de-al doilea tablou este prea mare!");
printf("\nIntroduceti primul tablou:\n");
for (i = 0; i < n; i++)
scanf("%d", p + i);
printf("\nIntroduceti cel de-al doilea tablou:\n");
for (i = 0; i < m; i++)
scanf("%d", t + i);
ord_cresc(p, n);
ord_cresc(t, m);
printf("\nIn caz ca nu ati introdus tablourile ordonate crescator, le-am
ordonat noi!\n");
printf("\nTablourile, inainte de interclasare arata in felul urmator:\n");
afisare(p, n);
printf("\n");
afisare(t, m);
printf("\nTabloul rezultat prin interclasare este:\n");
interclasare(p, t, n, m);
}
void ord_cresc(int* p, int n)
{
int i, j, aux;
for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if (*(p + i) > * (p + j))
{
aux = *(p + i);
*(p + i) = *(p + j);
*(p + j) = aux;
}
}
void afisare(int* p, int n)
{
int i;
for (i = 0; i < n; i++)
printf("%d ", *(p + i));
}
void interclasare(int* p, int* t, int n, int m)
{
int c[dim], * q, i = 0, j = 0, k = 0, l;
q = c;
while (i < n && j < m)
{
if (*(p + i) < *(t + j))
{
*(q + k) = *(p + i);
k++;
i++;
}
else
{
*(q + k) = *(t + j);
 k++;
j++;
}
}
if (i < n)
{
for (l = i; l < n; l++)
{
*(q + k) = *(p + l);
k++;
}
}
if (j < m)
{
for (l = j; l < m; l++)
{
*(q + k) = *(t + l);
k++;
}
}
printf("\nTabloul interclasat este: \n");
for (i = 0; i < k; i++)
printf("%d ", *(q + i));
}

Prob 15: Ordonati crescator un tablou unidimensional de numere �ntregi folosind

functia de biblioteca qsort()
din stdlib.h. Folositi acelasi algoritm pentru numere de tip float si ordonati
descrescator:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
int comparare(const void* a, const void* b);
int comparare2(const void* a, const void* b);
void main()
{
int a[20], n, i, m;
float b[20];
printf("Introduceti dimensiunea lui a:\n");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
printf("a[%d] = ", i);
scanf("%d", a + i);
}
qsort(a, n, sizeof(int), comparare);
printf("\nElementele tabloului de tip intreg ordonate crescator:\n");
for (i = 0; i < n; i++)
printf("%d ", *(a + i));

printf("\nIntroduceti dimensiunea lui b:\n");

scanf("%d", &m);
for (i = 0; i < m; i++)
{
printf("a[%d] = ", i);
scanf("%f", b + i);
 }
qsort(b, m, sizeof(float), comparare2);
printf("\nElementele tabloului de tip float ordonate descrescator:\n");
for (i = 0; i < m; i++)
printf("%f ", *(b + i));

}
int comparare(const void* a, const void* b)
{
return ((int)a - (int)b);
}
int comparare2(const void* a, const void* b)
{
return ((int)b - (int)a);
}