MATRICE

/*Pojedine cifre brojeva popunjavaju matricu po redovima(ostatak se popunjavam nulama).
Broj kolona
matrice jednak je broju cifara najveceg unesenog visecifrenog broja.
npr. unesu se brojevi: 123, 22, 4125.Unos brojeva prekinuti onda kada se unese 0.
matrica:
1 2 3 0
2 2 0 0
4 1 2 5 */
#include<stdio.h>
#include<stdlib.h>
#define MAX 50
main()
{
int mat[MAX][MAX],red,kol,i=0,broj,n=0,niz[MAX],max_br_cifara=0, maxIndex,br_red,br_kol;
int brojcifara=0,m,pom[MAX],pom_var[MAX],nova_pomocna[MAX],bonibon,var;
printf("\nUnesite elemente niza:\n");

do{
scanf("%d",&broj);
if(broj>9)
{
niz[i]=broj;
i++;
n++;
}
}while(broj!=0);
//Ispis niza
printf("\Unijeli ste niz:");

for(i=0; i<n; i++)
{
printf("%d\t",niz[i]);
}
//Odredjivanje dimenzija matrice

pom[0]=niz[0];
while(pom[0]>0)
{
pom[0]=pom[0]/10;
max_br_cifara++;
maxIndex=0;
}
red=0;
for(i=1; i<n; i++)
{
pom[i]=niz[i];
while(pom[i]>0)
{
pom[i]=pom[i]/10;
++brojcifara;
}
if(brojcifara>max_br_cifara)
{
max_br_cifara=brojcifara;
maxIndex=i;
}
brojcifara=0;
}
br_red=n;
br_kol=max_br_cifara;
//Formiranje matrice
for(i=0; i<n; i++)

{
pom_var[i]=niz[i];
while(pom_var[i]>0)
{
pom_var[i]=pom_var[i]/10;
++brojcifara;
}
kol=br_kol-1;
var=br_kol;
while(var>brojcifara)
{
mat[red][kol]=0;
kol--;
var--;
}
nova_pomocna[i]=niz[i];
while(nova_pomocna[i]>0)
{
m=nova_pomocna[i]%10;
mat[red][kol]=m;
kol--;
nova_pomocna[i]=nova_pomocna[i]/10;
red++;
brojcifara=0;
}
printf("\nMatrica je:\n");
for(red=0; red<br_red; red++)
{
for(kol=0; kol<br_kol; kol++)
{
printf("\t%d",mat[red][kol]);
}
printf("\n\n");
}
system("pause");
}
/*********************************************************************************/
/*Zamjena mijesta prve i zadnje kolone, druge i predzadnje, itd..*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom,temp;
printf("Unesite dimenziju matrice:");

scanf("%d",&dimenzija);
printf("\nUnesite elemente matrice:");
for( red=0; red<dimenzija; red++)
{
for( kol=0; kol<dimenzija;kol++)
{
printf("MAT[%d][%d]=",red,kol);
scanf("%d",&mat[red][kol]);
}
}
printf("Stara matrica je:\n");

{
{
}
printf("\n\n");
}
pom=dimenzija-1;
for(kol=0; kol<dimenzija/2; kol++)
{
for(red=0; red<dimenzija; red++)
{
temp=mat[red][kol];
mat[red][kol]=mat[red][pom];
mat[red][pom]=temp;
}
pom--;
}
printf("\nNova matrica je:\n");

{
{
}
printf("\n\n");
}
system("pause");
}
/*********************************************************************************/
/*Pojedine cifre brojeva popunjavaju matricu po redovima(ostatak se popunjavam nulama). Broj kolona
matrice jednak je broju cifara najveceg unesenog visecifrenog broja.
npr. unesu se brojevi: 123, 22, 4125.Unos brojeva prekinuti onda kada se unese 0.
matrica:
1 2 3 0
2 2 0 0
4 1 2 5 */
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int
mat[MAX][MAX],red,kol,max=0,br_cifara=0,n,broj,niz[MAX],k=0,i,brojac=0,ostatak_pri_djeljenju,pom,m,d,p;
//Potrebno je da unosimo visecifrene brojeve i da prekinemo unos kada unesemo 0.

do{
printf("\n\nUnesite visecifren broj:");
scanf("%d",&broj);
if(broj>9)
{
niz[k++]=broj;
n=broj;
while(n>0)
{
br_cifara++;
n=n/10;
}
if(br_cifara>max)
{
max=br_cifara;
}
br_cifara=0;
}
}while(broj!=0);
printf("\n\nNiz ispravno unesenih brojeva je:\n\n");

for(i=0; i<k; i++)
{
printf("%d\t",niz[i]);
}
printf("\n\nMaksimalan broj cifara je %d.",max);
/*******************************KREIRANJE MATRICE********************************************/
d=max;
for(red=k-1; red>=0; red--)
{
n=niz[red];
while(n>0)
{
brojac++;
n=n/10;
}
if(brojac==max)
{
m=niz[red];
for(kol=max-1; kol>=0; kol--)
{
if(m>0)
{
ostatak_pri_djeljenju=m%10;
mat[red][kol]=ostatak_pri_djeljenju;
m=m/10;
}
}
else if(brojac<max)
{
pom=d-brojac;
kol=max-1;
for(p=0; p<pom; p++)

{
mat[red][kol]=0;
kol--;
}
m=niz[red];
for(kol; kol>=0; kol--)
{
if(m>0)
{
ostatak_pri_djeljenju=m%10;
mat[red][kol]=ostatak_pri_djeljenju;
m=m/10;
}
}
d=max+1;
}
brojac=0;
}
printf("\n\nMatrica:\n\n");
for(red=0; red<k; red++)
{
for(kol=0; kol<max; kol++)
{
printf("%d\t",mat[red][kol]);
}
printf("\n\n");
}
system("pause");
//U ovom slucaju radi ali ne stampa prvu cifru na 0,0
/*********************************************************************************/
/*Zamjena mijesta prve i zadnje kolone, druge i predzadnje, itd..*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom,temp;


{
{
}
}

{
{
}
printf("\n\n");
}
pom=dimenzija-1;
for(kol=0; kol<dimenzija/2; kol++)
{
{
temp=mat[red][kol];
mat[red][kol]=mat[red][pom];
mat[red][pom]=temp;
}
pom--;
}

{
{
}
printf("\n\n");
}
system("pause");
}
/*********************************************************************************/
/*7) Popunjavanje mijesta ispod glavne dijagonale elementima niza*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,niz[MAX],i,brel=0;


{
{
}
}

{
{
}
printf("\n\n");
}

{
for(kol=0; kol<dimenzija; kol++)
{
if(red>kol)
{
brel++;
}
}
}
printf("\nUnesite elemente niza:");

for(i=0; i<brel; i++)
{
printf("%d. element niza: ",i+1);
scanf("%d",&niz[i]);
}
//Popunjavanje matrice ispod glavne dijagonale elementima niza

i=0;
{
{
if(red>kol)
{
mat[red][kol]=niz[i];
i++;
}
}
}
//Ispis transformisane matrice

{
{
}
printf("\n\n");
}
system("pause");
}
/*********************************************************************************/
/* Zamjena najveceg i najmanjeg elementa pojedinih redova sa vrijednoscu sume elemenata

pojedinih redova
npr za red matrice:
1 5 8 9, suma je 23, red ce nakon transformacije izgledati:
23 5 8 23 */
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,suma=0,max,maxKol,min,minKol;


{
{
}
}

{
{
}
printf("\n\n");
}
//Pronalazenje minimalnog i maksimalnog clana i zamjena tih clanova zbirom elemenata tekuce vrste

{
max=mat[red][0];
min=mat[red][0];
maxKol=0;
minKol=0;

{
if(mat[red][kol]<min)
{
min=mat[red][kol];
minKol=kol;
}
if(mat[red][kol]>max)
{
max=mat[red][kol];
maxKol=kol;
}
suma=suma+mat[red][kol];
}
mat[red][maxKol]=suma;
mat[red][minKol]=suma;
suma=0;
}

{
{
}
printf("\n\n");
}
system("pause");
}
/*********************************************************************************/
/* Od glavne i sporedne dijagonale matrice napraviti dva niza, potom najveci i najmanji element niza
zamijeniti vrijednoscu sume svih elemenata pojedinih nizova
zatim tako transformisan niz vratiti u matricu*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int
mat[MAX][MAX],dimenzija,red,kol,max,maxIndex,min,minIndex,max1,maxIndex1,min1,minIndex1,suma=0,suma1=0;
int niz_glavna[MAX],niz_sporedna[MAX],i,j,m=0,n=0;


{
{
}
}
//Ispis unijete matrice

{
{
}
printf("\n\n");
}
//Niz napravljen od elemenata glavne dijagonale

{
{
if(red==kol)
{
niz_glavna[m]=mat[red][kol];
m++;
}
}
}
//Niz napravljen od elemenata sporedne dijagonale

{
{
if(red+kol==dimenzija-1)
{
niz_sporedna[n]=mat[red][kol];
n++;
}
}
}
//Pronalazenje najmanjeg i najveceg elementa u nizu glavne dijagonale i njihova zamjena sumom elemenata
tog niza
min=niz_glavna[0];
minIndex=0;
max=niz_glavna[0];
maxIndex=0;
for(i=0; i<m; i++)

{
if(niz_glavna[i]>max)
{
max=niz_glavna[i];
maxIndex=i;
}
if(niz_glavna[i]<min)
{
min=niz_glavna[i];
minIndex=i;
}
suma=suma+niz_glavna[i];
}
niz_glavna[minIndex]=suma;
niz_glavna[maxIndex]=suma;
//Pronalazenje najmanjeg i najveceg elementa u nizu sporedne dijagonale i njihova zamjena sumom elemenata
tog niza
min1=niz_sporedna[0];
minIndex1=0;
max1=niz_sporedna[0];
maxIndex1=0;
for(j=0; j<n; j++)

{
if(niz_sporedna[j]>max1)
{
max1=niz_sporedna[i];
maxIndex1=j;
}
if(niz_sporedna[j]<min1)
{
min1=niz_sporedna[j];
minIndex1=j;
}
suma1=suma1+niz_sporedna[j];
}
niz_sporedna[minIndex1]=suma1;
niz_sporedna[maxIndex1]=suma1;
//Upisivanje tranformisanih nizova u matricu
i=0;
{
{
if(red==kol)
{
mat[red][kol]=niz_glavna[i];
i++;
}
}
}
j=0;
{
{
{
mat[red][kol]=niz_sporedna[j];
j++;
}
}
}
printf("Nova matrica je:\n");

{
{
}
printf("\n\n");
}
system("pause");
}
/*********************************************************************************/
/********26.9.2013*********
Napisati program na C-u kojim se unosi matrica M*M
a potom se vrsi njena transformacija tako sto se izvrsi zamjena elemenata unutar dveju vrsta u kojima se
nalaze najmanji i najveci element sporedne dijagonale
matrice.Prikazi na ekran transformisanu matricu
*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,max,min,maxRed=0,minRed=0,pom,dimenzija;
//Unos dimenzije matrice

printf("\n\nUnesite dimenziju matrice:");
//Unos matrice
printf("\n\nUnesite elemente matrice:");
{
{
printf("\n\nMAT[%d][%d]=",red,kol);
}
//Ispis stare matrice

printf("\n\nStara matrica je:\n\n");
{
{
}
printf("\n\n");
}
//Trazenje najmanjeg i najveceg elementa na sporednoj dijaonali i uporedo pamcenje u kojoj

//vrsti se nalaze
max=mat[0][dimenzija-1];
min=mat[0][dimenzija-1];

{
{
{
if(mat[red][kol]<min)
{
min=mat[red][kol];
minRed=red;
}
else if(mat[red][kol]>max)
{
max=mat[red][kol];
maxRed=red;
}
}
}
}
//Zamjena elemenata u vrstama u koima se nalaze min i max sporedne dijagonale

{
pom=mat[minRed][kol];
mat[minRed][kol]=mat[maxRed][kol];
mat[maxRed][kol]=pom;
}

printf("\n\nStara matrica je:\n\n");
{
{
}
printf("\n\n");
}
system("pause");}
/*********************************************************************************/
/********11.10.2013*********
Napisati program na C-u kojim se sa tastature unose dimenzije M
i elementi MAT1m*m i MAT2m*m,a potom se vrsi njihovo sabiranje
tako sto se sabere pri element MAT1 sa posljednjim elementom MAT2,drugi sa pretposljednjim itd.
Sumirane elemente upisati u novu matricu MAT3.Prikazati na ekran obijenu matricu.
*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int MAT1[MAX][MAX],red,kol,i,j,MAT2[MAX][MAX],suma,M,MAT3[MAX][MAX];
printf("\n\nUnesite dimenziju matrica:");

scanf("%d",&M);
//Unos elemenata MAT1

printf("\n\nUnesite elemente MAT1:\n\n");
for(red=0; red<M; red++)
{
for(kol=0; kol<M; kol++)
{
printf("\n\nMAT1[%d][%d]=",red,kol);
scanf("%d",&MAT1[red][kol]);
}
//Ispis MAT1
printf("\n\nMAT1 je:\n\n");
{
{
printf("%d\t",MAT1[red][kol]);
}
printf("\n\n");
}
//Unos elemenata MAT2

printf("\n\nUnesite elemente MAT2:\n\n");
for(i=0; i<M; i++)
{
for(j=0; j<M; j++)
{
printf("\n\nMAT2[%d][%d]=",i,j);
scanf("%d",&MAT2[i][j]);
}
//Ispis matrice 2
printf("\n\MAT2:\n\n");
for(i=0; i<M; i++)
{
for(j=0; j<M; j++)
{
printf("%d\t",MAT2[i][j]);
}
printf("\n\n");
}
//Sada vrsimo sabiranje MAT1 i MAT2 i smjetamo njihovu sumu u MAT3
for(red=0,i=M-1; red<M,i>=0; red++,i--)
{
for(kol=0,j=M-1; kol<M,j>=0; kol++,j--)
{
suma=MAT1[red][kol]+MAT2[i][j];
MAT3[red][kol]=suma;
}
}
//Ispis MAT3
printf("\n\nMatrica MAT3:\n\n");
{
{
printf("%d\t",MAT3[red][kol]);
}
printf("\n\n");
}
system("pause");
}
/*********************************************************************************/
/********12.9.2013*********
Napisati program na C-u kojim se sa tastature unosi matrica An*m,
a potom se vrsi zamjena elemenata unutar dveju kolona sa najmanjom i najvecom vrjednoscu sume
elemenata sa parnim indeksom vrste.Prikazati na ekran
transformisanu matricu
*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,pom,max=0,min=0,maxKol,minKol,suma=0;
printf("\n\nUnesite broj redova matrice:");

scanf("%d",&br_red);
printf("\n\nUnesite broj kolona matrice:");

scanf("%d",&br_kol);
//Unos elemenata matrice

printf("\n\nUnesite elemente matrice:\n\n");
{
{
printf("\n\nMAT[%d][%d]=",red,kol);
}
//Ispis elemenata matrice

printf("\n\nUnijeta matrica je:\n\n");
{
{
}
printf("\n\n");
}
//Pretpostavicemo da je prva kolona ,kolona sa najmanjom tj. najvecom sumom elemenata iz

vrsta sa parnim indexom
{
if(red%2==0)
{
min=min+mat[red][0];
max=max+mat[red][0];
}
}
maxKol=0;
minKol=0;
//Sada trazimo i uporedjujemo min i max

{
{
if(red%2==0)
{
}
}
if(suma>max)
{
max=suma;
maxKol=kol;
}
else if(suma<min)
{
min=suma;
minKol=kol;
}
suma=0;
//Zamjena elemenata kolona sa min i max sumom

{
pom=mat[red][minKol];
mat[red][minKol]=mat[red][maxKol];
mat[red][maxKol]=pom;
}
//Ispis matrice
printf("\n\Matrica nakon transformacije je:\n\n");

{
{
}
printf("\n\n");
}
system("pause");
/*********************************************************************************/
/*10)Napisati program na C-u kojim se matrica ANxN modifikuje tako da elementi iznad glavne dijagonale
u svakoj vrsti budu ciklično pomjereni za k mjesta udesno
(k se unosi sa tastature), i nalazi maksimalni element za elemente ispod glavne dijagonale. */
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,dimenzija,pom,k,p,j;

//Unos elemenata matrice

{
{
}
}

{
{
}
printf("\n\n");
}
printf("\n\nUnesite broj elemenata k:");

scanf("%d",&k);
//Pomijeranje za k mjesta udesno

{
{
if(red<kol)
{
for(p=0; p<k; p++)
{
pom=mat[red][dimenzija-1];
for(j=dimenzija-1; j>kol; j--)

{
mat[red][j]=mat[red][j-1];
}
mat[red][j]=pom;
}
}
}
}
//Ispis nove matrice

{
{
}
printf("\n\n");
}
system("pause");
/***********************************************************************************/
/***********************************************************************************/
/*Sa tastature unijeti dimenziju i elemente kvadratne matrice
zatim pronaci aritmeticku sredinu elemenata na glavnoj dijagonali matrice i potom izvrsiti
promjenu vrijednosti svih elemenata koji se nalaze u vrstama sa parnim indeksom vrste
tako sto se postojeca vrijednost elemenata uveca za vrijednost aritmeticke sredine*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,dimenzija,suma=0,pom,brojac_elemenata=0;
float arS;
printf("Unesite dimenziju kvadratne matrice:");
for(red=0;red<dimenzija;red++)
{
for(kol=0;kol<dimenzija;kol++)
{
printf(" MAT[%d][%d]=",red,kol);
}
}

{
{
}
printf("\n\n");
}
for(red=0; red< dimenzija; red++)

{
for(kol=0;kol< dimenzija; kol++)
{
if(red==kol)
{
brojac_elemenata++;
}
}
}
arS=(float)suma/brojac_elemenata;
printf("Aritmeticka sredina elemenata na glavnoj dijagonali je %.2f\n",arS);
for(kol=0; kol< dimenzija;kol++)

{
{
if(red%2==0)
{ mat[red][kol]=mat[red][kol]+arS;
}
}
}
printf("Nova transformisana matrica je:\n");

{
for(kol=0; kol< dimenzija;kol++)
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/* Napisati program na C-u koji se transformiše matrica A, dimenzija NxM, tako što se vrši ciklicno
pomjeranje elemenata matrice unutar
svake vrste za i mjesta udesno, gdje je i indeks vrste matrice. Štampati transformisanu matricu. */
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,p,pom;
printf("Unesite broj redova matrice:");

printf("\nUnesite broj kolona matrice:");

//Unos matrice
printf("\n_Unesite elemente matrice:");
for( red=0; red<br_red;red++)
{
{
}
}

{
for(kol=0;kol<br_kol;kol++)
{
}
printf("\n\n");
}

{
for(p=0; p<red; p++)
{
pom=mat[red][br_kol-1];
for(kol=br_kol-1; kol>0; kol--)

{
mat[red][kol]=mat[red][kol-1];
}
mat[red][0]=pom;
}
}

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/*Rok 9.septembar 2016. Elemente desno od glavne dijagonale pomjerimo za i+1 mjesta udesno.I je indeks
vrste.Matrica da bude kvadratna*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom,p,j;


{
{
}
}
{
{
}
printf("\n\n");
}

{
for(p=0; p<red+1; p++)
{
pom=mat[red][dimenzija-1];
for(kol=dimenzija-1; kol>red+1; kol--)

{
}
mat[red][red+1]=pom;
}
}

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/*Unijeti elemente matrice A,dimenzije N,
pri tome formirati niz B tako da se prvo popunjava
po sljedecem pravilu:Prvo smjestiti N,zatim elemente
iznad glavne dijagonale,pa onda ispod glavne dijagonale i
na kraju elemente glavne dijagonale*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,B[MAX],k=0;


{
{
}
}

{
{
}
printf("\n\n");
}
//U niz B prvo smo smjestili dimenziju matrice kao prvi element
B[k]=dimenzija;
k++;
//Zatim smjestamo elemente iznad glavne dijagonale

{
{
if(red<kol)
{
B[k]=mat[red][kol];
k++;
}
}
}
//Zatim smjestamo elemente ispod glavne dijagonale

{
{
if(red>kol)
{
B[k]=mat[red][kol];
k++;
}
}
}
//Zatim smjestamo elemente saglavne dijagonale u niz

{
{
if(red==kol)
{
B[k]=mat[red][kol];
k++;
}
}
}
printf("\nNiz B je:");
{
printf("\t%d",B[red]);
}
system("pause");
}
/***********************************************************************************/
/*Zamijena vrsta,prve sa zadnjom,druge sa predzadnjom i takoredom..*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom,i;

printf("\n Unesite elemente matrice:");

{
{
printf("\nMAT[%d][%d]=",red,kol);
}
}

{
{
}
printf("\n\n");
}
//Zamjena prve vrste sa zadnjom,druge sa predzadnjom..
i=dimenzija-1;
for(red=0; red<dimenzija/2; red++)
{
{
pom=mat[red][kol];
mat[red][kol]=mat[i][kol];
mat[i][kol]=pom;
}
i--;
}
printf("Transformisana matrica je:\n");

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/*Zamijena elemenata GLAVNE dijagonale prvi sa zadnjim
,drugi sa predzadnjim i sve tako*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom,j;


{
{
}
}

{
{
}
printf("\n\n");
}
//Zamjena prvog elementa glavne dijagonale sa zadnjim,drugog sa predzadnjim i tako redom
j=dimenzija-1;
{
{
if(red==kol)
{
pom=mat[red][kol];
mat[red][kol]=mat[j][j];
mat[j][j]=pom;
}
}
j--;
}

{
{
}
printf("\n\n");
}
system("pause");
/***********************************************************************************/
/*Zamijena elemenata GLAVNE dijagonale prvi sa zadnjim
,drugi sa predzadnjim i sve tako*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom,j,i;


{
{
}
}

{
{
}
printf("\n\n");
}
//Zamjena prvog elementa glavne dijagonale sa zadnjim,drugog sa predzadnjim i tako redom
for( red=0,i=dimenzija-1; red<dimenzija/2,i>=dimenzija/2; red++,i--)

{
for( kol=0,j=dimenzija-1; kol<dimenzija,j>=0;kol++,j--)
{
if(red==kol && i==j)
{
pom=mat[red][kol];
mat[red][kol]=mat[i][j];
mat[i][j]=pom;
}
}
}

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/*Zamijena elemenata glavne dijagonale sa sporednom dijagonalom*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom,j,i;


{
{
}
}

{
{
}
printf("\n\n");
}
//Mehanizam kojim mijenjamo gornju polovinu matrice
j=dimenzija-1;
{
{
if(red==kol)
{
pom=mat[red][kol];
mat[red][kol]=mat[red][j];
mat[red][j]=pom;
}
}
j--;
}
//Mehanizam kojim mijenjamo donju polovinu matrice

i=0;
for(red=dimenzija-1; red>dimenzija/2; red--)
{
{
if(red==kol)
{
pom=mat[red][kol];
mat[red][kol]=mat[red][i];
mat[red][i]=pom;
}
}
i++;
}

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/*1.Napisati program na C-u kojim se vrši sortiranje elemenata

u svakoj koloni matrice A
čiji je indeks kolone neparan u rastući redosled.
Matrica A ima dimezije MxN.
Elemente matrice A i njene dimenzije uneti sa tastature.
Štampati transformisanu matricu. */
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,pom,i;


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}
//Sortiranje elemenata u rastuci redoslijed

