Matrice i pokazivai

Napisati program za dinamiko alociranje nxn elemenata matrice mat. Uneti elemente
matrice i pozitivne i parne elemente zameniti sa 1. Ispisati novu matricu.
#include<stdio.h>
#include<stdlib.h>
main()
{
int **mat, i, j, n;
printf("Uneti dimenziju matrice\n");
scanf("%d",&n);
mat = (int**)malloc(n*sizeof(int*));
/*
mat = (int**)calloc(n, sizeof(int*));
*/
printf("Uneti elemente matrice\n");
for (i=0; i<n; i++)
{
*(mat+i)=(int*)malloc(n*sizeof(int));
/* *(mat+i)=(int*)calloc(n, sizeof(int));*/
for (j=0; j<n; j++)
scanf("%d",&mat[i][j]);
}
for (i=0 ; i<n ; i++ )
for (j=0; j<n; j++)
if(mat[i][j]>0&&mat[i][j]%2==0)
mat[i][j]=1;
printf("Elementi matrice su:\n");
for (i=0 ; i<n ; i++ )
{
for (j=0; j<n; j++)
printf("%d\t", *(*(mat+i)+j));
/*printf("%d\t", mat[i][j]); */
printf("\n");
}
free(mat);
}
ili preko funkcija
#include<stdio.h>
#include<stdlib.h>
/*Funkcija za unos elemenata matrice*/
void unos(int **mat, int n)
{
int i, j;
for (i=0; i<n; i++)

{
*(mat+i)=(int*)malloc(n*sizeof(int));
for (j=0; j<n; j++)
scanf("%d",&mat[i][j]);
}
}
/*Funkcija za ispis elemenata matrice*/
void ispis(int **mat, int n)
{
int i, j;
for (i=0 ; i<n ; i++ )
{
for (j=0; j<n; j++)
printf("%d\t", mat[i][j]);
printf("\n");
}
}
void formiraj(int **mat, int n)
{
int i, j;
for (i=0 ; i<n ; i++ )
for (j=0; j<n; j++)
if(mat[i][j]>0&&mat[i][j]%2==0)
mat[i][j]=1;
}
void main()
{
int **mat, n;
printf("Uneti dimenziju matrice\n");
scanf("%d",&n);
mat = (int**)malloc(n*sizeof(int*));
printf("Uneti elemente matrice\n");
unos(mat,n);
formiraj(mat,n);
printf("Elementi matrice su:\n");
ispis(mat, n);
free(mat);
}

Data je celobrojna matrica mat dimenzija nxn. Napisati program za unos

