Pagina informaticii

Teste de informatică pentru liceu, articole C#, C/C++, PHP

Lecţia 3 - Tablouri bidimensionale (matrice)

În CSharp pot fi două tipuri de matrice: A. regulate (dreptunghiulare) şi B. neregulate (jagged).

A. Matricele regulate sunt matricele care au acelaşi număr de componente pe fiecare linie. De aceea le numim şi dreptunghiulare. Dacă numărul de linii este egal cu numărul de coloane, atunci matricea este pătratică şi putem vorbi de diagonalele principală şi secundară.

P01. Să se declare o matrice de constante cu 3 linii şi 4 coloane şi să se afişeze apoi la ecran.

int[,] a = { { 1, 1, 1, 1 }, { 2, 2, 2, 2 }, { 3, 3, 3, 3 } };
//sau, la fel de corect,
//int[,] a = new int[3, 4] { { 1, 1, 1, 1 }, { 2, 2, 2, 2 }, { 3, 3, 3, 3 } };
int i, j;
for (i = 0; i < 3; i++)
{
	for (j = 0; j < 4; j++)
		Console.Write("{0} ", a[i, j]);
	Console.WriteLine();
}

De remarcat în programul de mai sus modul în care se declară o matrice dreptunghiulară, în care cele două dimensiuni sunt separate prin virgulă.

P02. Să se genereze o matrice cu L linii şi C coloane ce memorează numere naturale aleatoare mai mici decât 100. Să se afişeze matricea. Să se interschimbe apoi coloanele 1 şi 3. Să se afişeze din nou matricea.

Să menţionăm faptul că elementele coloanei 1 sunt de forma a[i,1], unde i=0..L-1. Deci linia 1 are componentele: a[0,1] a[1,1] a[2,1] ... a[L-1, 1]. Programul este următorul:

 
static void Main(string[] args)
{
	int[,] a;
	int L, C, i, j;

	Console.Write("Numarul de linii ale matricei : ");
	L = int.Parse(Console.ReadLine());
	Console.Write("Numarul de coloane ale matricei : ");
	C = int.Parse(Console.ReadLine());
	a = new int[L, C];

	// generarea valorilor din matrice:
	Random R = new Random();
	for (i = 0; i < L; i++)
		for (j = 0; j < C; j++)
			a[i, j] = R.Next(0, 100);

	// afisarea matricei:
	Console.WriteLine("\n\nMatricea generata este:");
	for (i = 0; i < L; i++)
	{
		for (j = 0; j < C; j++)
			Console.Write(a[i, j] + " ");
		Console.WriteLine();
	}

	// interschimbarea coloanelor 1 si 3
	for (i = 0; i < L; i++)
	{
		int aux = a[i, 1];
		a[i, 1] = a[i, 3];
		a[i, 3] = aux;
	}

	Console.WriteLine("\n\nMatricea dupa interschimbare este:");
	for (i = 0; i < L; i++)
	{
		for (j = 0; j < C; j++)
			Console.Write(a[i, j] + " ");
		Console.WriteLine();
	}
}

P03. Se citeşte o matrice pătratică având n linii şi n coloane. Să se verifice dacă aceasta poate fi matricea de adiacenţă asociată unui graf neorientat.

Pentru rezolvare va trebui să verificăm dacă:

  1. toate valorile din matrice sunt doar numerele 0 şi 1 (matricea este binară)
  2. pe diagonala principală sunt doar valori de 0
  3. matricea este simetrică, adică a[i, j] = a[j, i]

Programul este următorul:

static void Main(string[] args)
{
	int[,] a;
	int n, i, j;

	Console.Write("n = ");
	n = int.Parse(Console.ReadLine());
	a = new int[n, n];

	// citirea valorilor din matrice:
	for (i = 0; i < n; i++)
		for (j = 0; j < n; j++)
		{
			Console.Write("a[{0},{1}] = ", i, j);
			a[i, j] = int.Parse(Console.ReadLine());
		}

	// afisarea matricei:
	Console.WriteLine("\n\nMatricea citita este:");
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
			Console.Write(a[i, j] + " ");
		Console.WriteLine();
	}

	// verific daca este matrice de adiacenta:
	for (i = 0; i < n; i++)
		for (j = 0; j < n; j++)
		{
			if (a[i, j] < 0 || a[i, j] > 1)
			{
				Console.WriteLine("Matricea nu este binara");
				return;
			}
			if (a[i, j] != a[j, i])
			{
				Console.WriteLine("Matricea nu este simetrica");
				return;
			}
		}
	for (i = 0; i < n; i++)
		if (a[i, i] != 0)
		{
			Console.WriteLine("Matricea nu are doar valori 0 pe diagonala principala");
			return;
		}
		Console.WriteLine("Este matrice de adiacenta");
}

