Universitatea Tehnică a Moldovei

Facultatea Calculatoare Informatică și Microelectronică

Departamentul Ingineria Software și Automatică

RAPORT
la lucrarea de laborator nr. 5-6

la Programarea Calculatoarelor

Tema: Elemente de programare în limbajul C

Varianta 5 -25

A efectuat: Chiforiuc Adrian

A verificat: Prijivelschi Dumitru

Chişinău 2020
Scopul lucrării
însuşirea tehnicilor de algoritmizare şi programare cu subprograme în
prelucrareatablourilor uni- și bidimensionale în C
Obiectivele temei
1.Aprofundarea cunoştinţelor în limbajul şi mediul TurboC şi
perfecţionarea tehnicii de programare cusubprograme în prelucrarea
tablourilor uni- și bidimensionale.
2. Dezvoltarea procedeelor de algoritmizare şi progamare prin
descompunerea problemei în moduleautonome care, apoi, vor fi
reprezentate prin module de program pentru prelucrarea tablourilor
uni- șibidimensionale în C după principii comune cu apeluri multiple,
analizând soluţiile stereotipe şi celeeficiente.
3. Însuşirea tehnicilor eficiente de parcurgere, căutare, schimbare şi
ordonare a structurilor şi calcululconform cunoştinţelor obţinute din
matematică şi în baza lucrărilor precedente într-un program
complex,alcătuit după principiile top-down.
4. Llab. 5 se analizează testele din Anexa 2,3. și se preia variantele
problemelor din Llab. 3 și se transformăîn programe cu funcții proprii
după stil vechi și nou.
5. Llab. 6 se preia variantele problemelor din Llab. 4 și se transformă în
programe cu funcții proprii definiteca “proceduri” în C cu transmiterea
argumentelor funcțiilor în câteva moduri. Totodată se aplică și
lasoluționarea problemelor din Anexa 4.
1. Extras Teoretic
Programarea structurata este o problema ce rezolva strategia si
metodologia programării si are următoareleprincipii:
1. Structurile de control trebuie sa fie cat se poate de simple;
2. Construcţia unui program trebuie sa fie descrisa top-down.
Descrierea top-down se refera la descompunerea problemei noastre
in subprobleme. De obicei, acestesubprobleme sunt usor de descris.
Presupunem ca avem de citit câţiva intregi si trebuie sa-i afişăm in
ordine pecoloane (in capătul de sus al coloanelor trebuie sa scriem
 numele câmpului), sa le afişăm suma lor parţiala,minimul si maximul
lor. Pentru scrierea unui program C ce face acest lucru, vom utiliza
proiectarea (descrierea)"top-down".
Astfel, descompunem problema in următoarele subprobleme:
1. Un antet pentru problema data;
2. Scrierea câmpurilor;
3. Citirea si scrierea lor pe coloane. ş.a.m.d.
O functie este o parte denumita a programului care poate fi apelata
din alte parti ale programului atit de des,cit este nevoie. Conform
consideraţiilor teoretice funcţiile sunt un aspect important al
programării, ce permitîncapsularea unor rutine in cadrul unor "cutii
negre", astfel ca programatorul care se foloseşte de anumitefuncţii,
elaborate de programator, trebuie sa cunoască acţiunea lor şi modul
in care sunt implementate, iar pentrucele din bibliotecile standarde
al limbajului C doar acţiunea lor, nu si modul in care sunt
implementate.Totodată, funcţiile permit structurarea programului
pe blocuri, separând astfel zonele de cod ce îndeplinescaceleaşi
acţiuni si conferând o mai mare lizibilitate a codului.

2. Rezolvare

Lab 5