{
{
if(kol%2==0)
{
for(i=red+1; i<br_red; i++)
{
if(mat[i][kol]>mat[red][kol])
{
pom=mat[red][kol];
mat[red][kol]=mat[i][kol];
mat[i][kol]=pom;
}
}
}
}
}
//Transformisana matrica je

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/*Napisati program na C-u kojim se sa tastature unosi matrica MATM*M a potom se vrši njena transformacija
tako što se izvrši
zamena elemenata unutar dveju kolona u kojima se nalaze najmanji i najveći element dijagonale matrice.
Prikazati na ekran transformisanu matricu.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,min,max,minKol,maxKol,pom;
printf("\nUnesite dimenziju kvadratne matrice:");

printf("\nUnesite elemente kvadratne matrice:\n");

{
{
}
}

{
{
}
printf("\n\n");
}
max=mat[0][0];
min=mat[0][0];
maxKol=0;
minKol=0;

{
{
if(red==kol)
{
if(mat[red][kol]>max)
{
max=mat[red][kol];
maxKol=kol;
}
else if(mat[red][kol]<min)
{
min=mat[red][kol];
minKol=kol;
}
}
}
}

{
pom=mat[red][minKol];
mat[red][minKol]=mat[red][maxKol];
}

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/*3)Napisati program na C-u koji vrši rotiranje elemenata matrice A, dimenzija NxM,
po vrstama za jedno mjesto u desno. Pored rotacije elemenata matrice potrebno je izvršiti transfomaciju
matrice tako da prva vrsta
matrice prelazi na mjesto druge, druga na mjesto treće, itd.
Poslednja vrsta matrice, nakon transformacije, se nalazi na mestu prve. Štampati transformisanu matricu.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,pom,temp;


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}
//Pomijeranje elementa u svakoj vrsti za jedno mjesto udesno

{
pom=mat[red][br_kol-1];
for(kol=br_kol-1; kol>0; kol--)

{
}
mat[red][0]=pom;
}

{
{
}
printf("\n\n");
}
//Redanje vrsta kako je zadato u zadatku

{
temp=mat[br_red-1][kol];
for(red=br_red-1; red>0; red--)

{
mat[red][kol]=mat[red-1][kol];
}
mat[0][kol]=temp;
}

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/* Napisati program na C-u kojim se sa tastature unose elementi matrice A, dimenzija NxM, a potom se
formira niz B koji se sastoji od
negativnih elemenata matrice A. Pri formiranju niza B popunjavati ga odgovarajućim vrijednostima matrice A
krenuvši od elementa A[N-1][M-1]
i kretati se kroz vrste. */
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,B[MAX],k=0;


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}
//Kretanje kroz vrste i trazenje neparnih clanova
for(kol=br_kol-1; kol>=0; kol--)

