Fundamentele programării (XV) - Scala

de Claudiu Soroiu · 5 septembrie 2015

Elementele unui șir pot avea orice tip; nu ne împiedică nimic să facem în așa fel ca aceste elemente să fie, la rândul lor, șiruri.

Pentru un șir de numere întregi, tipul elementelor este Int, iar tipul șirului este Array[Int]. Dar, dacă tipul elementelor ar fi Array[Int], atunci tipul șirului ar fi: Array[Array[Int]]. Declarația ar putea arăta astfel:

var a:Array[Array[Int]]

1	var a:Array[Array[Int]]

Pentru a da o valoare șirului de șiruri, ar trebui să folosim new , apoi tipul șirului ( Array[Array[Int]]), iar apoi numărul elementelor între paranteze drepte. De exemplu, dacă am vrea să avem un șir format din 10 șiruri vom scrie:

var a = new Array[Array[Int]](10)

1	var a = new Array[Array[Int]](10)

Pentru a accesa primul șir din șirul nostru de șiruri am scrie a(0); a(0) este un șir. Nu este greu să ne dăm seama că pentru a accesa primul element al șirului a(0) va trebui să scriem a(0)(0).

Dar, a(0) nu conține deocamdată nimic. Să presupunem că el ar trebui să fie un șir format din 10 numere întregi. Pentru a crea acest șir, va trebui să scriem:

a[0] = new Array[Int](10)

1	a[0] = new Array[Int](10)

De-abia acum putem lucra cu elemente de genul a(0)(0).

Matrice

Cel mai simplu șir de șiruri este matricea. Aceasta poate fi privită ca fiind o grilă cu un anumit număr de linii și un anumit număr de coloane.

Fiecare linie este un șir (cu un număr de elemente egal cu numărul coloanelor), iar matricea este un șir de linii. Un exemplu este:

1  2  3  4
5  6  7  8
9 10 11 12

1 2 3 4

5 6 7 8

9 10 11 12

Avem o matrice cu trei linii și patru coloane; dacă dorim să creăm matricea element cu element, am putea scrie următorul cod:

var matrice = new Array[Array[Int]](3)
matrice(0) = new Array[Int](4)
matrice(1) = new Array[Int](4)
matrice(2) = new Array[Int](4)
matrice(0)(0) = 1
matrice(0)(1) = 2
matrice(0)(2) = 3
matrice(0)(3) = 4
matrice(1)(0) = 5
matrice(1)(1) = 6
matrice(1)(2) = 7
matrice(1)(3) = 8
matrice(2)(0) = 9
matrice(2)(1) = 10
matrice(2)(2) = 11
matrice(2)(3) = 12

var matrice = new Array[Array[Int]](3)

matrice(0) = new Array[Int](4)

matrice(1) = new Array[Int](4)

matrice(2) = new Array[Int](4)

matrice(0)(0) = 1

matrice(0)(1) = 2

matrice(0)(2) = 3

matrice(0)(3) = 4

matrice(1)(0) = 5

matrice(1)(1) = 6

matrice(1)(2) = 7

matrice(1)(3) = 8

matrice(2)(0) = 9

matrice(2)(1) = 10

matrice(2)(2) = 11

matrice(2)(3) = 12

Dar, am văzut că pentru un șir avem la dispoziție o prescurtare. Am putea rescrie codul astfel:

var matrice = new Array[Array[Int]](3)
matrice(0) = Array[Int](1, 2, 3, 4)
matrice(1) = Array[Int](5, 6, 7, 8)
matrice(2) = Array[Int](9, 10, 11, 12)

var matrice = new Array[Array[Int]](3)

matrice(0) = Array[Int](1, 2, 3, 4)

matrice(1) = Array[Int](5, 6, 7, 8)

matrice(2) = Array[Int](9, 10, 11, 12)

De fapt, matricea e tot un șir (format din șiruri). Oare nu se poate și altfel? Ce-ați zice de varianta următoare?

var matrice = Array[Array[Int]](
  Array[Int](1, 2, 3, 4),
  Array[Int](5, 6, 7, 8),
  Array[Int](9, 10, 11, 12))