#include <stdio.h>
#include <stdlib.h>
#include<time.h>
#include<math.h>
void return_var();
int check();
int main()
{
srand(time(NULL));
int p, i, n, m;
int max=0, F=0;
printf("Dati numarul de elemente a sirului:\n");
scanf("%d", &n);
printf("Dati numarul maxim generat: \n");
scanf("%d", &m);
printf("\n\n\n");
int x[n];

for(i=0; i<n; i++) //atribuirea unei variabile random pentru fiecare

element al sirului;
{
return_var(&p, m);
x[i] = p;
printf("%d\n", x[i]);
}
int min = x[0];
for(i=0; i<n; i++) //verificarea minimului si maximului;
{
if(max<x[i])
{
max = x[i];
}
if(min>x[i])
{
min = x[i];
 }
}
int a=0,b=0,c=0,d=0,e=0;
for (i=0; i<n; i++) //daca conditia este adevarata, variabila
corespunzatoare se incrimenteaza;
{
if(x[i]>x[i+1])
{
a++;
}
if(x[i]<x[i+1])
{
b++;
}
if(x[i]<2)
{
c++;
}
if(max>x[i])
{
d++;
}
if(min<x[i])
{
e++;
}
}
check(n,a,b,c,d,e);
if (F==0)
{
 for(i=0; i<n; i++)
{
printf("CosX = %f\n", cos(x[i]));
printf("SinX = %f\n", sin(x[i]));
}
}
else
{
printf("F = %d", F);
}
}
void return_var(int* p, int m)
{
int v;
v = (rand()%m);
*p=v;
}

int check(int n, int a, int b, int c, int d, int e, int F) // verifica conditiile, daca
variabila ce numara elementele este egala cu numarul
{ // de elemente ale sirului,
lui F i se va atribui o valoare din cele enumerate;
if(a==n)
{
F = 1;
}
if(b==n)
{
F = 2;
}
if(c==n)
 {
F = 3;
}
if(d==n)
{
F = 4;
}
if(e==n)
{
F = 5;
}
return F;
}
25(a) Să se elaboreze algoritmul şi programul ca să se calculeze numărul
cifrelor fiecărui număr dintr-untablou de numere pozitive care pot avea
valori cu cel puţin de 4 cifre (mii) şi de salvat în alt tablou.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void r_gen();
int counter();
int main()
{
srand(time(NULL));
int i, n,m,p,z;
printf("Dati numarul de elemente a sirului: \n"); scanf("%d", &n);
if(n<1)
{
printf("Eroare!");
return 0;
}
printf("\n\n\n");
m = (rand()%10000);
int x[n], y[n];
for (i=0;i<n;i++)
{
r_gen(&p, m);
x[i] = p;
printf("%d\n", x[i]);
}
printf("\n\n\n");
for (i=0;i<n;i++)
 {

y[i] = counter(x[i]);;
printf("%d\n", y[i]);
}
}

void r_gen(int* p, int m) // generarea numerelor random pentru tablou care

nu vor fi mai mici de 1000;
{
int v;
v = (rand()%m);
while(v < 1000)
{
v*=10;
}
*p=v;
}

int counter(int v) //atat timp cat v este mai mare ca 0, va avea loc impartirea
si in acelasi timp incrimentarea variabilei ce numara procedurile;
{
int count = 0;
while (v>0)
{
v/=10;
count++;
}
return count;
}
Lab 6
Să se citească de la tastatură o matrice patratica Anxn. Sa se calculeze suma
si produsul elementelor de pe diagonala principala si de pe diagonala
secundara
#include <stdio.h>
#include <stdlib.h>
#include<time.h>

void gen_matrix(int**, int, int, int);

void print_matrix(int**, int, int);
int** alloc_memory(int,int);
void diagonal_main(int**, int, int);
void diagonal_second(int**, int, int);
void destroy_matrix(int**, int, int);
int main()
{
int **matrix;
srand(time(NULL));
int i, j,m, r,c;
printf("Dati numarul de randuri a matricii:\n");
scanf("%d", &r);
printf("\n\n");
printf("Dati numarul maxim generat in matrice:\n");
scanf("%d", &m);
printf("\n\n");
c=r;
matrix = alloc_memory(r,c);
gen_matrix(matrix,r,c,m);
print_matrix(matrix,r,c);
diagonal_main(matrix,r,c);
diagonal_second(matrix,r,c);
destroy_matrix(matrix,r,c);
}

void gen_matrix(int **matrix, int r, int c, int m)

{
for(int i=0;i<r;i++)
{
for(int j=0;j<c;j++)
{
matrix[i][j] = ((rand()%m*2)-m);
}
}
}
void print_matrix(int **matrix, int r, int c)
{
for(int i=0;i<r;i++)
{
for(int j=0;j<c;j++)
{
printf("%d\t", matrix[i][j]);
}
printf("\n");
}
printf("\n\n");
}

