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 [Int]. Dar, dacă tipul elementelor ar fi [Int], atunci tipul șirului ar trebui obținut prin adăugarea unei perechi de paranteze drepte: [[Int]]. Declarația ar arăta astfel:
|
1 |
var a:[[Int]] |
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].
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 |
1 2 3 4 5 6 7 8 9 10 11 12 |
Avem o matrice cu trei linii și patru coloane; de fapt, matricea e tot un șir (format din șiruri). Deci vom avea elemente care sunt șiruri, separate între ele prin virgule:
|
1 |
var matrice:[[Int]] = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12] ] |
Am definit un șir format din trei elemente. Primul element este șirul [1, 2, 3, 4], al doilea este șirul [5, 6, 7, 8], iar al treilea este șirul [9, 10, 11, 12].
Tipul poate fi determinat automat, deci am putea scrie și:
|
1 |
var matrice = [ [1, 2, 3, 4], [5, 6, 7, 8], [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.
|
1 2 3 4 5 |
for var i = 0; i < matrice.count; i++ { for var j = 0; j < matrice[i].count; j++ { println(matrice[i][j]) } } |
Putem încerca și folosind varianta for each:
|
1 2 3 4 5 |
for linie in matrice { for valoare in linie { println(valoare); } } |
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.
În Swift avem posibilitatea de a crea un array cu un anumit număr de elemente specificând numărul elementelor și o valoare inițială pentru toate aceste elemente. De exemplu, un șir care să conțină zece zerouri ar putea fi creat astfel:
|
1 |
var sir = [Int](count: 10, repeatedValue: 0) |
Construcția este oarecum complicată; nu vom explica acum de ce se face în acest mod. Putem accepta că aceasta este modalitatea cerută de limbajul Swift.
Avem nevoie de zece astfel de șiruri:
|
1 |
var tablaInmultirii = [[Int]](count:10, repeatedValue:[Int](count:10, repeatedValue:0)) |
Valoarea care repetată este de zece ori este acum un șir format din zece elemente. Avem deocamdată zerouri; putem obține valorile corecte astfel:
|
1 2 3 4 5 |
for var i = 0; i < 10; i++ { for var j = 0; j < 10; j++ { 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:
|
1 2 3 4 5 6 7 |
for var i = 0; i < 10; i++ { for var j = 0; j < 10; j++ { print("\t") print(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.
