1) Deconcateneaza masivul

#include<stdio.h>
#include<conio.h>
#include<malloc.h>

//I - vectorul cu valori intregi alocat in memoria dinamica, lungimea vectorului

//E - suma valorilor stocate in vectorul de intrare
int suma(int* ps,int n)
{int s=0;
for(int i=0;i<n;i++)
s=s+*(ps+i);
return s;
}
int main()
{int n,i;
float* pv;
printf("Introduceti Dimensiune Vector:");
scanf("%d",&n);
pv=(float*)malloc(n*sizeof(float));
for(i=0;i<n;i++)
{printf("v[%d]=",i+1);
scanf("%f",pv+i);
}
int m,*pl;
printf("Introduceti nr de puncte de rupere:");
scanf("%d",&m);
pl=(int*)malloc((m+1)*sizeof(int));
int pct=0;
for(i=0;i<m;i++)
{printf("\nPunctul %d:",i+1);
scanf("%d",&pct);
if(!i)
*pl=pct;
else
*(pl+i)=pct-suma(pl,i);
}
*(pl+m)=n-pct;
float** pd;
pd=(float**)malloc((m+1)*sizeof(float*));
*pd=(float*)malloc(*pl*sizeof(float));
for(i=1;i<=m;i++)
*(pd+i)=(float*)malloc(*(pl+i)*sizeof(float));
i=0;
for(int j=0;j<=m;j++)
for(int k=0;k<*(pl+j);k++)
{*(*(pd+j)+k)=*(pv+i);
i=i+1;
}
for(i=0;i<=m;i++)
{printf("\nElemente vector %d:\n",i+1);
for(int j=0;j<*(pl+i);j++)
printf("%f",*(*(pd+i)+j));
}
free(pv);
free(pl);

for(i=0;i<=m;i++)
free(*(pd+i));
free(pd);
getch();
}

2) Frecventa de aparitie a valorii in vector

#include<stdio.h>
#include<conio.h>
#include<malloc.h>

//I - vectorul cu valori intregi, dimensiunea vectorului, numarul de valori distincte din vector.
//E - adresa masivului cu valorile distincte ale masivului de intrare
int* detValUniceVector (int* pv, int n, int *m)
{ int *pu;
*m=0;
pu=(int*)malloc(n*sizeof(int));
for(int i=0; i<n; i++)
{ int vb=0;
for(int j=0;j<n;j++)
if(*(pv+i)==*(pu+j))
vb=1;
if(!vb)
{ *(pu+*m)=*(pv+i);
*m=*m+1;
}
}
int *puN;
puN=(int*)malloc(*m*sizeof(int));
for(int i=0; i<*m;i++)
*(puN+i)=*(pu+i);
free(pu);
return puN;
}
//I - vectorul cu valori intregi, dimensiunea vectorului, vectorul cu valorile distincte ale vectorului de intrare,
vectorul cu frecventele de aparitie, numarul de valori distincte identificate in vectorul de intrare.
//E - frecventele de aparitie sunt calculate in locatiile vectorului de frecvente.
void calculFrecvente(int* pv, int n, int* pu, int* pf, int m)
{ for(int i=0;i<m;i++)
for(int j=0; j<n;j++)
if(*(pu+i)==*(pv+j))
*(pf+i)=*(pf+i)+1;
}
void main()
{
int n, *pv, i;
printf("Introduceti dimensiunea vectorului:");

scanf("%d",&n);
pv=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{ printf("v[%d]=",i+1);
scanf("%d",pv+i);
}
int m, *pu;
pu=detValUniceVector(pv,n,&m);
int *pf;
pf=(int*)malloc(m*sizeof(int));
for(i=0;i<m;i++)
*(pf+i)=0;
calculFrecvente(pv, n, pu, pf, m);
for(i=0;i<m;i++)
printf("\nValoarea %d are frecventa de aparitie %d", *(pu+i), *(pf+i));
free(pv);
free(pu);
free(pf);
getch();
}

3) Insereaza valoare nula pe pozitia anterioara fiecarei valori negative

#include<stdio.h>
#include<conio.h>
#include<malloc.h>

//I - vectorul cu valori intregi, dimensiunea vectorului de intrare.