{
for(red=br_red-1; red>=0; red--)
{
if(mat[red][kol]<0)
{
B[k]=mat[red][kol];
k++;
}
}
}
printf("Niz B formiran od elemenata matrice je:\n");

{
printf("\t%d",B[red]);
}
system("pause");
}
/***********************************************************************************/
/* ISPITNI
Unijeti kvadratnu matricu i transformisati je tako da se izvrsi njeno prosirenje

sa dodatnom kolonom i dodatnim redom u kojima ce se nalaziti sume elemenata iz odgovarajuceg reda
odnosno kolone..Npr
za matricu
1 2 3
4 5 6
7 8 9
potrebno je dobiti:
1 2 3 6
4 5 6 15
7 8 9 24
12 15 18 45 */
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,suma1=0,suma2=0;

{
{
}
}

{
{
}
printf("\n\n");
}
dimenzija=dimenzija+1;
for(red=0; red<dimenzija-1; red++)

{
for(kol=0; kol<dimenzija-1; kol++)
{
suma1+=mat[red][kol];
}
mat[red][dimenzija-1]=suma1;
suma1=0;
}
for(kol=0; kol<=dimenzija-1; kol++)

{
for(red=0; red<dimenzija-1; red++)
{
suma2+=mat[red][kol];
}
mat[dimenzija-1][kol]=suma2;
suma2=0;
}

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/*Napisati program na C-u kojim se sa tastature unose elementi celobrojne matrice A, reda M*M, pri čemu je
M paran broj,
a potom se vrši njena transformacija tako što se zamene mesta elementima u dvema susednim kolonama.
Štampati početnu i transformisanu matricu. */
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom;