var matrice = Array[Array[Int]](

Array[Int](1, 2, 3, 4),

Array[Int](5, 6, 7, 8),

Array[Int](9, 10, 11, 12))

Am definit un șir format din trei elemente. Primul element este șirul Array[Int](1, 2, 3, 4), al doilea este șirul Array[Int](5, 6, 7, 8), iar al treilea este șirul Array[Int](9, 10, 11, 12).

Parcurgerea matricelor

Putem parcurge matricele aproape la fel cum parcurgem șirurile. Le traversăm linie cu linie și apoi, dacă dorim, putem traversa fiecare linie. Este suficient să avem două bucle imbricate. Următoarea secvență afișează elementele, câte unul pe o linie. Nu va arăta ca o matrice, dar acest aspect nu este important.

for (i <- 0 until matrice.size) {
  for (j <- 0 until matrice(i).size) {
    println(matrice(i)(j))
  }
}

for (i <- 0 until matrice.size) {

for (j <- 0 until matrice(i).size) {

println(matrice(i)(j))

}

Putem încerca și folosind varianta for pentru șiruri:

for (linie <- matrice) {
  for (valoare <- linie) {
    println(valoare)
  }
}

for (linie <- matrice) {

for (valoare <- linie) {

println(valoare)

}

O simplificare pentru matrice

De cele mai multe ori șirurile de șiruri sunt matrice. Deși există situații în care șirurile individuale ar putea avea dimensiuni diferite, acestea sunt cazuri izolate. De obicei, șirurile au același număr de elemente și avem de-a face cu o matrice.

Când definim o matrice spunem că ea are m linii și n coloane; noi am precizat că matricea are m linii și apoi, pentru fiecare linie în parte, am spus că aceasta are n coloane. Dacă dorim să creăm matrice, limbajul Scala ne oferă o construcție mai simplă; putem preciza direct numărul liniilor și al coloanelor. De exemplu, pentru a crea o matrice cu trei linii și patru coloane putem scrie:

var matrice = Array.ofDim[Int](3, 4)

1	var matrice = Array.ofDim[Int](3, 4)

A fost creată matricea (echivalent cu var matrice = new Array[Array[Int]](3)) și au fost create liniile individuale (echivalent cu matrice(0) = new Array[Int](4); matrice(1) = new Array[Int](4); matrice(2) = new Array[Int](4)).

Observăm că prima dată este precizat numărul liniilor și apoi cel al coloanelor.

Tabla înmulțirii

În episodul X am văzut cum putem afișa tabla înmulțirii. Dar, este mai natural ca o astfel de tablă să fie păstrată într-o matrice. Am putea crea destul de simplu o astfel de matrice astfel:

var tablaInmultirii = Array.ofDim[Int](10, 10)
for (i <- 0 until 10) {
  for (j <- 0 until 10) {
    tablaInmultirii(i)(j) = (i + 1) * (j + 1)
  }
}

var tablaInmultirii = Array.ofDim[Int](10, 10)

for (i <- 0 until 10) {

for (j <- 0 until 10) {

tablaInmultirii(i)(j) = (i + 1) * (j + 1)

}

Avem (i + 1) * (j + 1)și nu i * j deoarece în șiruri (deci și în matrice) numerotarea începe de la 0, nu de la 1, iar în tabla înmulțirii avem nevoie de numerele de la 1 la 10, nu de la 0 la 9.

Putem scrie acum și o versiune mai simplă a afișării tablei:

for (i <- 0 until 10) {
  for (j <- 0 until 10) {
    print("\t" + tablaInmultirii(i)(j))
  }
  println()
}

for (i <- 0 until 10) {

for (j <- 0 until 10) {

print("\t" + tablaInmultirii(i)(j))

}

println()

}

Va urma

Șirurile sunt foarte utile, dar utilizarea lor incorectă poate duce la greșeli relativ greu de detectat. În următorul episod vom prezenta câteva "capcane" care ar trebui evitate.