Prijavi problem


Obeleži sve katergorije koje odgovaraju problemu

Jos detalja - opišite nam problem


Uspešno ste prijavili problem!
Status problema i sve dodatne informacije možete pratiti klikom na link
Na žalost nismo trenutno u mogućnosti da obradimo Vaš zahtev.
Molimo Vas da pokušate kasnije.

Priručnik za C#

Definicija matrice

Nizovi, sa kojima smo se upoznali u jednoj od prethodnih lekcija, omogućavaju nam da rešimo veliki broj problema tako što ćemo pomoću njih da predstavimo podatke koje program treba da obradi. Međutim, postoje situacije gde nam nizovi, u obliku u kojem smo ih videli, nisu dovoljni. Analizirajmo, na primer, digitalnu sliku. Slika se sastoji od piksela koji su raspoređeni po redovima. Svaki red se sastoji od niza piksela. Ovakva struktura podataka se naziva matrica.

Vidimo da matrica može da se posmatra i kao niz nizova: imamo niz redova, a svaki red je niz elemenata. Matrica može da se posmatra i kao dvodimenzioni niz. Pozicija svakog elementa u matrici je definisana sa dva broja, tj. dve dimenzije - u kojem redu, i u kojoj koloni se element nalazi. Za red u matrici može da se kaže i da je vrsta.

Matrica se definiše slično kao što se definiše niz. Tako, ako recimo hoćemo da definišemo matricu, koja ima 50 vrsta i 100 kolona, a elementi su celobrojne promenljive, to bismo uradili sledećom komandom:

int[,] brojevi = new int[50,100];

Ova komanda definiše u memoriji matricu od 5000 promenljivih pod nazivom "brojevi". Vrste ove matrice su numerisane od 0 do 49, a kolone su numerisane od 0 do 99.

Jednom elementnu matrice pristupamo tako što u uglastim zagradama, nakon naziva matrice navedemo broj vrste, a posle zareza i broj kolone u kojoj se taj element nalazi. Kada pristupimo elementu matrice, možemo sa njim raditi sve što možemo i sa običnom promenljivom: koristiti ga u računici, postavljati mu vrednost, itd.

Digitalna slika koju smo prikazali može da se predstavi pomoću celobrojne matrice tako što će broj 1 da označava crno, a broj 0 belo polje, na sledeći način:

int[,] slika = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    { 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0},
    { 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0},
    { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0},
    { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0},
    { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};

U ovom slučaju smo memoriju za matricu odvojili istovremeno sa popunjavanjem vrednosti. Dimenzije kreirane matrice odgovaraju broju elemenata koje smo uneli, tako da će ova matrica imati 10 vrsta i 15 kolona. Pogledajmo kako bi onda izgledali indeksi pojedinih elemenata matrice na slici.

Primer

Uradimo još jedan primer da bi se uhodali u radu sa matricama. Ocene učenika se u školskom dnevniku beleže u jednoj matrici čije vrste odgovaraju učenicima, a kolone školskim predmetima.

Iako se u dnevniku čuva puno ocena, za ovaj primer ćemo da se ograničimo samo na matricu koja nam čuva zaključene ocene učenika na kraju školske godine, pa je ocene[v,k] ocena učenika koji je u dnevniku u redu sa brojem (v+1), iz predmeta koji je po redu na mestu (k+1). To je zapravo ocena koja se nalazi u vrsti v i koloni k. Indeksi vrsta i kolona idu od 0, ali je nama prirodnije da pričamo o prvom učeniku, a ne da učenike pobrajamo od nultog. Tako da će u matrici vrsta v=0 sadržati ocene prvog učenika, vrsta v=1 ocene drugog učenika, v=2 ocene trećeg učenika i tako redom. Broj učenika odgovara broju vrsta n, a broj predmeta broju kolona m.

Uzimajući u obzir samo jedan mali deo dnevnika prikazan na prethodnoj slici vezan za ocene dva učenika iz tri predmeta, matrica ocena bi izgledala ovako:

int[,] ocene = { { 4, 5, 5},
    { 5, 5, 3}
};
int n = 2, m = 3;

Prosečna ocena celog odeljenja se dobija tako što se saberu sve ocene i podele sa ukupnim brojem ocena. Sledećim naredbama možemo da prođemo kroz celu matricu. Spoljašnjom naredbom ponavljanja prolazimo kroz matricu vrstu po vrstu. Unutrašnjom naredbom ponavljanja prolazimo kroz sve elemente jedne vrste koji se nalaze u različitim kolonama.

double prosek = 0;
for (int v = 0; v < n; v++)
{
    for (int k = 0; k < m; k++)
    {
        prosek += ocene[v, k];
    }
}
prosek /= (n * m);
Console.WriteLine(prosek);

Obratite pažnju na to da smo koristili promenljivu v za indeks vrste, a promenljivu k za indeks kolone. U sledećim primerima će biti prikazan način na koji vršimo neka izdračunavanja po vrstama i način na koji to radimo po kolonama. Preporuka je da se promenljiva v uvek koristi za indeks vrste, a k za indeks kolone, bez obzira da li se ista koristi u spoljnoj ili unutrašnjoj naredbi ponavljanja.

Sledećim naredbama računamo prosek svakog učenika, pa nam spoljašnja naredba ponavljanja služi da obradimo jednu po jednu vrstu, tj. jednog po jednog učenika.

for (int v = 0; v < n; v++)
{
    double prosekUcenika = 0;
    for (int k = 0; k < m; k++)
    {
        prosekUcenika += ocene[v, k];
    }
    prosekUcenika /= m;
    Console.WriteLine("Prosek " + (v + 1) + ". ucenika: " + prosekUcenika);
}

Ukoliko želimo da prebrojimo različite ocene za svaki predmet, tj. da vidimo za svaki predmet koliko ima jedinica, dvojki, trojki, četvorki i petica, onda će nam spoljašnja naredba ponavljanja služiti da obradimo jednu po jednu kolonu.

for (int k = 0; k < m; k++)
{
    int[] brOcena = new int[5];
    for (int v = 0; v < n; v++)
    {
        brOcena[ocene[v, k] - 1]++;
    }
    Console.WriteLine("Pregled ocena " + (k + 1) + ". predmeta");
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine("Ocena " + (i + 1) + " - " + brOcena[i] + " ucenika");
    }
    Console.WriteLine();
}

Učitavanje elemenata matrice

Možemo da napišemo i koristimo funkciju za učitavanje elemenata matrice sa standardnog ulaza:

// ucitava matricu dimenzija nXm sa standardnog ulaza 
// - ucitavaju se prvo dimenzije, a zatim i elementi matrice
static void ucitaj(out int[,] A, out int n, out int m)
{
    string[] str = Console.ReadLine().Split();
    n = int.Parse(str[0]);
    m = int.Parse(str[1]);
    A = new int[n, m];
    for (int v = 0; v < n; v++)
    {
        str = Console.ReadLine().Split();
        for (int k = 0; k < m; k++)
            A[v, k] = int.Parse(str[k]);
    }
}