do{
}while(dimenzija%2!=0);

{
{
}
}

{
{
}
printf("\n\n");
}
for(kol=0; kol<dimenzija; kol=kol+2)

{
{
pom=mat[red][kol];
mat[red][kol]=mat[red][kol+1];
mat[red][kol+1]=pom;
}
}

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************/
/*Napisati program na C-u kojim se sa tastature unose dimenzija M i elementi matrice AM*M.
Izvršiti transformaciju matrice tako da se zamene odgovarajući elementi matrice simetrično u odnosu na
glavnu dijagonalu.
Štampati matricu nakon transfromacije. Nije dozvoljeno koristiti pomoćne strukture podataka. */
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom;


{
{
}
}

{
{
}
printf("\n\n");
}
{
{
if(red>kol)
{
pom=kol;
kol=red;
red=pom;
}
}
}

{
for(red=0;red<dimenzija; red++)
{
}
printf("\n\n");
}
system("pause");
}
/************************************************************************************/
//Napisati program na C-u kojim se sa tastature unosi dimenzija i elementi cjelobrojne kvadratne
matrice.Dimenzija treba da bude paran broj.
//Omoguciti ponovni unos ako ovaj uslov nije ispunjen.Pronaci aritmeticku sredinu elemenata posljednje
vrste matrice
//a zatim u svim kolonama sa neparnim indeksom kolone pronaci elemente koji su manji od nadjene
aritmeticke sredine i izvrsiti
//zamjenu mjesta tih elemenata sa odgovarajucim elementima prethodne susjedne kolone(elementi se nalaze
unutar iste vrste).
//Stampati transformisanu matricu
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,dimenzija,suma=0,pom;
float arS;
printf("Unesite dimenziju kvadratne matrice:");

