/*Să se scrie un program care citeşte n numere reale, pe care le stochează într-un

tablou
alocat dinamic, afişează suma elementelor negative citite, iar la sfârşit
eliberează zona
de memorie alocată.*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#include <conio.h>
int functie(int *,int);
int main()
{
int *tab,n;
printf("Introduceti numarul elementelor din tablou: ");
scanf("%d",&n);
if(n<0)
{
printf("Valoare introdusa invalida");
return 1;
}
if(tab=(int*)malloc(n*sizeof(int)))
{
printf("\nIntroduceti elementele tabloului: \n");
for(int i=0;i<n;i++)
{
printf("Elementul %d = ",i+1);
scanf("%d",(tab+i));
}
}
printf("Suma elementelor negative din tablou este:
%d",functie(tab,n));
if(tab)
free(tab);
_getch();
return 0;

}
int functie(int *tab,int n)
{
int s=0;
for(int i=0;i<n;i++)
{
if(*(tab+i)<0)
{
s+=*(tab+i);
}
}
return s;
}

/* Fie o aplicaţie de gestiune distribuită care consideră că tratează activitatea

din 5 oraşe
diferite în fiecare oraş fiind 3 birouri de vânzare pe teritoriul respectiv. Să se
creeze în
cadrul unei funcţii un tablou de 5 pointeri către date de tip flotant, fiecare
pointer din
acest tablou referind o zonă în heap alocată dinamic de 3 date flotante ce
reprezintă
situaţia vânzărilor la sfărşitul unei zile. Se cere prelucrarea datelor din fiecare
oraş,
respectiv din fiecare birou de vânzare, prelucrare ce va include:
- funcţie care permite introducerea datelor pentru cele 5 oraşe şi respectiv
pentru fiecare oraş pentru cele 3 magazine din oraş;
- funcţie ce permite determinarea totalului de vânzări pe fiecare oraş în parte,
valoare pe care o va returna astfel că în programul principal se va calcula şi
afişa media vânzărilor din toate cele 5 oraşe;
- funcţie care va permite eliberarea spaţiului de memorie alocat dinamic astfel
încât dacă aceeaşi firmă are alte 3 magazine în cele 5 oraşe de profil diferit să
poată realoca un spaţiu echivalent pentru noile prelucrări pe care le va
efectua.*/
#define _CRT_SECURE_NO_WARNINGS
#include<conio.h>
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
void citire(float **);
void functie(float **);
void eliberare(float **);
int main()
{
float **x=0;
citire(x);
functie(x);
eliberare(x);
_getch();
}
void citire(float **x)
{
x = (float**)malloc(5 * sizeof(float));
for (int i = 0; i < 5; i++)
{
*(x + i) = (float*)malloc(3 * sizeof(float));
for (int j = 0; j < 3; j++)
{
printf("Orasul %d Biroul de vanzare %d: ", i + 1, j + 1);
scanf("%f", (x + i * 3 + j));
}
}
}
void functie(float **x)
{
float s = 0;
for (int i = 0; i < 5; i++) {
s = 0;
for (int j = 0; j < 3; j++)
{
s = **(x + i * 3 + j)+s;
}
printf("Orasul are %d media vanzarilor egala cu: %f .", i + 1, s /
3.0);

}
}
void eliberare(float **x)
{
for (int i = 0; i < 5; i++)
{
free(*(x+i));
 }
free(x);
}