//E - numarul de valori negative din vectorul de intrare
int calcululNrNegative(int* pv, int n)
{ int m=0;
for(int i=0;i<n;i++)
if(*(pv+i)<0)
m=m+1;
return m;
}
//I - vectorul de intrare cu valori intregi, lungimea vectorului de intrare, vectorul construit prin inserarea de
valori nule
//E - elementele noului vector prin suprascrierea locatiilor rezervate in vectorul rezultat transmis ca
parametru de intrare
void inserareNule (int* pv, int n, int*pf)
{ int j=0;
for(int i=0;i<n;i++)
{ if(*(pv+i)<0)
{ *(pf+j)=0;
j=j+1;
}

*(pf+j)=*(pv+i);
j=j+1;
}
}
void main()
{ int n, *pv,i;
printf("Introduceti dimensiunea vectorului:");
scanf("%d",&n);
pv=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{ printf("v[%d]=",i+1);
scanf("%d",pv+i);
}
int ng;
ng=calcululNrNegative(pv,n);
int m=n+ng;
int *pf=(int*)malloc(m*sizeof(int));
inserareNule(pv,n,pf);
printf("\n");
for(i=0;i<m;i++)
printf("%d",*(pf+i));
free(pv);
free(pf);
getch();
}

4) Sterge valorile duplicate

#include<stdio.h>
#include<malloc.h>
#include<conio.h>
void main()
{
int n, *pv,i;
printf("Introduceti dimensiunea vectorului:");
scanf("%d",&n);
pv=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{ printf("v[%d]=",i+1);
scanf("%d",pv+i);
}
int m=n;
for(i=0;i<n;i++)
{ int vb=0;
for(int j=0;j<i;j++)
if(*(pv+i)==*(pv+j))
vb=1;

if(vb)
{ for(int j=i;j<n-1;j++)
*(pv+j)=*(pv+j+1);
n=n-1;
i=i-1;
}
}
int *pn;
if(m!=n)
{ pn=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
*(pn+i)=*(pv+i);
free(pv);
}
printf("\n");
if(m!=n)
for(i=0;i<n;i++)
printf(" %d ", *(pn+i));
else
for(i=0;i<n;i++)
printf(" %d ", *(pv+i));
if(m==n)
free(pv);
else
free(pn);
getch();
}

5) Concateneaza vectori
#include<stdio.h>
#include<conio.h>
#include<malloc.h>

//I - vectorul cu adresele masivelor care se concateneaza, vectorul de lungimi ale masivelor de intrare,
numarul de masive care se concateneaza, lungimea vectorului obtinut prin concatenarea masivelor de intrare
//E - vectorul creat pentru stocarea masivelor concatenate
int* Concateneaza(int** pv, int*pn, int n, int* m)
{ int i,j,k=0;
*m=0;
for(i=0;i<n;i++)
*m=*m+*(pn+i);
int *pc=(int*)malloc(*m*sizeof(int));
for(i=0;i<n;i++)
for(j=0;j<*(pn+i);j++)
{ *(pc+k)=*(*(pv+i)+j);
k=k+1;
}

return pc;
}
void main()
{ int n, *pn, **pv, i;
printf("Introduceti numarul de vectori:");
scanf("%d",&n);
pn=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{printf("Dimensiune vector %d:", i+1);
scanf("%d",pn+i);
}
pv=(int**)malloc(n*sizeof(int*));
for(i=0;i<n;i++)
*(pv+i)=(int*)malloc(*(pn+i)*(sizeof(int)));
for(i=0;i<n;i++)
{ printf("\nIntroduceti elementele vectorului %d:\n",i+1);
for(int j=0;j<*(pn+i);j++)
{ printf("v%d[%d]=", i+1,j+1);
scanf("%d", *(pv+i)+j);
}
}
int m;
int *pm=Concateneaza(pv, pn, n, &m);
printf("\n");
for(i=0;i<m;i++)
printf(" %d ", *(pm+i));
for(i=0;i<n;i++)
free(*(pv+i));
free(pv);
free(pn);
free(pm);
getch();
}