void diagonal_main(int **matrix, int r, int c)

{
int j=0, sum=0, prod=1;
for(int i=0; i<r; i++)
{
sum = sum + matrix[i][j];
prod = prod * matrix[i][j];
j++;
}
printf("Suma diagonalei principale este: %d\nProdusul diagonalei
principale este: %d", sum,prod);
printf("\n\n");
}

void diagonal_second(int **matrix, int r, int c)

{
 int j=c-1, sum=0, prod=1;
for(int i=0; i<r; i++)
{
sum = sum + matrix[i][j];
prod = prod * matrix[i][j];
j--;
}
printf("Suma diagonalei secundare este: %d\nProdusul diagonalei
secundare este: %d", sum,prod);
printf("\n\n");
}

int** alloc_memory(int r, int c)

{
int **matrix = malloc(r * sizeof(int*));
for(int i = 0; i < r; i++){
matrix[i] = malloc (c * sizeof(int));
}
return matrix;
}
void destroy_matrix(int **matrix, int r, int c)
{
for (int i = 0; i < r; i++) {
free(matrix[i]);
}
free(matrix);
matrix = NULL;
}
Ex 25
Este data 1 matrice A={ai,j},delimitate în 4 sectoare (vezi Fig.2.). .
Calculaţi următoarele: valoarea minimă a sectorului 1; -- valoarea
maximă a sectorului 2; produsul elementelor a sectorului 3;. suma
elementelor sectorului 4.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <malloc.h>

int** alloc_memory(int,int);
void matrix_gen(int**, int, int, int);
void matrix_print(int**, int, int);
void cadran_1(int**, int, int);
void cadran_2(int**, int, int);
void cadran_3(int**, int, int);
void cadran_4(int**, int, int);
void destroy_matrix(int**,int,int);
int main()
{
srand(time(NULL));
int i,j,r,c,m;
int **matrix;
printf("Dati numarul randurilor matricii: \n");
scanf("%d", &r);
printf("\n\n");
 c = r;
printf("Dati numarul maxim generat: \n");
scanf("%d", &m);
printf("\n\n");
matrix = alloc_memory(r,c);
matrix_gen(matrix,r,c,m);
matrix_print(matrix,r,c);
cadran_1(matrix,r,c);
cadran_2(matrix,r,c);
cadran_3(matrix,r,c);
cadran_4(matrix,r,c);
destroy_matrix(matrix,r,c);
}

void matrix_gen(int **matrix, int r, int c, int m)

{
for(int i=0; i<r; i++)
{
for(int j=0; j<c; j++)
{
matrix[i][j] = ((rand()%m*2)-m);
}
}
}

void matrix_print(int **matrix, int r, int c)

{
for(int i=0; i<r; i++)
{
for(int j=0; j<c; j++)
 {
printf("%d\t", matrix[i][j]);
}
printf("\n");
}
printf("\n\n");

void cadran_1(int** matrix,int r,int c)

{
printf("\nConditia 1;\n");
int matrix2[100];
int q=1,x=0;

for(int i=0; i<c; i++)

{
matrix2[i]=matrix[0][i];
x++;
}
int w;
w=r-1;
int j=0;
while(w>0)
{
j++;
for(int i=q; i<w; i++)
{
matrix2[x]= matrix[j][i];
x++;
 }
w--;
q++;
}
printf("\n\n");
for(int i=0; i<x; i++)
{
printf("%d\t",matrix2[i]);
}
int check1=0;
for(int i=0; i<x; i++)
{
if(check1>matrix2[i])
{
check1=matrix2[i];
}
}
printf("\n\nValoarea minima in cadranul 1 este : %d\n", check1);
}

void cadran_2(int** matrix,int r,int c)

{
printf("\n\n Conditia 2; \n");
int matrix2[100];
int q=1, x=0;
for(int i=0; i<r; i++)
{
matrix2[i]=matrix[i][0];
x++;
}
 int w;
w=c-1;
int j=0;
while(w>0)
{
j++;
for(int i=q; i<w; i++)
{
matrix2[x] = matrix[i][j];
x++;
}
w--;
q++;
}
printf("\n\n");
for(int i=0; i<x; i++)
{
printf("%d\t",matrix2[i]);
}
int check2=0;
for (int i=0; i<x; i++)
{
if(matrix2[i]>check2)
{
check2 = matrix2[i];
}
}
printf("\n\nValoarea maxima in cadranul 2 este : %d\n", check2);
}
void cadran_3(int** matrix,int r,int c)
{
printf("Conditia 3;\n");
int matrix2[100];
int q=1,x=0;
for(int i=0; i<r; i++)
{
matrix2[i]= matrix[i][c-1];
x++;
}
int w;
w=r-1;
long long int z=1;
int j=w;
while(w>0)
{
j--;
for(int i=q; i<w; i++)
{
matrix2[i]=matrix[i][j];
x++;
}
q++;
w--;
}
printf("\n\n");
for(int i=0; i<x; i++)
{
printf("\t%d",matrix2[i]);
}
 for(int i=0; i<x; i++)
{
z *=matrix2[i];
}
printf("\n");
printf("Produsul tuturor elementelor este : %lld\n", z);
}

void cadran_4(int** matrix,int r,int c)

{
printf("Conditia 4;\n");
int matrix2[100];
int q=1,x=0;
for(int i=0; i<c; i++)
{
matrix2[i]= matrix[r-1][i];
x++;
}
int w;
w=c-1;
int z=0;
int j=w;
while(w>0)
{
j--;
for(int i=q; i<w; i++)
{
matrix2[x]=matrix[j][i];
x++;
}
 q++;
w--;
}
printf("\n\n");
for(int i=0; i<x; i++)
{
printf("\t%d",matrix2[i]);
}
for(int i=0; i<x; i++)
{
z +=matrix2[i];
}
printf("\n");
printf("Suma tuturor elementelor este : %d", z);
}

int** alloc_memory(int r, int c)

{
int **matrix = malloc(r * sizeof(int*));
for(int i = 0; i < r; i++)
{
matrix[i] = malloc (c * sizeof(int));
}
return matrix;
}

void destroy_matrix(int **matrix, int r, int c)

{
for (int i = 0; i < r; i++)
 {
free(matrix[i]);
}
free(matrix);
matrix = NULL;
}
Anexa 2

Răspuns: 8 20
Adică x = 8 iar y =20

Răspuns : msort(a+1, xxptr);

Răspuns : 2 2 6

Valoarea unui element de tip char se afiseaza la ecran prin functia speciala
%c și nu %s.
1024 1 0.0009765

 10 puncte                                                                                                                                                                
         
aveți 10 puncte. Încă ? 5                                                                                                                                           
                
 7 puncte                                                                                                                                                                  
        
aveți 17 puncte. Încă ? 5                                                                                                                                           
                
 11 puncte                                                                                                                                                                
         
depă șit  
g::x = 18 g::n = 2
g::x = 18 g::n= 5
#
#
#
#

1   0                                                                                                                                                                          
   
0   1                                                                                                                                                                          
   
                                                                                                                                                                                 
    
1   0   0                                                                                                                                                                     
    
0   1   0                                                                                                                                                                     
    
0   0   1                                                                                                                                                                     
    
Anexa 3

#include
<stdio.h>
#include
<stdlib.h>
int sign(int);
void cadran_check(int);
int main()
{
int x,y,check;
printf("Dati coordonatele: \n");
printf("X = "); scanf("%d", &x);
printf("\nY = "); scanf("%d", &y);
check = 3*sign(x) + sign(y);
printf("\n\n");
cadran_check(check);
}

int sign(int n)
{
if(n<0)
{
n = -1;
}
if(n>0)
{
n = 1;
}
if(n==0)
{
n = 0;
}
return n;
}

void cadran_check(int check)

{
switch (check)
{
case 4:
printf("Coordonata se afla in cadranul 1\n");
break;
case 2:
printf("Coordonata se afla in cadranul 2\n");
break;
case -4:
printf("Coordonata se afla in cadranul 3\n");
break;
case -2:
printf("Coordonata se afla in cadranul 4\n");
break;
default:
printf("Coordonata se afla pe una sau ambele axe de coordonate\n");
}
}

5. Pentru matricea dată Y={yi,j}, i=1,n; j=1,n; efectuaţi transpunerea

faţă de diagonala secundară şi obţineţi matricea B, apoi calculaţi E=Y*B

#include <stdio.h>
#include <stdlib.h>
#include<time.h>
#include<malloc.h>
int** alloc_memory(int,int);
int** alloc_memory_t(int,int);
void matrix_gen(int**,int,int,int);
void matrix_print(int**,int,int);
void matrix_transform(int**,int**,int,int);
void matrix_prod(int**,int**,int**,int,int);
void matrix_destroy(int**,int,int);

int main()
{
srand(time(NULL));
int** matrix;
int** A;
int**P;
int r,c,m;
printf("Dati numarul randurilor matricii\n");
scanf("%d", &r);
c=r;
printf("Dati numarul maxim generat\n");
scanf("%d", &m);
printf("\n\n");
matrix = alloc_memory(r,c);
A = alloc_memory(r,c);
P = alloc_memory(r,c); //alocarea memoriei matricilor
matrix_gen(matrix,r,c,m);
matrix_print(matrix,r,c);
matrix_transform(matrix,A,r,c);
matrix_prod(matrix,A,P,r,c);
matrix_destroy(matrix,r,c);
matrix_destroy(A,r,c);
matrix_destroy(P,r,c);
}
void matrix_gen(int**matrix,int r,int c, int m)
{
for(int i=0; i<r; i++)
{
for(int j=0; j<c; j++)
{
matrix[i][j]=((rand()%m*2)-m);
}
}
}

void matrix_print(int**matrix,int r, int c)

{
for(int i=0; i<r; i++)
{
printf("\n");
for(int j=0; j<c; j++)
{
printf("%d\t", matrix[i][j]);
}
printf("\n");
}
printf("\n\n");
}

void matrix_transform(int** matrix,int** A,int r, int c)

{
int x,y,a,b;
x=r;
a=r;
y=c;
b=c;
A = alloc_memory(r,c);
for(int i=0; i<r; i++)
{
for(int j=0; j<c; j++)
{
A[i][j] = matrix[i][j];
}
}
for(int i=0; i<x-1; i++)
{
for(int j=0; j<y-1; j++)
{
A[i][j] = matrix[r-i-1][c-j-1];
}
y--;
}
for(int i=0; i<a-1; i++)
{
for(int j=0; j<b-1; j++)
{
A[r-i-1][c-j-1] = matrix[i][j];
}
b--;
}
printf("\n\n");
for(int i=0; i<r; i++)
{
 printf("\n");
for(int j=0; j<c; j++)
{
printf("%d\t", A[i][j]);
}
printf("\n");
}
}

void matrix_prod(int**matrix,int**A,int**P,int r,int c)

{
int g;
g = r;
for(int i=0;i<r;i++)
{
for(int j=0;j<c;j++)
{
P[i][j] = 0;
}
}

for(int i=0; i<r; i++)

{
for(int j=0; j<c; j++)
{
for(int k=0; k<g; k++)
{
P[i][j] = P[i][j]+matrix[i][k]*A[k][j];
}
 }
}
for(int i=0; i<r; i++)
{
printf("\n");
for(int j=0; j<c; j++)
{
printf("%d\t", P[i][j]);
}
printf("\n");
}
}

int** alloc_memory(int r, int c)

{
int **matrix = malloc(r*sizeof(int*));
for(int i=0; i<c; i++)
{
matrix[i] = malloc(c*sizeof(int));
}
return matrix;
}

void matrix_destroy(int**matrix,int r, int c)

{
for (int i=0; i<r; i++)
{
free(matrix[i]);
}
 free(matrix);
matrix = NULL;
}

Concluzie:
În această lucrare de laborator, am studiat noi tehnici de programare,
prin folosirea funcțiilor proprii, astfel operând cu tablouri
unidimensionale și bidimensionale, creând programe care sunt mai
ușor de citit pentru alți utilizatori. De asemenea, în această lucrare de
laborator am studiat folosirea pointerilor, des utilizați în lucrul cu
tablourile unidimensionale și bidimensionale și funcții proprii. De
asemenea am studiat alocarea memoriei pentru pointeri care are drept
scop perfecționarea programelor și optimizarea acestora.