do
{
}
while(dimenzija%2!=0);
{
{
}
}

{
{
printf("%d",mat[red][kol]);
}
printf("\n");
}
for(kol=0; kol< dimenzija; kol++)

{
suma=suma+mat[dimenzija-1][kol];
arS=(float)suma/dimenzija;
printf("Izracunata aritmeticka sredina elemenata posljednje vrste je: %.2f",arS);

{
for(kol=0; kol< dimenzija; kol++)
{
if(kol%2!=0)
{
if(mat[red][kol]<arS)
{
pom=mat[red][kol];
mat[red][kol-1]=pom;
}
}
}
}
printf("Transformisana matrica je matrica je:\n");

{
{
printf("%d",mat[red][kol]);
}
printf("\n\n");
system("pause");
}
/************************************************************************************/
//1) Napisati program na C-u koji zamenjuje mesta l-toj i s-toj vrsti matrice AMxN.
//Prilikom zamene mesta vrstama sve negativne elemente l-te i s-te vrste matrice zameniti sa 0.
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,pom,l,s;


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}
//Unos l-te i s-te vrste

printf("Unesite l-tu vrstu:");
do
{
scanf("%d",&l);
}while(l<0||l>=br_red);
printf("Unesite s-tu vrstu:");

do
{
scanf("%d",&s);
}while(s<0||s>=br_red);
for( kol=0; kol<br_kol; kol++)

{
if(mat[l][kol]<0)
{
mat[l][kol]=0;
}
else if(mat[s][kol]<0)
{
mat[s][kol]=0;
}
pom=mat[l][kol];
mat[l][kol]=mat[s][kol];
mat[s][kol]=pom;
}
printf("Nova , transformisana matrica je:\n");

{
{
}
printf("\n\n");
}
system("pause");
}
//Ili ovako
//1)Napisati program na C-u koji zamenjuje mesta l-toj i s-toj vrsti matrice AMxN.
//Prilikom zamene mesta vrstama sve negativne elemente l-te i s-te vrste matrice zameniti sa 0.
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,pom,l,s;


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}
printf("\nUnesite l-tu vrstu:");

do{
scanf("%d",&l);
}while(l<0 || l>=br_red);
printf("\nUnesite s-tu vrstu:");

do{
scanf("%d",&s);
}while(s<0 || s>=br_red);

{
if(mat[l][kol]<0)
{
mat[l][kol]=0;
}
if(mat[s][kol]<0)
{
mat[s][kol]=0;
}
pom=mat[l][kol];
mat[l][kol]=mat[s][kol];
mat[s][kol]=pom;
}