6) Produsul a doi vectori

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - masivele de intrare ale operatiei produs vectorial, lungimile masivelor de intrare
//E - masivul cu valorile aferente produsului vectorial
int* PV(int* pv, int*pu, int n)
{ int i, *pw;
pw=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)

*(pw+i)=*(pv+i)**(pu+i);
return pw;
}
void main()
{ int *pv, *pu, i,m,n;
printf("Introduceti dimensiunea vectorului 1:");
scanf("%d",&m);
printf("Introduceti dimensiunea vectorului 2:");
scanf("%d",&n);
if(m==n)
{
pv=(int*)malloc(m*sizeof(int));
pu=(int*)malloc(n*sizeof(int));
for(i=0;i<m;i++)
{ printf("v1[%d]=", i+1);
scanf("%d", pv+i);
}
printf("\n");
for(i=0;i<n;i++)
{ printf("v2[%d]=", i+1);
scanf("%d", pu+i);
}
int* pp=PV(pv,pu,n);
printf("\n");
for(i=0;i<n;i++)
printf(" %d ", *(pp+i));
free(pv);
free(pu);
free(pp);
}
else
printf("\nDimensiunile vectorilor nu permit efectuarea operatiei!\n");
getch();
}

7) Interclaseaza doi vectori

#include<conio.h>
#include<stdio.h>
#include<malloc.h>
//I - vectorul cu valori intregi care se sorteaza, lungimea vectorului sortat
//E - nu se construieste o structura separata, vectorul de intrare avand elementele sortate

void sortare(int* pv, int m)

{ for(int i=0;i<m-1;i++)
for(int j=i+1; j<m; j++)
if(*(pv+i)>*(pv+j))
{ int aux=*(pv+i);
*(pv+i)=*(pv+j);
*(pv+j)=aux;
}
}
void main()
{ int m,n,*px,*py,i,j,k;
printf("Introduceti dimensiunea vectorului 1:");
scanf("%d",&m);
px=(int*)malloc(m*sizeof(int));
for(i=0;i<m;i++)
{ printf("v1[%d]=", i+1);
scanf("%d",px+i);
}
printf("Introduceti dimensiunea vectorului 2:");
scanf("%d",&n);
py=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{ printf("v2[%d]=", i+1);
scanf("%d",py+i);
}
sortare(px,m);
sortare(py,n);
int *pi=(int*)malloc((m+n)*sizeof(int));
k=0;
i=0;
j=0;
while(i<m && j<n)
{ if(*(px+i) < *(py+j))
{ *(pi+k)=*(px+i);
i=i+1;
}
else
{*(pi+k)=*(py+j);
j=j+1;
}
k=k+1;
}
if(i<m)
for(int ii=i;ii<m;ii++)
{ *(pi+k)=*(px+ii);
k=k+1;
}
else
for(int jj=j;jj<n;jj++)
{ *(pi+k)=*(py+jj);
k=k+1;

}
printf("\n");
for(i=0;i<k;i++)
printf(" %d ", *(pi+i));
free(px);
free(py);
free(pi);
getch();
}

8) Codul ASCII
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
#include<
void main()
{
char *src=NULL, *token=NULL;
char sep[]=".,";
int n=100;
src=(char*)malloc((n+1)*sizeof(char));
memset(src, 0X00,n+1);
printf("Introduceti sirul de caractere:");
scanf(" %s ", src);
token=strtok(src,sep);
char *pCuv[51];
int i=0;
while(token)
{ pCuv[i]=(char*)malloc(sizeof(char)*strlen(token)+1);
strcpy(pCuv[i],toke);
i=i+1;
token=strtok(NULL,sep);
}
printf("\n");
for(int j=0; j<i; j++)
printf("\n%s", pCuv[j]);
free(src);
for(int j=0; j<i; j++)
free(pCuv[j]);
getch();
}

9) Valorile strict pozitive

#include<stdio.h>
#include<conio.h>