/*Să se scrie o aplicaţie C/C++, care alocă dinamic memorie pentru stocarea
elementelor a două matrici de "m" linii şi "n" coloane. Să se scrie o funcţie care
calculează suma celor două matrici şi o funcţie pentru afişarea unei matrici. Să se
afişeze matricile iniţiale şi matricea obţinută. */
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#include <conio.h>
int *functie(int *,int *,int , int );
void citire(int *,int ,int );
void afisare(int *,int ,int );
int main()
{
int *a,*b,n,m,*tab=NULL;
printf("Introduceti numarul de linii a matricilor: ");
scanf("%d",&m);
printf("Introduceti numarul de coloane a matricilor: ");
scanf("%d",&n);
if(n<=0||m<=0)
{
printf("Valoare introdusa invalida");
return 1;
}
if((a=(int*)malloc(n*m*sizeof(int)))&&(b=(int*)malloc(n*m*sizeof(int))))
{
printf("\nIntroduceti elementele primei matrici: \n");
citire(a,m,n);
printf("\nIntroduceti elementele celei de a doua matrici:
\n");
citire(b,m,n);
tab=functie(a,b,m,n);
printf("Prima matrice este : \n");
afisare(a,m,n);
printf("A doua matrice este : \n");
afisare(b,m,n);
printf("Suma celor doua matrice este : \n");
afisare(tab,m,n);
if(a||b||tab)
{free(a);
free(b);
free(tab);}
_getch();
return 0;
}
else
{printf("\n Eroare de alocare !");
_getch();
return 1;

}
int *functie(int *a,int *b,int m , int n )
{
int *tab;
 if(tab=(int*)malloc(n*m*sizeof(int)))
{ for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
*(tab+i*n+j)=*(a+i*n+j)+*(b+i*n+j);
}
}
}
return tab;

}
void citire(int *tab,int m,int n)
{
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
printf("tab[%d][%d] = ",i+1,j+1);
scanf("%d",(tab+i*n+j));
}
}
}
void afisare(int *a,int m,int n)
{
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
printf("%d ",*(a+i*n+j));

}
printf("\n");
}
}