B. Matricele neregulate (jagged) sunt matricele în care fiecare linie este privită ca un vector ce trebuie iniţializat separat. Astfel este posibil ca două linii să nu aibă aceeaşi lungime. Aceste matrice sunt utile de exemplu pentru memorarea eficientă a listelor de adiacenţă asociate grafurilor, astfel că o linie i va reţine adiacenţii vârfului i din graf.

P04. Să se creeze o matrice neregulată cu 3 linii, linia 0 având 3 elemente, linia 2 având 5 elemente, iar ultima linie 4 elemente.

De remarcat în programul de mai jos modul în care trebuie iniţializată mai întâi matricea, apoi fiecare linie în parte.

static void Main(string[] args)
{
	int i,j;
	int[][] a;

	a = new int[3][] 
	{ 
		new int[]{ 1, 1, 1 }, // initializare prima linie 
		new int[]{ 2, 2, 2, 2, 2 }, // initializare a doua linie 
		new int[]{ 3, 3, 3, 3 } // initializare a treia linie
	};

	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < a[i].Length; j++)
			Console.Write(a[i][j] + " ");
		Console.WriteLine();
	}
}

Observaţi modul de acces la elementul de pe linia i şi coloana j prin expresia a[i][j], la fel ca în C++. Fiecare a[i] este un tablou unidimensional, deci putem afla lungimea sa prin utilizarea proprietăţii Length a unui vector.

P05. La problema anterioară, parcurgeţi elementele matricei neregulate utilizând instrucţiunea foreach.

foreach (int[] v in a)
{
	foreach (int elem in v)
		Console.Write(elem + " ");
	Console.WriteLine();
}

Fiecare matricea este parcursă linie cu linie. O linie este deci un obiect de tip int[] (aşa cum observăm în prima instrucţiune foreach). Cu al doilea foreach parcurgem o linie a matricei, deci un element al său este un obiect de tip int.

P06. Se citeşte un număr natural n > 1. Să se genereze aleator un vector t cu n componente numere naturale. Se va genera apoi aleator o matrice neregulată a, în care linia a[i] din matrice va avea lungimea t[i].

static void Main(string[] args)
{
	int i,j, n;
	int[][] a;
	int[] t;

	Console.Write(" n = ");
	n = int.Parse(Console.ReadLine());

	// initializare si generare vector t:
	t = new int[n];
	Random r = new Random();
	for (i = 0; i < n; i++)
		t[i] = r.Next(1, 10);

	//initializare si generare matrice
	a = new int[n][];
	for (i = 0; i < n; i++)
	{
		// t[i] = dimensiunea liniei i din matrice
		a[i] = new int[t[i]]; 
		for (j = 0; j < t[i]; j++)
			a[i][j] = r.Next(0, 30);
	}

	// afisare matrice
	foreach (int[] v in a)
	{
		foreach (int elem in v)
			Console.Write(elem + " ");
		Console.WriteLine();
	}
}

În finalul acestei lecţii, vă propun spre rezolvare câteva probleme cu matrice:

P07. Să se genereze o matrice regulată cu L linii şi C coloane, în care a[i, j] = max{i, j}. Să se afişeze matricea. Să se creeze apoi matricea transpusă (adică liniile se transformă în coloane şi coloanele în linii, deci matricea va avea C linii şi L coloane)

P08. Se consideră o matrice binară care este matricea de adiacenţă asociată unui graf. Să se construiască listele de adiacenţă asociate grafului, care se vor memora într-o matrice neregulată.

P09. Generaţi aleator o matrice pătratică având n linii şi n coloane. Să se calculeze suma valorilor de deasupra diagonalei principale din această matrice.

Despre autor
Author

Dan Pracsiu deţinător www.dponline.ro
Profesor, Liceul Teoretic "Emil Racoviță" Vaslui
Membru în Comisia Naţională a Olimpiadelor de Informatică
Pasiuni: istoria, călătoriile, fotografia, muzica clasică

Comentarii (1)
Scrie un comentariu
Nume:

Comentariu:

15 + 10 =