#include<malloc.h>
//I - vectorul cu valori intregi pentru care se aplica operatia, lungimea vectorului de intrare
//E - numarul de elemente strict pozitive din vectorul de intrare
int nrPozitive(int* pv, int n)
{ int m=0;
for(int i=0; i<n; i++)
if( *(pv+i)>0)
m=m+1;
return m;
}
//I - vectorul de intrare cu valori intregi, lungimea vectorului de intrare, lungimea noului vector determinata
in cadrul functiei
//E - noua zona de memorie dinamica aferenta masivului cu valori intregi strict pozitive
int* extragerePoz(int* pv, int n, int *m)
{ *m=nrPozitive(pv,n);
int* pp=(int*)malloc(n*sizeof(int));
int i, j=0;
for(i=0;i<n;i++)
if(*(pv+i)>0)
{ *(pp+j)=*(pv+i);
j=j+1;
}
return pp;
}
void main()
{ int n, *pv, i;
printf("Introduceti dimensiunea vectorului:");
scanf("%d",&n);
pv=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{ printf("v[%d]=",i+1);
scanf("%d", pv+i);
}
int m;
int *pz=extragerePoz(pv,n,&m);
for(i=0;i<m;i++)
printf(" %d ", *(pz+i));
free(pv);
free(pz);
getch();
}

10) Identitatea multimilor

#include<stdio.h>
#include<conio.h>
#include<malloc.h>

10

//I - vectorul baza de comparare, vectorul comparat, vectorul indicatorilor de stare, lungimile celor doi
vectori
//E - valoarea semafor de identitate a celor doi vector
int verificaIdentitatea(float* px, float* py, int* ps, int m, int n)
{ int i,j,vb=0;
for(i=0;i<m;i++)
{ int vbs=0;
for(j=0;j<n;j++)
if(*(px+i)==*(py+j))
{ *(ps+j)=1;
vbs=1;
}
if(!vbs)
vb=1;
}
if(vb)
return 0;
else
for(i=0;i<n;i++)
if(!*(ps+i))
return 0;
return 1;
}
void main()
{ int m,n,i;
float *px, *py;
printf("Introduceti dimensiunea vectorului 1:");
scanf("%d", &m);
px=(float*)malloc(m*sizeof(float));
for(i=0;i<m;i++)
{printf("v1[%d]=",i+1);
scanf("%f", px+i);
}
printf("Introduceti dimensiunea vectorului 2:");
scanf("%d", &n);
py=(float*)malloc(n*sizeof(float));
for(i=0;i<n;i++)
{printf("v2[%d]=",i+1);
scanf("%f",py+i);
}
int *pis=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
*(pis+i)=0;
int vb=verificaIdentitatea(px,py,pis,m,n);
if(vb)
printf("\nVectorii sunt identici!");
else
printf("\nVectorii contin multimi diferite de valori!");
free(px);
free(py);
free(pis);
getch();

11

11) Matrice patratica cu valori constante

#include<conio.h>
#include<stdio.h>
#include<malloc.h>
int main()
{int **pm,n,i,j;
printf("Dimensiunea Matricei:");
scanf("%d",&n);
pm=(int**)malloc(n*sizeof(int*));
for(i=0;i<n;i++)
*(pm+i)=(int*)malloc(n*sizeof(int));
int c;
printf("Valoare constantei:");
scanf("%d",&c);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(j==i || j==n-i-1)
*(*(pm+i)+j)=c;
else
*(*(pm+i)+j)=0;
for(i=0;i<n;i++)
{printf("\n");
for(j=0;j<n;j++)
printf("%d",*(*(pm+i)+j));
}
for(i=0;i<n;i++)
free(*(pm+i));
free(pm);
getch();
}

12) Liniarizarea lexicografica

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
int main()
{int **pm,m,n,i,j;
printf("Introduceti nr de linii:");
scanf("%d",&m);
printf("Introduceti nr de coloane:");
scanf("%d",&n);
pm=(int**)malloc(m*sizeof(int*));
for(i=0;i<m;i++)
*(pm+i)=(int*)malloc(n*sizeof(int));
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{printf("M[%d][%d]=",i+1,j+1);
scanf("%d",*(pm+i)+j);
}
int *pv,nr,k;

12

nr=m*n;
pv=(int*)malloc(nr*sizeof(int));
k=0;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{*(pv+k)=*(*(pm+i)+j);
k=k+1;
}
printf("\n");
for(i=0;i<nr;i++)
printf("%d",*(pv+i));
for(i=0;i<m;i++)
free(*(pm+i));
free(pm);
free(pv);
getch();
}