/*Să se scrie o aplicaţie C/C++ care alocă dinamic memorie pentru "n" şiruri de
caractere, care se vor citi de la tastatură.*/
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
int main()
{
int n, d, i, j;
char *s;
printf("Introduceti numarul de siruri de caractere: ");
scanf("%d", &n);
printf("Introduceti dimensiunea sirurilor de caractere: ");
scanf("%d", &d);
if (n < 0 || d < 0)
{
printf( "Date introduse invalide !!");
}
else
{
for (i = 0; i < n; i++)
{
s = (char*)malloc(n*d* sizeof(char));
 if (s == NULL)
{
printf("\n Nu s a putut aloca in memorie. ");
return 1;
}
printf("Introduceti sirul (%d) cu (%d) caractere: ", i + 1, d);
for (j = 0; j < d; j++)
{
scanf(" %c", (s + j));
}
if (s)
free(s);
}
}
return 0;
_getch();
}
/*Declaraţi un pointer global de tip float. În funcţia main() citiţi o valoare
întreagă N
care reprezintă dimensiunea tabloului de numere reale. Alocaţi memoria necesară
pentru stocarea tabloului şi citiţi elementele de la tastatură. Determinaţi
valoarea
medie a celor N elemente şi calculaţi Mn=(sum(pow((xi-xmed),n))/N, unde n=1,2,3.
Afişaţi rezultatele şi apoi eliberaţi memoria. Folosiţi funcţiile malloc() şi
free().
Generaţi numerele din tablou folosind funcţia de bibliotecă care generează numere
aleatoare şi determinaţi pentru acestea media valorilor şi Mn. Realizati aceeasi
aplicatie folosind operatorii new şi delete*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#include <conio.h>
#include <time.h>
#include <stdlib.h>
#include<math.h>
float media( int);
long int *tab;
int main()
{
int n;
long float s = 0, mn, v1, v2, v3, m, x;
printf("Introduceti numarul elementelor din tablou: ");
scanf("%d", &n);
if (n < 0)
{
printf("Valoare introdusa invalida");
return 1;
}
srand(time(NULL));
if (tab = (long int*)malloc(n * sizeof(long int)))
{
printf("\nTabloul construit este: ");
for (int i = 0; i < n; i++)
{
*(tab + i) = rand();
printf("%li ", *(tab + i));
}
m = media( n);
for (int i = 0; i < n; i++)
 {
x = *(tab + i);
v1 = pow((x - m), 1);
v2 = pow((x - m), 2);
v3 = pow((x - m), 3);
s += v1 + v2 + v3;
}
mn = (long float)s / n;
printf("\n\t Mn= %lf", mn);
}
if (tab)
free(tab);
_getch();
return 0;

}
float media(int n)
{
long float m = 0;
for (int i = 0; i < n; i++)
{
m += *(tab + i);
}
m = (long float)m / n;
return m;
}

/*Folosiţi alocarea dinamică pentru o matrice m x n cu valori întregi (m, n <7).

Initializaţi elementele matricii. Dacă matricea este pătratică, folosiţi metoda lui
Sarrus
pentru a obţine valoarea determinantului. Afişaţi rezultatul şi eliberaţi
memoria.*/
#define _CRT_SECURE_NO_WARNINGS
#include <conio.h>
#include <stdio.h>
#include <malloc.h>
int main()
{
int *x, m, n, i, j,p=1,d=0;
printf("\n\tIntroduceti numarul de linii : ");
scanf("%d", &m);
printf("\tIntroduceti numarul de coloane : ");
scanf("%d", &n);
if (n*m < 0)
{
printf("\t\tDate invalide(n sau m < 0) !!");
_getch();
return 1;
}
if (n == m)
{
if (x = (int*)malloc(n*(2 * n - 1) * sizeof(int)))
{
printf("\t\tIntroduceti elementele matricei: ");
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
scanf("%d", (x + i * (2 * n - 1) + j));
 }
}
for (i = 0; i < m; i++)
{
for (j = n; j < 2 * n - 1; j++)
{
*(x + i * (2 * n - 1) + j) = *(x + i * (2 * n - 1) +
j - n);
}
}
for (j = 0; j < n; j++)
{
p = 1;
for (i = 0; i < (2 * n - 1)*n; i += 6)
{

p *= *(x + i + j);
}
d += p;
}
for (j = n - 1; j < 2 * n - 1; j++)
{
p = 1;
for (i = 0; i < ((2 * n - 1)*n) - n; i += 4)
{

p *= *(x + i + j);
}
d -= p;
}
if (x)
free(x);
printf("\t\tValoarea determinantului este %d .", d);
_getch();
return 0;
}
else
{
printf("\t\tAlocare dinamica nereusita!");
_getch();
return 1;
}
}
else
{
printf("Matricea nu e patratica");
_getch();
return 0;
}
}/*Să se scrie o aplicaţie C/C++ care alocă dinamic memorie necesară pentru
stocarea a
10.000 de numere întregi. Programul iniţializează numerele cu valori aleatoare
între 1
şi 100 (folosiţi funcţiile srand() şi/sau rand() în VC++). Scrieţi o funcţie care
afişează
cele mai frecvente 10 numere şi numărul lor de apariţii în tabloul iniţial.*/
#define _CRT_SECURE_NO_WARNINGS
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <time.h>
void functie(int *);
int main()
{
int *x, i, *ap, maxap = 0, aux, j;
if (x = (int*)malloc(10000 * sizeof(int)))
{
if (ap = (int*)malloc(202 * sizeof(int))) {
memset(ap, 0, (200 * sizeof(int)));
srand(time(NULL));
for (i = 0; i < 10000; i++)
{
*(x + i) = rand() % 100 + 1;
*(ap + *(x + i)) = *(ap + *(x + i)) + 1;
if (*(ap + *(x + i)) == 1)
{
*(ap + *(x + i) + 100) = *(x + i);
}
}
functie(ap);
}
else
{
printf("\t\tAlocare dinamica nereusita!");
_getch();
return 1;
}
_getch();
if (x)
free(x);
if (ap)
free(ap);
return 0;
}
else
{
printf("\t\tAlocare dinamica nereusita!");
_getch();
return 1;
}
}
void functie(int *ap)
{
int i, j, aux;
for (i = 0; i < 101; i++)
{
for (j = i + 1; j < 101; j++)
{
if (*(ap + i) > 0)
{
if (*(ap + j) > *(ap + i))
{
aux = *(ap + j);
*(ap + j) = *(ap + i);
*(ap + i) = aux;
aux = *(ap + j + 100);
 *(ap + j + 100) = *(ap + i + 100);
*(ap + i + 100) = aux;
}
}
}
}
printf("Cele mai frecvente 10 numere si numarul lor de aparitii: \n");
for (i = 1; i < 11; i++)
{
printf("\tNUMAR = %d \t NR. APARITII = %d \n", *(ap + i + 100), *(ap +
i));
}
}/*. Să se scrie o aplicaţie C/C++ în care se alocă dinamic memorie pentru n numere
întregi, numere ce vor fi citite de la tastatură. Să se scrie funcţia care extrage
radicalul
din fiecare număr şi stochează valorile obţinute într-un alt tablou alocat dinamic.
Să
se afişeze numerele iniţiale şi valorile din tabloul format. Eliberaţi la sfârşit
memoria
alocată.*/
#define _CRT_SECURE_NO_WARNINGS
#include <conio.h>
#include <stdio.h>
#include <malloc.h>
#include <math.h>
int *functie(int*, int*,int );
int main()
{
int n, *x,*y=NULL;
printf("Introduceti numarul elementelor din tablou: ");
scanf("%d", &n);
if (n < 0)
{
printf("\t\Date invalide!");
_getch();
return 1;
}
if (x = (int*)malloc(n * sizeof(int)))
{
printf("\tIntroduceti cele %d numere : ", n);
for (int i = 0; i < n; i++)
{
scanf("%d",(x + i));
}
y=functie(x, y, n);
printf("\tTabloul format este : ");
for (int i = 0; i < n; i++)
{
printf("%d ", *(y+i));
}
if (x)
free(x);
if (y)
free(y);
_getch();
}
else
{
printf("\t\tAlocare dinamica nereusita!");
 _getch();
return 1;
}
}
int *functie(int*x,int*y,int n)
{
if (y = (int*)malloc(n * sizeof(int)))
{
for (int i = 0; i < n; i++)
{
*(y + i) = sqrt(*(x + i));
}
return y;
}
else
{
return y;

}
}/*Scrieţi un program în care se citesc n şiruri de caractere şi se concatenează
într-un alt
şir, alocat dinamic. Repetaţi operaţia de câte ori doreşte utilizatorul. După
fiecare
afişare a şirului obţinut prin concatenare eliberaţi memoria alocată dinamic*/
#define _CRT_SECURE_NO_WARNINGS
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <ctype.h>
#include<cstring>
#include <math.h>
int main()
{
int n, l = 0;
char *x, *y=NULL,car=NULL;
printf("\tIntroduceti numarul sirurilor de caractere : ");
scanf("%d", &n);
if (n <= 0)
{
printf("\tDate invalide!");
_getch();
return 1;
}
for (int i = 0; i < n; i++)
{
if (x = (char*)malloc(256 * sizeof(char)))
{
if ((i == 0)&&(y = (char*)malloc(256 * sizeof(char))))
{
printf("\n\tIntroduceti sirul de caractere: ");
scanf("%s", x);
for (int j = 0; j < strlen(x); j++)
{
y[l] = x[j];
l++;
}
y[l] = '\0';
printf("\tSirul format este %s \n", y);
 if (x)
free(x);

}
else if(i!=0)
{
printf("\n\tIntroduceti alt sir de caractere: ");
scanf("%s", x);
for (int j = 0; j < strlen(x); j++)
{
y[l] = x[j];
l++;
}
y[l] = '\0';
printf("\tSirul format este %s \n", y);
if (x)
free(x);
}
else
{
printf("\t\tAlocare dinamica nereusita!");
_getch();
return 1;
}
printf("\tContinuati?(ENTER - DA): ");
car =_getch();
if ((int)car != 13)
{
break;
}

}
else
{
printf("\t\tAlocare dinamica nereusita!");
_getch();
return 1;
}
}
if (y)
free(y);
_getch();
}/*Să se scrie o aplicaţie C/C++, care alocă dinamic memorie pentru stocarea
elementelor unei matrici de dimensiune nxn. Să se scrie o funcţie care calculează
suma numerelor pozitive pare de sub diagonala principală şi o funcţie pentru
afişarea
matricei. Să se afişeze matricea şi suma cerută. Eliberaţi memoria alocată dinamic.

*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#include <conio.h>
int suma(int * , int );
void citire(int *,int );
void afisare(int *,int );
int main()
{
 int *a,n;
printf("Introduceti numarul de linii & coloane a matricei: ");
scanf("%d",&n);
if(n<=0)
{
printf("Valoare introdusa invalida");
_getch();
return 1;
}
if(a=(int*)malloc(n*n*sizeof(int)))
{
printf("\nIntroduceti elementele matricii: \n");
citire(a,n);
printf("Matricea este : \n");
afisare(a,n);
printf("Suma numerelor pozitive pare de sub diagonala
principala este : %d\n",suma(a,n));
if(a)
free(a);
_getch();
return 0;
}
else
{printf("\n Eroare de alocare !");
_getch();
return 1;
}

}
int suma(int *a , int n )
{
int s=0;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if((i>j)&&(*(a+i*n+j)%2==0))
s+=*(a+i*n+j);
}
}
return s;

}
void citire(int *tab,int n)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
printf("tab[%d][%d] = ",i+1,j+1);
scanf("%d",(tab+i*n+j));
}
}
}
void afisare(int *a,int n)
{
for(int i=0;i<n;i++)
{
 for(int j=0;j<n;j++)
{
printf("%d ",*(a+i*n+j));

}
printf("\n");
}
}