elemenata matrice sa standardnog ulaza i formirati niz C koji se dobija kada
se sumiraju pozitivni elementi po vrstama matrice.Izvriti dinamiku
alokaciju memorije za niz i matricu.
#include<stdio.h>
#include<stdlib.h>
void unos(int **mat, int n)
{
int i, j;
for (i=0; i<n; i++)
{
*(mat+i)=(int*)malloc(n*sizeof(int));
for (j=0; j<n; j++)
scanf("%d",&mat[i][j]);
}
}
void ispis(int *C, int n)
{
int i;
for (i=0 ; i<n ; i++ )
printf("%d\n", C[i]);
}
void formiraj(int **mat, int *C, int n)
{
int i, j;
for (i=0;i<n;i++)
{
C[i]=0;
for(j=0;j<n;j++)
if(mat[i][j]>0)
C[i]+= mat[i][j];
}
}
void main()
{
int **mat, *C, n;
printf("Uneti dimenziju matrice\n");
scanf("%d",&n);
mat = (int**)malloc(n*sizeof(int*));
C=(int*)malloc(n*sizeof(int));
printf("Uneti elemente matrice\n");
unos(mat,n);
formiraj(mat,C,n);
printf("Kreirani niz je:\n");
ispis(C,n);
free(mat);
free(C);

}
Napisati program za sabiranje matrica A i B dimenzije n i tampanje rezultujue matrice
C.
#include<stdio.h>
#include<stdlib.h>
void unos(int **mat, int n)
{
int i, j;
for (i=0; i<n; i++)
{
*(mat+i)=(int*)malloc(n*sizeof(int));
for (j=0; j<n; j++)
scanf("%d",&mat[i][j]);
}
}
void ispis(int **mat, int n)
{
int i, j;
for (i=0 ; i<n ; i++ )
{
for (j=0; j<n; j++)
printf("%d\t", mat[i][j]);
printf("\n");
}
}
void sabiranje(int **A, int **B, int **C, int n)
{
int i, j;
for (i=0 ; i<n ; i++ )
for (j=0; j<n; j++)
C[i][j]=A[i][j]+B[i][j];
}
void main()
{
int **A, **B, **C, i, j, n;
printf("Uneti dimenziju matrice\n");
scanf("%d",&n);
A = (int**)malloc(n*sizeof(int*));
B = (int**)malloc(n*sizeof(int*));
C = (int**)malloc(n*sizeof(int*));
for (i=0; i<n; i++)
*(C+i)=(int*)malloc(n*sizeof(int));

printf("Uneti elemente matrice A\n");

unos(A,n);
printf("Uneti elemente matrice B\n");
unos(B,n);
sabiranje(A, B, C,n);
printf("Elementi matrice su C:\n");
ispis(C, n);
free(A);
free(B);
free(C);
}
Data je realna matrica M dimenzija nxn. Formirati niz C koji se dobija od
elemenata matrice M iji elementi se nalaze na sporednoj dijagonali i ispod
glavne dijagonale. Izvriti dinamiku alokaciju memorije za niz i matricu.
#include<stdio.h>
#include<stdlib.h>
void unos(int **mat, int n)
{
int i, j;
for (i=0; i<n; i++)
{
*(mat+i)=(int*)malloc(n*sizeof(int));
for (j=0; j<n; j++)
scanf("%d",&mat[i][j]);
}
}
void ispis(int *C, int n)
{
int i;
for (i=0 ; i<n ; i++ )
printf("%d\n", C[i]);
}
void main()
{
int **M, *C, i , j;
int br=0, n;
printf("Uneti dimenziju matrice\n");
scanf("%d",&n);
M = (int**)malloc(n*sizeof(int*));
C=(int*)malloc(n*n*sizeof(int));
printf("Uneti elemente matrice\n");
unos(M,n);
br=0;
for (i=0;i<n;i++)

for(j=0;j<n;j++)
if(i+j==n-1||i>j)
C[br++] = M[i][j];
printf("Kreirani niz je:\n");
ispis(C,br);
free(M);
free(C);
}
Data je celobrojna matrica M dimenzija nxn. Formirati niz A koji se dobija od
elemenata matrice M iji elementi se nalaze iznad glavne dijagonale i niz B
koji se dobija od elemenata matrice iz poslednje kolone. Ispisati dobijene
nizove. Izvriti dinamiku alokaciju memorije za nizove i matricu.
#include<stdio.h>
#include<stdlib.h>
void unos(int **mat, int n)
{
int i, j;
for (i=0; i<n; i++)
{
*(mat+i)=(int*)malloc(n*sizeof(int));
for (j=0; j<n; j++)
scanf("%d",&mat[i][j]);
}
}
void ispis(int *C, int n)
{
int i;
for (i=0 ; i<n ; i++ )
printf("C[%d]=%d\n",i, C[i]);
}
void main()
{
int **M, *A, *B, n, i, j, br=0;
printf("Uneti dimenziju matrice\n");
scanf("%d",&n);
M = (int**)malloc(n*sizeof(int*));
A=(int*)malloc(n*sizeof(int));
B=(int*)malloc(n*sizeof(int));
printf("Uneti elemente matrice\n");
unos(M,n);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(i<j)
A[br++]=M[i][j];

for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(j==n-1)
B[i]=M[i][j];
printf("Niz A je:\n");
ispis(A,br);
printf("Niz B je:\n");
ispis(B,n);
free(M);
free(A);
free(B);
}

Napisati program za unos celobrojnog niza A dimenzije n.

Formirati matricu M koja se dobija kada se elementi niza A smeste
na sporednu dijagonalu, iznad sporedne dijagonale elementi imaju
vrednost 0, a ispod sporedne jednak je proizvodu indeksa.
Koristiti funkcije i dinamiku alokaciju memorije.
#include<stdio.h>
#include<stdlib.h>
void unos(int *A, int n)
{
int i;
for (i=0; i<n; i++)
scanf("%d",(A+i));
}
void ispis(int **M, int n)
{
int i,j;
for (i=0 ; i<n ; i++ )
{
for (j=0 ; j<n ; j++ )
printf("%d\t", M[i][j]);
printf("\n");
}
}
void main()
{
int **M, *A, i , j, n;
printf("Uneti dimenziju niza\n");
scanf("%d",&n);
M = (int**)malloc(n*sizeof(int*));
for (i=0; i<n; i++)
*(M+i)=(int*)malloc(n*sizeof(int));
A=(int*)malloc(n*sizeof(int));
printf("Uneti elemente niza\n");
unos(A,n);
for (i=0;i<n;i++)
for(j=0;j<n;j++)
if(i+j==n-1)
M[i][j]=A[i];
else if(i+j<n-1)
M[i][j]=0;
else
M[i][j]=i*j;
printf("Kreirana matrica je:\n");
ispis(M,n);

free(M);
free(A);
}