{
{
}
printf("\n\n");
}
system("pause");
}
/***********************************************************************************************/
//2) Napisati program na C-u koji vrši sortiranje elemenata na glavnoj dijagonali matrice ANxN u
nerastući redosled,
//a zatim izračunava proizvod elemenata ispod sporedne dijagonale. Štampati transformisanu matricu i
dobijeni proizvod.
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom,proizvod=1,i,j;


{
{
}
}

{
{
}
printf("\n\n");
}
//Potrebno je sada da svrstamo elemente na glavnoj dijagonali u opadajuci redoslijed(nerastuci).To cemo

uraditi
//tako sto cemo uvesti dvije nove petlje i,j..koje ce obje kretati od za jedan vise od prethodnog reda i
kolone.
//Takodje elementi i prve dvije,kao i druge dvije petlje moraju biti na glavnoj dijagonali

{
{
if( red==kol)
{
for(j=kol+1; j<dimenzija; j++)
{
if(mat[j][j]<mat[red][kol])
{
pom=mat[red][kol];
mat[red][kol]=mat[j][j];
mat[j][j]=pom;
}
}
}
}
}
{
{ printf("\t%d",mat[red][kol]);
}
printf("\n\n");
}
//Proizvod ispod sporedne dijalgonale

{
{
if(red+kol>dimenzija-1)
{
proizvod=proizvod*mat[red][kol];
}
}
}
printf("Proizvod elemenata ispod sporedne dijagonale je %d",proizvod);
system("pause");
/*********************************************************************************************/
/*4)Napisati program na C-u koji vrši sortiranje elemenata matrice A, dimenzija NxM u okviru vrsta u
rastući redoslijed.
Matricu A uneti sa tastature. Štampati transformisanu matricu.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,pom,j;


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}
//Sortiranje elemenata u rastuci redoslijed po vrstama

{
{
for(j=kol+1; j<br_kol; j++)
{ if(mat[red][kol]>mat[red][j])
{
pom=mat[red][kol];
mat[red][kol]=mat[red][j];
mat[red][j]=pom;
}
}
}
}

{
{
}
printf("\n\n");
}
system("pause");
}
/************************************************************************************/
/*U prvi red unijeti redne brojeve takmicara a zatim redom u sve kolone unijeti po 6 ocjena za svakog
takmicara.Poredati ih tako da na prvom mjestu bude onaj takmcar sa najvecom sumom ocjena kolone,zatim na
drugom malo gori ,itd..pa najgori na zadnjem mjestu.
Sa tastature unosimo broj takmicara.Ocjene su
u opsegu od 1 do 5*/
#include<stdio.h>
#define MAX 100
#include<stdlib.h>
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,br_takmicara,rbr_takmicara,max=0,suma=0,j,pom,maxKol=0;
printf("\n\nUnesite broj takmicara koji ucestvuju u takmicenju:");

scanf("%d",&br_takmicara);
br_kol=br_takmicara;
//U prvi red unosimo redne brojeve takmicara