13) Suma a doua matrici

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - doua matrice cu valor reale, dimensiunea celor doua matrice data in numar de linii si coloane
//E - adresa de memorie dinamica pentru gestionarea matricei rezultat
float** sumaMat(float **pa, float **pb, int m, int n)
{float **suma;
int i,j;
suma=(float**)malloc(m*sizeof(float*));
for(i=0;i<m;i++)
*(suma+i)=(float*)malloc(n*sizeof(float));
for(i=0;i<m;i++)
for(j=0;j<n;j++)
*(*(suma+i)+j)=*(*(pa+i)+j)+*(*(pb+i)+j);
return suma;
}
void main() {
float **pa, **pb;
int m,n,p,r,i,j;
printf("Introduceti numarul de linii matrice A:");
scanf("%d",&m);
printf("Introduceti numarul de coloane matrice A:");
scanf("%d",&n);
printf("Introduceti numarul de linii matrice B:");
scanf("%d",&p);
printf("Introduceti numarul de coloane matrice B:");
scanf("%d",&r);
if(m==p && n==r)
{ pa=(float **)malloc(m*sizeof(float*));
for(i=0;i<m;i++)
*(pa+i)=(float*)malloc(n*sizeof(float));

13

pb=(float**)malloc(p*sizeof(float*));
for(i=0;i<p;i++)
*(pb+i)=(float*)malloc(r*sizeof(float));
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{printf("A[%d][%d]=", i+1,j+1);
scanf("%f",*(pa+i)+j);
}
for(i=0;i<p;i++)
for(j=0;j<r;j++)
{printf("B[%d][%d]=", i+1,j+1);
scanf("%f",*(pb+i)+j);
}
float **ps;
ps=sumaMat(pa,pb,m,n);
for(i=0;i<m;i++)
{ printf("\n");
for(j=0;j<n;j++)
printf(" %7.2f ", *(*(ps+i)+j));
}
for(i=0;i<m;i++)
free(*(pa+i));
free(pa);
for(i=0;i<m;i++)
free(*(pb+i));
free(pb);
for(i=0;i<m;i++)
free(*(ps+i));
free(ps);
}
else
printf("\nOperatia nu poate fi efectata");
getch();
}

14) Transpusa unei matrici

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - matricea pentru care se determina transpusa, matricea rezultat cu valorile transpuse, dimensiunea celor
doua matrice data in numar de linii si coloane
//E - valorile transpuse ale matricei sunt plasate in memoria dinamica pe baza adresei matricei rezultat
transmisa catre functie in lista de parametri
void transpusaMat (float **pm, float **pt, int m, int n)
{ for (int i=0; i<m;i++)
for(int j=0; j<n;j++)
*(*(pt+j)+i)=*(*(pm+i)+j);
}

14

void main()
{ float **pm;
int m,n,i,j;
printf("Introduceti numarul de linii:");
scanf("%d",&m);
printf("\nIntroduceti numarul de coloane:");
scanf("%d",&n);
pm=(float**)malloc(m*sizeof(float*));
for(i=0;i<m;i++)
*(pm+i)=(float*)malloc(n*sizeof(float));
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{printf("M[%d][%d]=", i+1,j+1);
scanf("%f", *(pm+i)+j);
}
float **pt;
pt=(float**)malloc(n*sizeof(float*));
for(i=0;i<n;i++)
*(pt+i)=(float*)malloc(m*sizeof(float));
transpusaMat(pm,pt,m,n);
for(i=0;i<n;i++)
{printf("\n");
for(j=0;j<m;j++)
printf(" %7.2f ", *(*(pt+i)+j));
}
for(i=0;i<m;i++)
free(*(pm+i));
free(pm);
for(i=0;i<m;i++)
free(*(pt+i));
free(pt);
getch();
}

15) Modificarea structurii primei linii

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - vectorul cu valori intregi care se sorteaza crescator, numarul de valori din vector
//E - sirul ordonat de valori accesibil in zona de memorie dinamica aferenta vectorului
void sortareVector(int *pv, int n)
{ for(int i=0;i<n-1;i++)
for(int j=i+1;j<n;j++)
if(*(pv+i)>*(pv+j))
{ int aux=*(pv+i);
*(pv+i)=*(pv+j);
*(pv+j)=aux;
}
}