#include<stdio.h>
#include<stdlib.h>
void unos(int *A, int n)
{
int i;
for (i=0; i<n; i++)
scanf("%d",(A+i));
}
void ispis(int **M, int n)
{
int i,j;
for (i=0 ; i<n ; i++ )
{
for (j=0 ; j<n ; j++ )
printf("%d\t", M[i][j]);
printf("\n");
}
}
void razmeni(int *x, int*y)
{
int pom;
pom=*x;
*x=*y;
*y=pom;
}
void sort(int **M, int n)
{
int i,j,k;
for(i=0;i<n;i++)
for(j=0;j<n-1;j++)
for(k=j+1;k<n;k++)
if(M[i][j]>M[i][k])
razmeni(&M[i][j],&M[i][k]);
}
void sortkolona(int **M, int n)
{
int i,j,k;
for(i=0;i<n;i++)
for(j=0;j<n-1;j++)
for(k=j+1;k<n;k++)
if(M[j][i]>M[k][i])
razmeni(&M[j][i],&M[k][i]);
}
void main()
{

int **M, *A, i , j, n;

printf("Uneti dimenziju niza\n");
scanf("%d",&n);
M = (int**)malloc(n*sizeof(int*));
for (i=0; i<n; i++)
*(M+i)=(int*)malloc(n*sizeof(int));
A=(int*)malloc(n*sizeof(int));
printf("Uneti elemente niza\n");
unos(A,n);
for (i=0;i<n;i++)
for(j=0;j<n;j++)
if(i==j)
M[i][j]=A[i];
else if(i>j)
M[i][j]=1;
else
M[i][j]=i+j;
printf("Kreirana matrica je:\n");
ispis(M,n);
sort(M,n);
printf("Matrica sortirana po vrsti:\n");
ispis(M,n);
sortkolona(M,n);
printf("Matrica sortirana po koloni:\n");
ispis(M,n);
free(M);
free(A);
}
Prethodni primer sa sortiranjem
#include<stdio.h>
#include<stdlib.h>
void unos(int **M, int n)
{
int i,j;
for (i=0; i<n; i++)
for(j=0;j<n;j++)
scanf("%d",&M[i][j]);
}
void ispis(int **M, int n)
{
int i,j;
for (i=0 ; i<n ; i++ )

{
for (j=0 ; j<n ; j++ )
printf("%d\t", M[i][j]);
printf("\n");
}
}
void razmeni(int *x, int*y)
{
int pom;
pom=*x;
*x=*y;
*y=pom;
}
void sort(int **M, int n)
{
int i,j,k;
for(i=0;i<n;i++)
for(j=0;j<n-1;j++)
for(k=j+1;k<n;k++)
if(M[i][j]>M[i][k])
razmeni(&M[i][j],&M[i][k]);
}
void sortkolona(int **M, int n)
{
int i,j,k;
for(i=0;i<n;i++)
for(j=0;j<n-1;j++)
for(k=j+1;k<n;k++)
if(M[j][i]>M[k][i])
razmeni(&M[j][i],&M[k][i]);
}
void main()
{
int **M, **K, i , j, n;
printf("Uneti dimenziju matrice\n");
scanf("%d",&n);
M = (int**)malloc(n*sizeof(int*));
for (i=0; i<n; i++)
*(M+i)=(int*)malloc(n*sizeof(int));
printf("Uneti elemente matrice M\n");
unos(M,n);
K = (int**)malloc(n*sizeof(int*));
for (i=0; i<n; i++)
*(K+i)=(int*)malloc(n*sizeof(int));
for (i=0;i<n;i++)

for(j=0;j<n;j++)
if(j==0||j==n-1)
K[i][j]=i+j;
else
K[i][j]=M[i][j];
printf("Kreirana matrica M je:\n");
ispis(M,n);
sort(M,n);
printf("Kreirana matrica M posle sortiranja po vrsti
je:\n");
ispis(M,n);
sortkolona(M,n);
printf("Kreirana matrica M posle sortiranja po koloni
je:\n");
ispis(M,n);
printf("Kreirana matrica K je:\n");
ispis(K,n);
free(M);
free(K);
}

#include<stdio.h>
#include<stdlib.h>
void unos(int **mat, int n)
{
int i, j;
for (i=0; i<n; i++)
{
*(mat+i)=(int*)malloc(n*sizeof(int));
for (j=0; j<n; j++)
scanf("%d",&mat[i][j]);
}
}
void ispis(int *A, int n)
{
int i;
for (i=0 ; i<n ; i++ )
printf("%d\n", *(A+i));
}
void razmeni(int *x, int*y)
{
int pom;
pom=*x;
*x=*y;
*y=pom;
}
void sort(int *A, int n)
{
int i, j;
for (i=0 ; i<n-1 ; i++ )
for (j=i+1; j<n; j++)
if(*(A+i)>*(A+j))
razmeni((A+i),(A+j));
}
void main()
{
int *A, **M, i,j, n, dim=0;
printf("Uneti dimenziju matrice\n");
scanf("%d",&n);
A = (int*)malloc(n*n*sizeof(int*));
M = (int**)malloc(n*sizeof(int*));
printf("Uneti elemente matrice M\n");
unos(M,n);

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

for (j=0; j<n; j++)
A[dim++]=M[j][i];
printf("Elementi niza A pre sortiranja su:\n");
ispis(A, dim);
sort(A,dim);
printf("Elementi Niza A su:\n");
ispis(A, dim);
free(A);
free(M);
}
Napisati program za unos matrice M dimenzije n*n. Formirati niz A
koji se dobija od elemenata matrice koji se nalaze u prvoj i
poslednjoj koloni. Ispisati dobijeni niz na standardnom izlazu. U
reavanju programa koristiti dinamiku alkoaciju memorije i
funkcije.
#include<stdio.h>
#include<stdlib.h>
void unos(int **mat, int n)
{
int i, j;
for (i=0; i<n; i++)
for (j=0; j<n; j++)
scanf("%d",&mat[i][j]);
}
void ispis(int *A, int n)
{
int i;
for (i=0 ; i<n ; i++ )
printf("%d\n", A[i]);
}
void main()
{
int **M, *A, i , j, n, k=0;
printf("Uneti dimenziju matrice\n");
scanf("%d",&n);
M = (int**)malloc(n*sizeof(int*));
for (i=0; i<n; i++)
*(M+i)=(int*)malloc(n*sizeof(int));
A=(int*)malloc(2*n*sizeof(int));
printf("Uneti elemente matrice\n");
unos(M,n);
for(j=0;j<n;j++)

for (i=0;i<n;i++)
if(j==0||j==n-1)
A[k++]=M[i][j];
printf("Kreirani niz je:\n");
ispis(A,k);
free(M);
free(A);
}
Napisati program za unos celobrojnog niza A dimenzije n.
Formirati matricu M koja se dobija kada se elementi niza A smeste
na glavnu dijagonalu, iznad glavne dijagonale elementi imaju
vrednost 1, a ispod glavne zadatu vrednost k. Koristiti funkcije
i dinamiku alokaciju memorije.
#include<stdio.h>
#include<stdlib.h>
void unos(int *A, int n)
{
int i;
for (i=0; i<n; i++)
scanf("%d",(A+i));
}
void ispis(int **M, int n)
{
int i,j;
for (i=0 ; i<n ; i++ )
{
for (j=0 ; j<n ; j++ )
printf("%d\t", M[i][j]);
printf("\n");
}
}
void main()
{
int **M, *A, i , j, n,k;
printf("Uneti dimenziju niza\n");
scanf("%d",&n);
M = (int**)malloc(n*sizeof(int*));
for (i=0; i<n; i++)
*(M+i)=(int*)malloc(n*sizeof(int));
A=(int*)malloc(n*sizeof(int));
printf("Uneti elemente niza\n");

unos(A,n);
printf("Uneti k");
scanf("%d",&k);
for (i=0;i<n;i++)
for(j=0;j<n;j++)
if(i==j)
M[i][j]=A[i];
else if(i<j)
M[i][j]=1;
else
M[i][j]=k;
printf("Kreirana matrica je:\n");
ispis(M,n);
free(M);
free(A);
}
Napisati program za unos celobrojnog niza A dimenzije n.