{
printf("\n\nUnesite redni broj %d. takmicara:",kol+1);
scanf("%d",&mat[0][kol]);
br_red=7; //Zato sto imamo sest ocjena i plus jos jedan red u kojem su ispisani redni brojevi
takmicara
//Zatim unosimo po sest ocjena za svakog takmicara.Ocjene su u psegu od 1 do 5

{
{
do{
printf("\n\nUnesite %d. ocjenu:",red);
}while(mat[red][kol]<1 || mat[red][kol]>5);
}
}
//Unesena matrica sa rednim brojevima i ocjenama prije sortiranja izgleda ovako:

printf("\n\nPocetna matrica:\n\n");
{
{
}
printf("\n\n");
}
//Sortiranje kolona matrice u rastuci redoslijed

{
for(j=kol+1; j<br_kol; j++)
{
{
max=max+mat[red][kol];
suma=suma+mat[red][j];
}
if(suma>max)
{
maxKol=j;
{
pom=mat[red][kol];
mat[red][kol]=mat[red][maxKol];
}
}
max=0; suma=0;
}
}
printf("\n\Transformisana matrica:\n\n");
{
{
}
printf("\n\n");
}
system("pause");
}
/*****************************************************************************************/
/*4.Napisati program na C-u kojim se sa tastature unose elementi matrice A dimenzije M*M,
pri čemu je svaki element matrice višecifreni celi broj, a potom se od tih elemenata formira celobrojni
niz B čiji je svaki element
jednak proizvodu cifara najveće i najmanje težine odgovarajućeg elementa matrice A. Na ekran štampati
kreirani niz B.
*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],dimenzija,red,kol,lsb,msb,B[MAX],k=0;
float aritS;


{
{
do{
}while(mat[red][kol]<=9);
}
}

{
{
}
printf("\n\n");
}

{
{
lsb=mat[red][kol]%10;
while(mat[red][kol]>=10)
{
mat[red][kol]=mat[red][kol]/10;
}
msb=mat[red][kol];
B[k]=lsb*msb;
k++;
}
}
printf("Niz B je:\n");
for(kol=0; kol<k; kol++)
{
printf("\t%d",B[kol]);
}
system("pause");
}
/**************************************************************************************************/
/*5)Napisati program na C-u koji vrši sortiranje elemenata matrice A, dimenzije NxM,
u okviru kolona u opadajući redoslijed. Štampati transformisanu matricu.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,pom,j;


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}
//Sortiranje elemenata u opadajuci redoslijed po kolonama

{
{
for(j=red+1; j<br_red; j++)
{
if(mat[red][kol]<mat[j][kol])
{
pom=mat[red][kol];
mat[red][kol]=mat[j][kol];
mat[j][kol]=pom;
}
}
}
}

{
{
}
printf("\n\n");
}
system("pause");
}
/*********************************************************************************************/
/*6)Napisati program na C-u koji računa i prikazuje proizvod matrice ANxN i njene transponovane matrice
(AT).
Matricu A inicijalizovati prilikom deklaracije.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,dimenzija,pom,proizvod=1,Transponovana[MAX][MAX],i,suma=0;
int A[MAX][MAX];

//Unos matrice
for( red=0; red<dimenzija;red++)
{
{
}
}

for( red=0; red<dimenzija;red++)
{
{
}
printf("\n\n");
}
//Kreiranje transponovane matrice

{
{
Transponovana[red][kol]=mat[kol][red];
}
}
printf("\n\nTransponovana matrica izgleda ovako:\n\n");

{
{
printf("%d\t",Transponovana[red][kol]);
}
printf("\n\n");
}
//Proizvod unijete matrice i transponovane matrice

{
{
for(i=0; i<dimenzija; i++)
{
suma=suma+(mat[red][i]*Transponovana[i][kol]);
}
A[red][kol]=suma;
suma=0;
}
}
printf("\n\nTransponovana matrica izgleda ovako:\n\n");

{
{
printf("%d\t",A[red][kol]);
}
printf("\n\n");
}
system("pause");
}
/***************************************************************************/
/*7)Napisati program na C-u koji računa vrednost izraza A=BxC+D, gdje su A, B, C i D kvadratne matrice
reda N. Štampati matricu A.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int red,kol,j,pom=0,dimenzija,A[MAX][MAX],B[MAX][MAX],C[MAX][MAX],D[MAX][MAX],k;
printf("Unesite dimenziju matrica:");

printf("\nUnesite elemente matrice B:\n");

{
{
printf("B[%d][%d]=",red,kol);
scanf("%d",&B[red][kol]);
}
}
printf("\nUnesite elemente matrice C:\n");

{
{
printf("C[%d][%d]=",red,kol);
scanf("%d",&C[red][kol]);
}
}
printf("\nUnesite elemente matrice D:\n");

{
{
printf("D[%d][%d]=",red,kol);
scanf("%d",&D[red][kol]);
}
}
{
{
for(k=0; k<dimenzija; k++)
{
pom=pom+(B[red][k]*C[k][kol]);
}
A[red][kol]=pom+D[red][kol];
pom=0;
}
}
printf("Matrica A je:\n");
{
{
printf("\t%d",A[red][kol]);
}
printf("\n\n");
}
system("pause");
}
/**************************************************************************************/
/*9)Napisati program na C-u kojim se određuje i prikazuje kolona matrice ANxM čiji je zbir elemenata
najmanji.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,min=0,suma=0,minKol;


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}
//Pretpostavicemo da je suma elemenata prve kolone najmanja

{
min=min+mat[red][0];
}
minKol=0;

{
{
}
if(suma<min)
{
min=suma;
minKol=kol;
}
suma=0;
}
printf("Kolona sa najmanjim zbirom njenih elemenata je: %d\n",minKol);

printf("Njeni elementi su:\n");
for(red=0; red< br_red; red++)

{
printf("%d",mat[red][minKol]);
printf("\n\n");
}
system("pause");
}
/***************************************************************************************/
/*9)Napisati program na C-u kojim se određuje i prikazuje kolona matrice ANxM čiji je zbir elemenata
najveci.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,pom,suma=0,suma2=0,max,maxKol;


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}

{
{
}
max=suma;
maxKol=0;
}

{
{
suma2=suma2+mat[red][kol];
}
if(suma2>suma)
{
max=suma2;
maxKol=kol;
}
//Ispis elemenata kolone koja imanajveci zbir

{
printf("%d\n",mat[red][maxKol]);
}
system("pause");
/***********************************************************/
/*Napisati program na C-u kojim se sa tastature unose elementi matrice A, dimenzija M*N,
a potom se formira niz B koji se sastoji od elemenata matrice A koji su parni brojevi.
Pri formiranju niza B popunjavati ga
odgovarajucim elementima matrice A krenuvši pri pretraživanju matrice od elementa A[M-1][0] i kretati se
kroz kolone.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,pom,k=0,B[MAX];


//Unos matrice
{
{
}
}

{
{
}
printf("\n\n");
}
for(red=br_red-1; red>=0; red--)

{
{
if(mat[red][kol]%2==0)
{
B[k]=mat[red][kol];
k++;
}
}
}
//Ispis niza
printf("\n\nNiz B:\n\n");

{
printf("%d\t",B[kol]);
}
system("pause");
}
/******************************************************************/
/*Napisati program na programskom jeziku C kojim se formira matrica A(10,10)

tako da u njoj naizmenicno budu slova A i B pocevši od A(0,0)=A.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
main()
{
int red,kol,dimenzija=10;
char n= 'A',m='B';
char mat[MAX][MAX];

{
for(kol=0;kol<dimenzija; kol=kol+2)
{
mat[red][kol]=n;
}

{
for(kol=1;kol<dimenzija;kol= kol+2)
{
mat[red][kol]=m;
}

{
{
printf("%c\t",mat[red][kol]);
}
printf("\n\n");
}
system("pause");
}
/*******************************************************************/
/*Napisati program na C-u kojim se sa tastature unose elementi matrice A, dimenzija M*N, pri cemu su
njeni elementi višecifreni celi brojevi, a potom se formira niz B koji se sastoji od pojedinacnih cifara
elemenata matrice A.
Pri formiranju niza B krenuti sa pretraživanjem matrice A od elementa A[0][N-1] i kretati se kroz vrste.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
#include<string.h>
main()
{
int mat[MAX][MAX],red,kol,br_red,br_kol,B[MAX],k=0,n,ostatak_pri_djeljenju;


//Unos matrice
{
{
do{
}while(mat[red][kol]<=9);
}
}

{
{
}
printf("\n\n");
}
for(kol=br_kol-1; kol>=0; kol--)

{
{
n=mat[red][kol];
while(n>0)
{
ostatak_pri_djeljenju=n%10;
n=n/10;
B[k]=ostatak_pri_djeljenju;
k++;
}
}
}
printf("\n\nNiz B nastao od pojedinacnih cifara matrice:\n\n");

{
printf("%d\t",B[red]);
}
system("pause");
/***************************************************************************/
/*3.Napisati program na C-u kojim se vrši rotiranje elemenata u pojedinim kolonama matrice A,
MxM, za j pozicija na gore, pri cemu je j indeks kolone.
Matricu A i njenu dimenziju uneti sa tastature. Štampati transformisanu matricu.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
#include<string.h>
main()
{
int mat[MAX][MAX],dimenzija,red,kol,pom,p;


{
{
}
}
//Ispis unijete matrice:

{
{
}
printf("\n\n");
}
//Mehanizam kojim vrsimo pomijeranje za j (ja cu j oznaciti sa kol) mjesta prema gore u odnosu na
kolonu u kojoj stojimo

{
for(p=0; p<kol; p++)
{
pom=mat[0][kol];
for(red=0; red<dimenzija;red++)
{
mat[red][kol]=mat[red+1][kol];
}
mat[dimenzija-1][kol]=pom;
}
}
//Ispis transformisane matrice:

{
{
}
printf("\n\n");
}
system("pause");
}
/************************************************************************/
/*Napisati program na C-u kojim se od elemenata celobrojne matrice A, M*M, koji se nalaze iznad glavne
dijagonale formira celobrojni niz B na takav nacin da se u njega upisuju dupli elementi iz matrice A i da
se pri pretraživanju matrice krece od elementa A[0][M-1] i krece se kroz vrste.
Red matrice A i njene elemente uneti sa tastature, a na ekran štampati matricu A i dobijeni niz B.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
#include<string.h>
main()
{
int mat[MAX][MAX],dimenzija,red,kol,B[MAX],k=0,i,j,br_istih=0;


{
{
}
}

{
{
}
printf("\n\n");
}
//Trazimo duple elemente u matrici koji se javljaju vise od jednog puta
for(kol=dimenzija-1; kol>=0; kol--)

{
{
for(j=dimenzija-1; j>=0; j--)
{
for(i=0; i<dimenzija; i++)
{
if(mat[red][kol]==mat[i][j])
{
br_istih++;
}
}
}
if(br_istih>=2)
{
B[k]=mat[red][kol];
k++;
}
br_istih=0;
}
}

{

{
printf("%d\t",B[red]);
}
system("pause");
/******************************************************************/
/*Ucitati matricu i naci u kojem redu je najmanja aritmeticka sredina.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
#include<string.h>
main()
{
int mat[MAX][MAX],dimenzija,red,kol,suma=0,minarSred=0;
float minarS,arS;


{
{
}
}

{
{
}
printf("\n\n");
}
//Prertpostavicemo da je najamanja minarS u prvom redu

{
suma=suma+mat[0][kol];
}
minarS=(float)suma/dimenzija;
minarSred=0; //Pretpostavka da je prvi red,red sa najmanjom aritmetickom sr.
suma=0;

{
{
}
if(arS<minarS)
{
minarS=arS;
minarSred=red;
}
suma=0;
}
printf("\n\nRed sa najmanjom aritmetickom sredinom je %d. red,a njegova aritmeticka sredina je

%.2f.",minarSred,minarS);
system("pause");
/***********************************************************************/
/*Napisati program na C-u kojim se sa tastature unose elementi matrice A, dimenzija N*N, a
potom se formira niz D koji se sastoji od elemenata matrice A koji su manji od vrednosti
aritmeticke sredine svih elemenata kolone kojoj pripadaju. Pri formiranju niza D popunjavati ga
odgovarajucim elementima matrice A krenuvši pri pretraživanju matrice A od elementa
A[N-1][0] i kretati se kroz kolone.*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
#include<string.h>
main()
{
int mat[MAX][MAX],dimenzija,red,kol,i,D[MAX],k=0,suma=0;
float arS;


{
{
}
}

{
{
}
printf("\n\n");
}
for(red=dimenzija-1; red>=0; red--)

{
{
for(i=dimenzija-1; i>=0; i--)
{
suma=suma+mat[i][kol];
}
if(mat[red][kol]<arS)
{
D[k]=mat[red][kol];
k++;
}
suma=0;
}
}
printf("\n\nNiz D:\n\n");
{
printf("%d\t",D[kol]);
}
system("pause");
}
/***********************************************************/