15

//I - vectorul cu valori intregi sortate crescator, numarul de linii care se insereaza, numarul de linii din
matricea care isi modifica structura
//E - indicator de validare: valoarea 0 pentru vector invalid, valoarea 1 pentru vector valid
int validarePozitii(int *pv, int n,int m)
{ int *pis;
pis=(int*)malloc(n*sizeof(int));
for(int i=0;i<n;i++)
*(pis+i)=0;
for(int i=0;i<n-1;i++)
for(int j=i+1; j<n;j++)
if(*(pv+i)==*(pv+j))
*(pis+i)=*(pis+j)=1;
for(int i=0;i<n;i++)
if(*(pis+i))
{free(pis);
return 0;
}
for(int i=0;i<n;i++)
*(pis+i)=0;
for(int i=0;i<n;i++)
if(*(pv+i)>m+n)
*(pis+i)=1;
for(int i=0;i<n;i++)
if(*(pis+i))
{ free(pis);
return 0;
}
free(pis);
return 1;
}
void main()
{ float **pm;
int m,n,i,j;
printf("Introduceti numarul de linii al matricei: ");
scanf("%d",&m);
printf("Introduceti numarul de coloane al matricei: ");
scanf("%d",&n);
pm=(float**)malloc(m*sizeof(float*));
for(i=0;i<m;i++)
*(pm+i)=(float*)malloc(n*sizeof(float));
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{ printf("M[%d][%d]=", i+1, j+1);
scanf("%f", *(pm+i)+j);
}
float **pr;

16

int *pv;
int r;
printf("Introduceti numarul de linii suplimentare:");
scanf("%d",&r);
pv=(int*)malloc(r*sizeof(int));
printf("Introduceti pozitiile in matricea rezultat pentru liniile de inserat:\n");
for(i=0;i<r;i++)
{ printf("Linia %d:", i+1);
scanf("%d",pv+i);
}
sortareVector(pv,r);
int vb=validarePozitii(pv,r,m);
if(vb)
{ pr=(float**)malloc((m+r)*sizeof(float*));
for(i=0;i<m+r;i++)
*(pr+i)=(float*)malloc(n*sizeof(float));
int k=0, pmi=0;
for(i=0; i<m+r; i++)
if(i==*(pv+k)-1)
{ for(j=0;j<n;j++)
*(*(pr+i)+j)=0;
k=k+1;
}
else
{ for(j=0;j<n;j++)
*(*(pr+i)+j)=*(*(pm+pmi)+j);
pmi=pmi+1;
}
for(i=0;i<m;i++)
free(*(pm+i));
free(pm);
pm=pr;
pr=NULL;
for(i=0;i<m+r;i++)
{ printf("\n");
for(j=0;j<n;j++)
printf(" %7.2f ", *(*(pm+i)+j));
}
}
else
printf("\nVectorul de pozitii ale liniilor nu este corect specificat!\n");
for(i=0;i<m+r;i++)
free(*(pm+i));
free(pm);
free(pv);
getch();
}

16) Suma elementelor de sub diagonala

#include<stdio.h>
#include<conio.h>
#include<malloc.h>

17

int sumasec(int **pm,int n)

{int i,j,s=0;
for(i=1;i<n;i++)
for(j=n-1;j>n-i-1;j--)
s=s+*(*(pm+i)+j);
return s;
}
int main()
{int **pm=NULL , n,i,j;
printf("Dimensiune Matrice:");
scanf("%d",&n);
pm=(int**)malloc(n*sizeof(int*));
for(i=0;i<n;i++)
*(pm+i)=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{printf("M[%d][%d]=",i+1,j+1);
scanf("%d",*(pm+i)+j);
}
for(i=0;i<n;i++)
{printf("\n");
for(j=0;j<n;j++)
printf("%d",*(*(pm+i)+j));
}
printf("\nSuma elementelor de sub diagonala secundara este %d:\n",sumasec(pm,n));
for(i=0;i<n;i++)
if(*(pm+i))
free(*(pm+i));
if(pm)
free(pm);
getch();
}

18