MATRICE

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

MATRICE

Uploaded by

Copyright:

Available Formats

/*Pojedine cifre brojeva popunjavaju matricu po redovima(ostatak se popunjavam nulama).

printf("\nUnesite elemente niza:\n");

printf("\Unijeli ste niz:");

//Odredjivanje dimenzija matrice

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

/*Zamjena mijesta prve i zadnje kolone, druge i predzadnje, itd..*/

printf("Unesite dimenziju matrice:");

printf("Stara matrica je:\n");

printf("\nNova matrica je:\n");

//Potrebno je da unosimo visecifrene brojeve i da prekinemo unos kada unesemo 0.

printf("\n\nNiz ispravno unesenih brojeva je:\n\n");

printf("\n\nMaksimalan broj cifara je %d.",max);

for(p=0; p<pom; p++)

//U ovom slucaju radi ali ne stampa prvu cifru na 0,0

/*Zamjena mijesta prve i zadnje kolone, druge i predzadnje, itd..*/

printf("Unesite dimenziju matrice:");

printf("\nUnesite elemente matrice:");

printf("Stara matrica je:\n");

printf("\nNova matrica je:\n");

/*7) Popunjavanje mijesta ispod glavne dijagonale elementima niza*/

printf("Unesite dimenziju matrice:");

printf("\nUnesite elemente matrice:");

printf("Stara matrica je:\n");

for(red=0; red<dimenzija; red++)

printf("\nUnesite elemente niza:");

//Popunjavanje matrice ispod glavne dijagonale elementima niza

//Ispis transformisane matrice

/* Zamjena najveceg i najmanjeg elementa pojedinih redova sa vrijednoscu sume elemenata

printf("Unesite dimenziju matrice:");

printf("\nUnesite elemente matrice:");

printf("Stara matrica je:\n");

for(red=0; red<dimenzija; red++)

for(kol=0; kol<dimenzija; kol++)

//Ispis transformisane matrice

printf("Unesite dimenziju matrice:");

printf("\nUnesite elemente matrice:");

//Ispis unijete matrice

//Niz napravljen od elemenata glavne dijagonale

for( red=0; red<dimenzija; red++)

//Niz napravljen od elemenata sporedne dijagonale

for( red=0; red<dimenzija; red++)

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

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

//Upisivanje tranformisanih nizova u matricu

//Ispis transformisane matrice

printf("Nova matrica je:\n");

//Unos dimenzije matrice

//Ispis stare matrice

//Trazenje najmanjeg i najveceg elementa na sporednoj dijaonali i uporedo pamcenje u kojoj

for(red=0; red<dimenzija; red++)

//Zamjena elemenata u vrstama u koima se nalaze min i max sporedne dijagonale

for(kol=0; kol<dimenzija; kol++)

//Ispis transformisane matrice

printf("\n\nUnesite dimenziju matrica:");

//Unos elemenata MAT1

//Unos elemenata MAT2

printf("\n\nUnesite broj redova matrice:");

printf("\n\nUnesite broj kolona matrice:");

//Unos elemenata matrice

//Ispis elemenata matrice

//Pretpostavicemo da je prva kolona ,kolona sa najmanjom tj. najvecom sumom elemenata iz

//Sada trazimo i uporedjujemo min i max

for(kol=1; kol<br_kol; kol++)

/Zamjena mijesta prve i zadnje kolone, druge i predzadnje, itd../

/Zamjena mijesta prve i zadnje kolone, druge i predzadnje, itd../

/7) Popunjavanje mijesta ispod glavne dijagonale elementima niza/

/Zamijena vrsta,prve sa zadnjom,druge sa predzadnjom i takoredom../