Matricë- në - një analog i një grupi dydimensional - një tabelë katrore ose drejtkëndore e përbërë nga rreshta dhe kolona:

Madhësia e grupit dy-dimensional- numri i elementeve në grupin M*N,

ku M është numri i rreshtave, N është numri i kolonave (numrat natyrorë).

Matrica katrore– një matricë me numër të barabartë rreshtash dhe kolonash.

Rendi i matricës - numri i rreshtave (kolonave) të një matrice katrore.

1. Përshkrimi i një grupi dydimensional

Një grup dydimensional është një grup vargjesh, pra një tabelë dydimensionale. Mund të operoni si me elementë individualë të një grupi ashtu edhe me grupin në tërësi.

Në Pascal, indekset janë të mbyllura në kllapa katrore:

A, A,..A.

Ka 2 mënyra për të përshkruar një grup 2-dimensional:

1 Përshkrimi i grupit në seksionin e variablaveVAR:

istart..ikona, jstart..jcon– vargjet e indeksit (rreshta, kolona);

t – lloji i elementit.

Për shembull:

VAR y: i numrit të plotë;

VAR F: grup i grupit real;

VAR mb: grup real ;

VAR C: vargu i vargut;

KONSTI M= 4; N=2;

VAR A: grupi i numrit të plotë;

2 Përshkrimi i grupit në seksionin e përshkrimit të tipitLLOJI:

Për të mbushur matricën organizohet një cikël i jashtëm sipas i, e brendshme – nga j(me kusht që i janë rreshta, j janë kolona). Në këtë rast, indeksi i rreshtit i ndryshon më ngadalë se indeksi i kolonës j për faktin se ka një numërim gradual të të gjithë elementëve të rreshtit, d.m.th., kolonave të rreshtit të i-të.

Plotësimi sipas kolonave:

A A
A
A
A

Ushtrime për plotësimin e vargjeve 2-dimensionale

Ushtrimi mas1: Plotësoni matricën A(5, 10) rresht pas rreshti duke përdorur metodën e gjenerimit të numrave të rastësishëm.

programi mas_1; (duke mbushur matricën rresht pas rreshti)

A: grup i INTEGER;

writeLn('Matrica A:');

PËR i:= 1 deri në 5 BËJ(laku i jashtëm sipas rreshtave)

PËR j:=1 NË 10 BËJ(laku i brendshëm nëpër kolona)

A:= e rastësishme (10);

shkruani (A: 3); (printoni të gjithë rreshtin me radhë)

shkruajLn; (shkoni në linjën e re)

Ushtrimi mas2: Plotësoni matricën A(3, 4) kolonë për kolonë duke futur numra nga tastiera.

program mas_2; (plotësimi i matricës me kolona)

Const N =4; M = 3;

Var A: grup i INTEGER;

PËR j:= 1 deri në M DO(lak i jashtëm në kolona)

PËR i:=1 TË N BËJ(laku i brendshëm nëpër rreshta)

write('Fut elementin A[",i",",","j,"]=');

readLn(A);

writeLn('Matrica e rezultatit A:');

për i:=1 deri në N do (dalja e matricës)

për j:=1 deri në M bëj

shkruaj nje,' ');

Ushtrimi mas3: Jepet një matricë A(N? M), e përbërë nga numra natyrorë. Përcaktoni elementin maksimal dhe indekset e tij.

program mas_3; (Elementi maksimal i matricës)

CONST t= 10; r=10;

A: grup i INTEGER;

n, m, Max, iMax, jMax, k: numër i plotë;

Write('Fut numrin e rreshtave N='); readLn(N);

write('Fut numrin e kolonave M='); lexoLn(M);

writeLn('Matrica:');

FOR i:= 1 deri në N DO (plotësimi i një grupi duke gjeneruar numra të rastit)

PËR j:=1 TË M BËJ

A:= e rastësishme (10);

shkruani (A: 3);

Maksimumi:= A; iMax:=1; jMax:=1; k:=0;(ne pranojmë vlerën fillestare Max = vlerën e elementit të parë)

Për i:=1 deri në N bëj

Për j:=1 deri në M bëj

NËSE A > Maks atëherë

Maksimumi:= A; iMax:=i; jMax:=j; k:=1

WriteLn('Max= ' ,Max,' në rresht: ',imax, ' kolona:', jmax);

Një grup është një strukturë të dhënash e përfaqësuar si një grup qelizash të të njëjtit lloj, të bashkuar nën një emër të vetëm. Vargjet përdoren për të përpunuar sasi të mëdha të dhënash të të njëjtit lloj. Emri i grupit është ai që janë treguesit, do t'ju tregoj pak më vonë. Një qelizë individuale e të dhënave në një grup quhet një element grupi. Elementet e një grupi mund të jenë të dhëna të çdo lloji. Vargjet mund të kenë një ose më shumë se një dimension. Varësisht nga numri i dimensioneve, vargjet ndahen në vargje njëdimensionale, vargje dydimensionale, vargje tredimensionale, e kështu me radhë deri në një varg n-dimensionale. Vargjet njëdimensionale dhe dydimensionale përdoren më shpesh në programim, kështu që ne do të shqyrtojmë vetëm këto vargje.

Vargjet njëdimensionale në C++

Vargu njëdimensional është një grup me një parametër që karakterizon numrin e elementeve të grupit njëdimensional. Në fakt, një grup njëdimensional është një grup që mund të ketë vetëm një rresht dhe n numër kolonash. Kolonat në një grup njëdimensional janë elementet e grupit. Figura 1 tregon strukturën e një grupi të plotë njëdimensional a. Madhësia e këtij grupi është 16 qeliza.

Figura 1 - Vargjet në C++

Vini re se indeksi maksimal i një grupi njëdimensional aështë 15, por madhësia e grupit është 16 qeliza, sepse numërimi i qelizave të grupit gjithmonë fillon nga 0. Indeksi i qelizave është një numër i plotë jo negativ me të cilin mund të aksesoni secilën qelizë të grupit dhe të kryeni çdo veprim mbi të ( qelizë).

//sintaksë për deklarimin e një grupi njëdimensional në C++: /*lloji i të dhënave*/ /*emri i një grupi njëdimensional*/; //një shembull i deklarimit të një grupi njëdimensional të paraqitur në Figurën 1: int a;

ku, int është një numër i plotë;

A është emri i një grupi njëdimensional;
16 është madhësia e një grupi njëdimensional, 16 qelizash.

Gjithmonë menjëherë pas emrit të grupit ka kllapa katrore në të cilat përcaktohet madhësia e grupit njëdimensional.

//një mënyrë tjetër për të deklaruar vargje njëdimensionale int mas, a;

Dy vargje njëdimensionale mas dhe a janë deklaruar me madhësi përkatësisht 10 dhe 16. Për më tepër, në këtë metodë të deklarimit, të gjitha vargjet do të kenë të njëjtin lloj të dhënash, në rastin tonë - int.

// vargjet mund të inicializohen kur deklarohen: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // inicializimi i një grupi njëdimensional

Inicializimi i një grupi njëdimensional kryhet në kllapa kaçurrelë pas shenjës barazohet, çdo element i grupit ndahet nga ai i mëparshmi me presje.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // inicializimi i grupit pa përcaktuar madhësinë e tij.

Në këtë rast, vetë përpiluesi do të përcaktojë madhësinë e grupit njëdimensional. Madhësia e një grupi mund të hiqet vetëm kur e inicializon atë kur deklarohet normalisht një grup, madhësia e grupit duhet të specifikohet. Le të zhvillojmë një program të thjeshtë për të përpunuar një grup njëdimensional.

// array.cpp: Përcakton pikën hyrëse për aplikacionin e konsolës. #include "stdafx.h" #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// kodi Kodi::Blloqe

// Kodi i Dev-C++

// array.cpp: Përcakton pikën hyrëse për aplikacionin e konsolës. #përfshi duke përdorur hapësirën e emrave std; int kryesore(int argc, char* argv) (cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

rreshtat 10-11Është deklaruar dhe inicializuar një grup i plotë njëdimensional i quajtur array1, madhësia e të cilit është 16 qeliza, domethënë një grup i tillë mund të ruajë 16 numra. Çdo përpunim i grupit është i mundur vetëm në lidhje me sythe. Cilin lak të zgjidhni për përpunimin e grupit varet nga ju që të vendosni. Por është më e përshtatshme për këtë detyrë. Ne do të përdorim numëruesin e variablit numërues për të aksesuar elementët e grupit njëdimensional të grupit1. Kushti për vazhdimin e ciklit for përmban një shenjë strikte të pabarazisë, pasi nuk ka indeks të gjashtëmbëdhjetë në vargun njëdimensional1. Dhe meqenëse numërimi i qelizave fillon nga zero, ka 16 elementë në grup në trupin e ciklit for, operatori cout printon elementet e një grupi njëdimensional (shih Figurën 2).

Obrabotka massiva indekson elementin massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 49 array1 1 , shtyp çdo tast. . .

Figura 2 - Vargjet në C++

Le të zhvillojmë një program tjetër për përpunimin e një grupi njëdimensional në C++. Programi duhet të lexojë në mënyrë sekuenciale dhjetë numra të futur nga tastiera. Të gjithë numrat e futur përmblidhen dhe rezultati shfaqet në ekran.

// array_sum.cpp: Përcakton pikën hyrëse për aplikacionin e konsolës. #include "stdafx.h" #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// kodi Kodi::Blloqe

// Kodi i Dev-C++

// array_sum.cpp: Përcakton pikën hyrëse për aplikacionin e konsolës. #përfshi duke përdorur hapësirën e emrave std; int main(int argc, char* argv) ( int array1; // deklaro një grup të plotë cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> grup1; // lexoni numrat e futur nga kutia e tastierës<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Para përpunimit të një grupi, ai duhet të deklarohet dhe madhësia e një grupi njëdimensional është 10, siç përcaktohet nga gjendja e detyrës. Në variablin shuma do të grumbullojmë shumën e elementeve të një vargu njëdimensional. Cikli i parë for mbush grupin njëdimensional të deklaruar me numra të futur nga tastiera, rreshtat 12-13. Ndryshorja numërues përdoret për të aksesuar në mënyrë sekuenciale elementet e grupit njëdimensional të grupit1, duke filluar nga indeksi 0 deri dhe duke përfshirë të 9-tën. Cikli i dytë for shfaq elementet e grupit, rreshtat 15-16. Cikli i tretë for lexon në mënyrë sekuenciale elementet e një grupi njëdimensional dhe i mbledh ato, shuma grumbullohet në variablin shuma. rreshtat 17-18. Rezultati i programit është paraqitur në Figurën 3.

Shkruani elementi massiva: 0 1 2 3 4 5 6 7 8 9 grup1 = (0 1 2 3 4 5 6 7 8 9 ) shuma = 45 Për të vazhduar, shtypni çdo tast. . .

Figura 3 - Vargjet në C++

Së pari, të 10 numrat u futën në mënyrë sekuenciale, pas së cilës u shfaq një grup njëdimensional dhe u printua shuma e numrave në grup.

Vargjet dydimensionale në C++

Deri në këtë pikë, ne kemi konsideruar vargje njëdimensionale, të cilat nuk mund të kufizohen gjithmonë në. Le të themi se ju duhet të përpunoni disa të dhëna nga një tabelë. Një tabelë ka dy karakteristika: numrin e rreshtave dhe numrin e kolonave. Gjithashtu në një grup dydimensional, përveç numrit të elementeve të grupit, ekzistojnë karakteristika të tilla si numri i rreshtave dhe numri i kolonave të një grupi dydimensional. Kjo është, vizualisht, një grup dy-dimensionale është një tabelë e rregullt, me rreshta dhe kolona. Në fakt, një grup dydimensional është një grup njëdimensional i vargjeve njëdimensionale. Struktura e një grupi dydimensional, të quajtur a, me madhësi m me n është paraqitur më poshtë (shih Figurën 4).

Figura 4 - Vargjet në C++

ku, m është numri i rreshtave të një grupi dydimensional;
n është numri i kolonave të një grupi dydimensional;
m * n - numri i elementeve të grupit.

// sintaksë për deklarimin e një grupi dydimensional /*lloji i të dhënave*/ /*emri i grupit*/;

Në deklarimin e një grupi dydimensional, si dhe në deklarimin e një grupi njëdimensional, para së gjithash, duhet të specifikoni:

  • lloji i të dhënave;
  • emri i grupit.

Pas kësaj, kllapat e para katrore tregojnë numrin e rreshtave të grupit dydimensional, dhe kllapat e dyta katrore tregojnë numrin e kolonave të grupit dydimensional. Një grup dy-dimensionale dallohet vizualisht nga një grup njëdimensional nga një palë e dytë kllapa katrore. Le të shohim një shembull të deklarimit të një grupi dydimensional. Le të themi se duhet të deklarojmë një grup dydimensional me një numër elementësh të barabartë me 15. Në këtë rast, një grup dydimensional mund të ketë tre rreshta dhe pesë kolona ose pesë rreshta dhe tre kolona.

// shembull deklarimi i një grupi dydimensional: int a;

  • a është emri i grupit të numrave të plotë
  • numri në kllapat e para katrore tregon numrin e rreshtave të grupit dydimensional, në këtë rast janë 5;
  • numri në kllapat e dyta katrore tregon numrin e kolonave të grupit dydimensional, në këtë rast janë 3.

// inicializimi i një grupi dydimensional: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1));

Ky grup ka 5 rreshta, 3 kolona. pas shenjës së caktimit vendosen kllapa kaçurrela të përgjithshme, brenda të cilave vendosen aq palë kllapa kaçurrela sa duhet të ketë vija në një grup dydimensional dhe këto kllapa ndahen me presje. Në çdo palë kllapa kaçurrela, shkruani elementet e një grupi dydimensional të ndarë me presje. Në të gjitha mbajtëset kaçurrelë, numri i elementeve duhet të jetë i njëjtë. Meqenëse ka pesë rreshta në grup, ka edhe pesë çifte të brendshme kllapash. Në kllapat e brendshme janë shkruar tre elemente, pasi numri i kolonave është tre. Grafikisht, grupi ynë do të duket si një tabelë dy-dimensionale (shih Figurën 5).

Figura 5 - Vargjet në C++

Në çdo qelizë të një grupi dydimensional a tregohet vlera, adresa e kësaj qelize tregohet në këndin e poshtëm djathtas. Adresa e qelizës së një grupi dydimensional është emri i grupit, numri i rreshtit dhe numri i kolonës.

Le të zhvillojmë një program të thjeshtë për përpunimin e një grupi dydimensional, të quajtur "Labyrinth". Labirinti duhet të ndërtohet mbi bazën e një grupi dydimensional. Ne do të zgjedhim madhësinë e labirintit sipas gjykimit tonë.

// array2.cpp: Përcakton pikën hyrëse për aplikacionin e konsolës. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) ndryshe cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kodi Kodi::Blloqe

// Kodi i Dev-C++

// array2.cpp: Përcakton pikën hyrëse për aplikacionin e konsolës. #përfshi duke përdorur hapësirën e emrave std; int main(int argc, char* argv) ( // 1-kushtëzuar "muret e labirintit" // 2-"rruga e saktë, dalja nga labirinti" // 0-"rruga e rreme" int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // inicializimi i një grupi dydimensional ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1, (1,2,2,2,2,2,2, 1,2,1,1 ,1,1,2,1,0,0,1,0,1, (1,1,1,1,1,1,2,1,2,1,0 ,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2, 0,0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,) (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0, 0,0,1,0 ,0,1,1,2,1,1,1,1,0,0,0,0,1,1, (1,0,0,1,0,0,0 ,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1, 1,1,1,2 ,1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,) , (1,2,1 ,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1 ,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,1, (1,2,1,2,1,2, 1,2,1,0,1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1,2,1,0 ,1,1,1, 1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0,0,0,0, 0,0,0,0 ,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0 ,1,2,1, ), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1, ), (1,2, 1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,), (1,2, 1,1,2,1 ,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1,1,2,1 ,0,0,1, 1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1,1,0,1, 2,2,2,2 ,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2,1,1,1 ,1,1,1, 1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1, 1,1,2,2 ,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,1,), (1,2 ,1,1,2, 1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2,2,2,2, 1,0,1,1 ,2,2,2,2,0,0,1,0,0,0,1,1, (1,1,1,1,1,1,1,1,1 ,1,1,1, 1,1,1,1,1,1,1,1,) ); // dy unaza - të brendshme dhe të jashtme, duke aksesuar çdo element të grupit për (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) ndryshe cout<< " "; // вывести два пробела cout << endl; } return 0; }

Shtigjet e sakta dhe të gabuara mund të shënohen me të njëjtin numër, për shembull, zero, por për qartësi, shtegu i saktë shënohet me numrin 2. Vargu u inicializua manualisht, vetëm për të thjeshtuar programin. Meqenëse programi përpunon një grup dy-dimensionale, nevojiten dy sythe për të kaluar midis elementeve të grupit dydimensional. Cikli i parë for kalon midis rreshtave të një grupi dydimensional. Meqenëse ka 33 rreshta në një grup dydimensional, ndryshorja numërues i rritet nga 0 në 33, rreshti 46. Brenda ciklit të parë është një cikli for që qarkullon nëpër elementët e rreshtit të një grupi dydimensional. Në trupin e ciklit të dytë for, një operacion unar i konvertimit të tipit të të dhënave kryhet brenda - static_cast<>() , i cili printon karakterin numër 176. Operacioni i konvertimit të tipit të të dhënave është dublikuar për të rritur gjerësinë e labirintit. Rezultati i programit (shih Figurën 6).

Figura 6 - Vargjet në C++

Array (Gjithashtu grup indeks, Ndonjehere tabela, rresht) - një grup i emërtuar (i renditur) variablash (të dhënash) të të njëjtit lloj, të vendosura në memorie menjëherë njëri pas tjetrit, të aksesuara nga indeks. Në rastin më të thjeshtë varg ka një gjatësi konstante dhe ruan njësi të dhënash të të njëjtit lloj.

Indeksi i njëjti grup është një numër e tërë, duke treguar një element specifik të grupit.

Numri i indekseve të grupeve të përdorura mund të ndryshojë. Vargjet me një indeks quhen njëdimensionale, me dy - dy dimensionale etj.

Njëdimensionale grupi nuk përputhet rreptësisht vektoriale në matematikë, dy dimensionale - matricë . Vargjet më të përdorura janë një ose dy indekset, më rrallë - me tre, edhe më shumë indekse janë jashtëzakonisht të rralla.

Vargu përshkruhet kështu:

Lloji më i zakonshëm i indeksit është një varg, për shembull:

Më sipër përshkruan grupi B, përbërë nga 5 elemente dhe simbolike grupi R, përbërë nga 34 elementet. Për një grup Do të ndahen 5*6=30 bajt memorie (pasi për variablat e tipit Reale bie në sy 6 bajt memorie), për grupin R - 1*34=34 bajt memorie (për variabla si Char - 1 bajt). Lloji bazë Elementet e grupit mund të jenë çdo gjë, të thjeshtë dhe të strukturuar, me përjashtim të një skedari! Një grup mund të deklarohet duke përdorur vet lloji:

Cikli mund të quhet çdo sekuencë udhëzimesh e ekzekutuar në mënyrë të përsëritur, e organizuar në çfarëdo mënyre (për shembull, duke përdorur një kërcim të kushtëzuar).

Një ekzekutim i vetëm i një trupi laku quhet përsëritje. Shprehje, i cili përcakton, do të ekzekutohet edhe një herë përsëritje, ose ciklit fundi është një kusht dalje ose gjendja e fundit të lakut(por mund të jetë edhe kusht për vazhdim). Thirret ndryshorja që ruan numrin aktual të përsëritjes numëruesi i përsëritjes lak ose thjesht kundër ciklit. Cikli nuk përmban domosdoshmërisht kundër.

Ka cikle:

- Cikli me banak, në të cilën disa ndryshore e ndryshojnë vlerën e saj nga një e dhënë fillore vlerat deri në përfundimtar kuptimet me disa hap, dhe për çdo vlerë të kësaj variabli trupi i ciklit ekzekutohet një herë. Zbatuar nga operatori për

Shembull. Plotësoni varg:

Dhe kështu mund të plotësoni dy dimensionale grup:

- Cikli me parakusht, i cili ekzekutohet për sa kohë që disa kushte të specifikuara para fillimit të saj janë të vërteta. Zbatuar nga operatori derisa.

- Cikli me kusht post, në të cilin gjendja kontrollohet pasi të ekzekutohet trupi i ciklit, që do të thotë se trupi ekzekutohet gjithmonë të paktën një herë. Në Pascal, ky lak zbatohet nga operatori përsëris...derisa

Ka një operacion kapërce përsëritjen, kur në përsëritjen aktuale ciklitështë e nevojshme të kapërcehen të gjitha komandat deri në fund të trupit të ciklit të ekzekutuar. Në këtë rast, vetë cikli nuk duhet të ndërpritet, kushtet e vazhdimit ose të daljes duhet të llogariten në mënyrën e zakonshme. Zbatuar nga operatori vazhdojnë.

Komanda përdoret gjithashtu shpesh në sythe dalje e hershme nga cikli, për shembull, kur zbulohet një gabim gjatë ekzekutimit të trupit të lakut, pas së cilës funksionimi i mëtejshëm i lakut nuk ka kuptim. Zbatuar nga operatori DALJE ose thyej.

Le të kthehemi në fillim, ose më mirë në fillim shembull. Ne duhet të përcaktojmë se çfarë bën kjo pjesë e programit:

Bazuar në sa më sipër, grupi dydimensional i përdorur është Aështë një matricë e madhësisë n x n. Përdoret lak me banak nga një në n, me sa duket është përcaktuar më herët.

Brenda ciklit: ndryshore Me merr vlerën e një grupi dydimensional me një indeks (c:=A), së pari kjo . Më pas, në vend të këtij elementi të grupit, futet vlera e një elementi të të njëjtit grup, por me një indeks. (A:=A), ose kur k:=1 (A:=A). Ato. Futen elementet e rreshtit të parë, sepse numri i parë në indeks është përgjegjës për numrin e rreshtit në matricë - [ i,j], dhe e dyta për numrin e kolonës - . Dhe në fund, në vend të elementit me indeks , futet vlera fillestare e elementit të grupit A me indeks , të cilën e kemi futur në ndryshoren Me (A:=c).

Dhe me çdo përsëritje të lakut tonë vlera i rritet me njësi. Le të ndjekim hapat. Së pari kjo :

с:=A A:=A A:=c

с:=A A:=A A:=c

с:=A A:=A A:=c

Kështu që n herë më parë . Ato. vlera diagonale e matricës së drejtimit nga e majta në të djathtë dhe nga lart poshtë. DHE elementet e kësaj diagonale ndryshojnë vlerat me elementet së pari drenazhet e matricës(ose k-ajo rresht). Pra, përgjigja e saktë është opsioni 3: ky algoritëm ndërron vendet elementet diagonale dhekkolona e tabelës.

Seksionet: Shkenca Kompjuterike

Subjekti: Vargje dydimensionale. Plotësimi i një grupi dydimensional sipas një rregulli të caktuar.

Qëllimet: praktikoni aftësitë e punës me elementë të një grupi dydimensional, mësoni të plotësoni vargjet dydimensionale sipas një rregulli të caktuar, mësoni të nxirrni marrëdhënien midis numrit të rreshtit dhe numrit të kolonës; zhvillimi i të menduarit logjik të nxënësve.

PËRPARIMI I KLASËS

1. Përditësimi i njohurive

Vargjet në të cilat pozicioni i elementeve përshkruhet me dy indekse quhen dydimensionale. Struktura e një grupi të tillë mund të përfaqësohet nga një matricë drejtkëndëshe. Çdo element i matricës identifikohet në mënyrë unike duke treguar numrin e rreshtit dhe kolonës, numri i rreshtit është i, numri i kolonës është j.
Merrni parasysh matricën A me madhësi n*m:

një 11 një 12 a 13 një 14
një 21 një 22 a 23 një 24
a 31 a 32 a 33 një 34

Matrica prej 3 rreshtash dhe 4 kolonash, numri i rreshtave n=3, numri i kolonave m=4. Çdo element ka numrin e vet, i cili përbëhet nga dy numra - numri i rreshtit në të cilin ndodhet elementi dhe numri i kolonës. Për shembull, a23 është një element që gjendet në rreshtin e dytë dhe në kolonën e tretë.
Një grup dy-dimensionale në Turbo Pascal mund të përshkruhet në mënyra të ndryshme. Për të përshkruar një grup dy-dimensionale, duhet të përcaktoni se çfarë lloji të elementeve të tij janë dhe si numërohen (çfarë lloj indeksi është). Ka disa mënyra për të përshkruar një grup dy-dimensional.

Kosto maxN=…; (Numërimet maksimale të rreshtave)
maxM=…; (Vlerat maksimale për numrin e kolonave)

1 mënyrë

Lloji Mas = grup prej<тип элементов>; (Rreth një dimensional)
Lloji TMas = grup i Mas; (Sarte njëdimensionale, elementet e të cilit janë vargje njëdimensionale)

2 mënyra

Lloji Tmas = grup i grupit të<тип элементов>;
(Sarte njëdimensionale, elementet e të cilit janë vargje njëdimensionale)

3 mënyra

Lloji<имя типа>= grup i<тип элементов>; (varg dy-dimensionale)

Preferenca i jepet metodës së tretë të përshkrimit të një grupi dydimensional.

Për shembull:

Const N=3; M=4;
Lloji Tmas= grup i numrave të plotë; (Rreth 2D të numrave të plotë)

Formimi i një grupi dydimensional mund të kryhet në katër mënyra: futje nga tastiera, përmes një gjeneruesi të numrave të rastësishëm, sipas një rregulli të caktuar, ose duke përdorur një skedar.

1) Formimi i një grupi dydimensional duke përdorur hyrjen e tastierës dhe një algoritëm për daljen rresht pas rreshti të elementeve të matricës.

Const N=10;M=10;
Lloji Tmas= grup i numrit të plotë;
Var A:Tmas; i,j:numër i plotë;
Filloni
(Hyrja e elementeve të matricës)
Për i:=1 deri në N bëj
Për j:=1 deri në M bëj
Lexo nje);
(Dalja e elementeve të matricës)
Për i:=1 deri në N filloni
Për j:=1 deri në M bëj
Shkruaj(A:4); (Rreshti i parë është shtypur)
Writeln (Rreshti i ri)
fundi;
fund.

2) Një fragment i një programi për gjenerimin e një grupi dydimensional përmes një gjeneruesi të numrave të rastësishëm.

Filloni
Randomize; (Inicializimi i gjeneratorit të numrave të rastësishëm)
(Hyrja e elementeve të matricës)
Për i:=1 deri në N bëj
Për j:=1 deri në M bëj
Përgjigje: = e rastësishme (45) -22;

2. Studimi i materialit të ri. Plotësimi i një grupi sipas një rregulli

Le të shqyrtojmë disa fragmente të programeve për plotësimin e një grupi dydimensional sipas një ligji të caktuar. Për ta bërë këtë, duhet të nxirrni një rregull mbushjeje.

1. Plotësoni grupin A me madhësi n*m si më poshtë, për shembull

1 2 3 4 5 6 7 8
16 15 14 13 12 11 10 9
17 18 19 20 21 22 23 24
32 31 30 29 28 27 26 25
33 34 35 36 37 38 39 40
48 47 46 45 44 43 42 41

Vargu është i mbushur sipas parimit "gjarpër". Rregulli i mbushjes: nëse numri i rreshtit është numër tek, atëherë A=(i-1)*m+j, përndryshe A=i*m-j+1.

programi M1A;

n,m,i,j: numër i plotë;
fillojnë
readln(n,m);
sepse i:=1 deri në n fillojnë
për j:=1 deri në m bëj
fillojnë
nëse i mod 2 = 1 atëherë
A=(i-1)*m+j
tjetër
A=i*m-j+1;
shkruani (A: 3);
fundi;
shkruarn;
fundi;
lexuarln;
fund.

Këtu është një shembull i një programi për një metodë tjetër mbushjeje sipas një rregulli të caktuar:

programi M1B;
var A: grup i numrave të plotë;
n,m,i,j: numër i plotë;
c: numër i plotë;
fillojnë
readln(n,m);
c:=1;
për i:=1 deri në n bëj
fillojnë
për j:=1 deri në m bëj
fillojnë
A:=c;
nëse (i mod 2 = 0) dhe (j<>m) atëherë
dhjetor (c)
tjetër
inc(c);
shkruani (A: 3);
fundi;
c:=c+m-1;
shkruarn;
fundi;
lexuarln;
fund.

2. Plotësoni grupin A sipas parimit të mëposhtëm:

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

programi M2;
var A: grup i numrave të plotë;
n,m,i,j: numër i plotë;
c: numër i plotë;
fillojnë
readln(n,m);
c:=0;
për i:=1 deri në n bëj
fillojnë
për j:=1 deri në m bëj
fillojnë
nëse (i-1+j) mod 2 = 0 atëherë
A:=0
tjetër
fillojnë
inc(c);
A:=c;
fundi;
shkruani (A: 5);
fundi;
shkruarn;
fundi;
lexuarln;
fund.

3. Plotësoni grupin A sipas parimit të mëposhtëm:

1 12 13 24 25 36
2 11 14 23 26 35
3 10 15 22 27 34
4 9 16 21 28 33
5 8 17 20 29 32
6 7 18 19 30 31

var A: grup i numrave të plotë;
n,m,i,j: numër i plotë;
c: numër i plotë;
fillojnë
readln(n,m);
c:=1;
për j:=1 deri në m bëj
fillojnë
për i:=1 deri në n bëj
fillojnë
A:=c;
nëse (j mod 2 = 0) dhe (i<>n) atëherë
dhjetor (c)
tjetër
inc(c);
fundi;
c:=c+n-1;
fundi;
për i:=1 deri në n bëj
fillojnë
për j:=1 deri në m bëj
shkruani (A: 5);
shkruarn;
fundi;
lexuarln;
fund.

4. Plotësoni grupin A sipas parimit të mëposhtëm:

1 2 3 4 5
2 3 4 5 1
3 4 5 1 2
4 5 1 2 3
5 1 2 3 4

var i,j,m,c,d: numër i plotë;

fillojnë
c:=1;
readln(m);
për j:=1 deri në m bëj
fillojnë
i:=c;
d:=1;
përsëritni
A:=d;
inc(i);
nëse jam atëherë
i:=1;
inc(d);
deri në i=c;
dhjetor (c);
nëse c<= 0 then
c:=m-c;
fundi;
për i:=1 deri në m bëj
fillojnë
për j:=1 deri në m bëj
shkruani (A: 2);
shkruarn;
fundi;
fund.

5. Plotësoni grupin A sipas parimit të mëposhtëm:

1 0 0 0 1
0 1 0 1 0
0 0 1 0 0
0 1 0 1 0
1 0 0 0 1

var m,i,j: numër i plotë;
A: grup i numrave të plotë;
fillojnë
readln(m);
për i:=1 deri në m bëj
fillojnë
për j:=1 deri në m bëj
fillojnë
nëse (i=j) ose (m-i+1=j) atëherë
A: = 1
tjetër
A:=0;
shkruani (A: 2);
fundi;
shkruarn;
fundi;
fund.

3. Probleme për zgjidhje të pavarur

6 5 4 3 2 1
7 8 9 10 11 12
18 17 16 15 14 13
19 20 21 22 23 24
30 29 28 27 26 25
31 32 33 34 35 36

36 25 24 13 12 1
35 26 23 14 11 2
34 27 22 15 10 3
33 28 21 16 9 4
32 29 20 17 8 5
31 30 19 18 7 6

0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0

4) Plotësoni grupin sipas parimit të mëposhtëm:

31 32 33 34 35 36
25 26 27 28 29 30
19 20 21 22 23 24
13 14 15 16 17 18
7 8 9 10 11 12
1 2 3 4 5 6

5) Plotësoni grupin sipas parimit të mëposhtëm:

31 25 19 13 7 1
32 26 20 14 8 2
33 27 21 15 9 3
34 28 22 16 10 4
35 29 23 17 11 5
36 30 24 18 12 6

Detyre shtepie:

1) Plotësoni grupin sipas parimit të mëposhtëm:

6 7 18 19 30 31
5 8 17 20 29 32
4 9 16 21 28 33
3 10 15 22 27 34
2 11 14 23 26 35
1 12 13 24 25 36

2) Plotësoni grupin sipas parimit të mëposhtëm:

31 32 33 34 35 36
30 29 28 27 26 25
19 20 21 22 23 24
18 17 16 15 14 13
7 8 9 10 11 12
6 5 4 3 2 1

3) Plotësoni grupin sipas parimit të mëposhtëm:

0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0

Kur zgjidhni probleme me një sasi të madhe të dhënash të të njëjtit lloj, përdorimi i variablave me emra të ndryshëm që nuk renditen sipas adresave të memories e bën programimin të vështirë. Në raste të tilla, gjuha C përdor objekte të quajtura vargje.

është një pjesë e memories ngjitur që përmban një sekuencë objektesh të të njëjtit lloj, të shënuar me një emër.

Vargu karakterizohet nga konceptet themelore të mëposhtme:

Elementi i grupit (vlera e elementit të grupit)– një vlerë e ruajtur në një qelizë specifike memorie të vendosur brenda grupit, si dhe adresën e kësaj qelize memorie.
Çdo element i grupit karakterizohet nga tre vlera:

  • adresa e elementit - adresa e qelizës së memories fillestare në të cilën ndodhet ky element;
  • indeksi i elementit (numri rendor i elementit në grup);
  • vlera e elementit.

Adresa e grupit – adresa e elementit fillestar të grupit.

Emri i grupit është një identifikues që përdoret për t'iu referuar elementeve të grupit.

Madhësia e vargut – numri i elementeve të grupit

Madhësia e elementit është numri i bajteve të zëna nga një element i grupit.

Grafikisht, vendndodhja e grupit në memorien e kompjuterit mund të paraqitet si një rrip i vazhdueshëm adresash.

Vargu i paraqitur në figurë përmban q elementë me indekse nga 0 në q-1. Çdo element zë k byte në memorien e kompjuterit dhe renditja e elementeve në memorie është sekuenciale.

Adresat e elementit i-të të grupit janë

Adresa e grupit është adresa e elementit fillestar (zero) të grupit. Për të hyrë në elementët e grupit, përdoret numri serial (indeksi) i elementit, vlera fillestare e të cilit është 0. Pra, nëse një grup përmban q elemente, atëherë indekset e elementeve të grupit ndryshojnë nga 0 në q-1.

Gjatësia e vargut është numri i bajteve të alokuara në memorie për të ruajtur të gjithë elementët e grupit.

Gjatësia e vargut = Madhësia e elementit * Numri i elementeve

Funksioni mund të përdoret për të përcaktuar madhësinë e një elementi grupi

madhësia int (lloji);

Për shembull,

madhësia e(char) = 1;
madhësia (int) = 4;
madhësia (float) = 4;
madhësia e (dyfishtë) = 8;

Deklarimi dhe inicializimi i vargjeve

Për të deklaruar një grup në C, përdoret sintaksa e mëposhtme:

shkruani emrin[dimension]=(init);

Inicializimi është një grup vlerash fillestare të elementeve të grupit, të specifikuara në kllapa kaçurrelë, të ndara me presje.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // grup a prej 10 numrash të plotë

Nëse numri i vlerave të inicializimit të specifikuara në kllapat kaçurrelë është më i vogël se numri i elementeve të grupit të specifikuar në kllapat katrore, atëherë të gjithë elementët e mbetur në grup (për të cilët nuk kishte vlera të mjaftueshme inicializimi) do të jenë zero. Kjo veti është e përshtatshme për t'u përdorur për të vendosur të gjithë elementët e një grupi në vlera zero.

int b = (0); // grup b me 10 elementë të inicializuar në 0


Nëse grupi inicializohet kur deklarohet, atëherë vlerat konstante fillestare të elementeve të tij tregohen të ndara me presje në kllapa kaçurrelë. Në këtë rast, numri i elementeve në kllapa katrore mund të hiqet.

int a = (1, 2, 3, 4, 5, 6, 7, 8, 9);

Kur aksesoni elementët e grupit, indeksi i elementit të kërkuar tregohet në kllapa katrore.

Shembull në C

1
2
3
4
5
6
7
8

#përfshi
int main()
{
int a = (5, 4, 3, 2, 1); // grupi a përmban 5 elemente
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar ();
kthimi 0;
}

Rezultati i ekzekutimit të programit:

Sidoqoftë, shpesh është e nevojshme të vendosni vlerat e elementeve të grupit gjatë ekzekutimit të programit. Kjo përdor një deklaratë vargu pa inicializim. Në këtë rast, tregimi i numrit të elementeve në kllapa katrore është i detyrueshëm.

int a;

Për të vendosur vlerat fillestare të elementeve të grupit, përdoret shumë shpesh një lak parametrik:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18


#përfshi
int main()
{
int a;
int i;
// Futja e elementeve të grupit
për (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
// Dalja e elementeve të grupit
për (i = 0; i<5; i++)
printf("%d " , a[i]); // kërkohet hapësira në formatin e printimit
getchar (); getchar ();
kthimi 0;
}

Rezultati i ekzekutimit të programit

Vargjet shumëdimensionale

Vargjet shumëdimensionale mund të deklarohen gjithashtu në C. Dallimi midis një grupi shumëdimensional dhe atij njëdimensional është se në një grup njëdimensional pozicioni i një elementi përcaktohet nga një indeks, dhe në një grup shumëdimensional - nga disa. Një shembull i një grupi shumëdimensional është një matricë.

Forma e përgjithshme e deklarimit të një grupi shumëdimensional

shkruani emrin[dimensioni1][dimensioni2]...[dimensioni];

Elementet e një grupi shumëdimensional janë të vendosur në qelizat e RAM-it të njëpasnjëshme në rendin rritës të adresave. Në kujtesën e kompjuterit, elementët e një grupi shumëdimensional janë të renditur në një rresht, për shembull një grup me 2 rreshta dhe 3 kolona,

int a;


do të vendoset në memorie si më poshtë

Numri i përgjithshëm i elementeve në grupin e dhënë dydimensional përcaktohet si

Numri i rreshtave * Numri i kolonave = 2 * 3 = 6.

Numri i bajteve të memories që kërkohen për të akomoduar grupin jepet nga

Numri i artikujve * Madhësia e artikullit = 6 * 4 = 24 bajt.

Inicializimi i vargjeve shumëdimensionale

Vlerat e elementeve të një grupi shumëdimensional, si në rastin njëdimensional, mund të specifikohen me vlera konstante kur deklarohen, të mbyllura në kllapa kaçurrelë (). Sidoqoftë, në këtë rast, numri i elementeve në rreshta dhe kolona duhet të tregohet në kllapa katrore.

Shembull në C

1
2
3
4
5
6
7
8
9

#përfshi
int main()
{
int a = (1, 2, 3, 4, 5, 6);
printf("%d %d %d\n" , a, a, a);
getchar ();
kthimi 0;
}



Sidoqoftë, më shpesh duhet të futni vlerat e elementeve të një grupi shumëdimensional gjatë ekzekutimit të programit. Për këtë qëllim, është e përshtatshme të përdoret një lak parametrik i mbivendosur.

Shembull në C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#define _CRT_SECURE_NO_WARNINGS
#përfshi
int main()
{
int a; // grup me 2 rreshta dhe 3 kolona
int i, j;
// Futja e elementeve të grupit
për (i = 0; i<2; i++) // qark nëpër linja
{
për (j = 0; j<3; j++) // qark nëpër kolona
{
printf("a[%d][%d] = " , i, j);
scanf("%d" , &a[i][j]);
}
}
// Dalja e elementeve të grupit
për (i = 0; i<2; i++) // qark nëpër linja
{
për (j = 0; j<3; j++) // qark nëpër kolona
{
printf("%d " , a[i][j]);
}
printf("\n"); // linjë e re
}
getchar (); getchar ();
kthimi 0;
}



Kalimi i një vargu te një funksion

Përpunimi i grupeve mund të organizohet me lehtësi duke përdorur funksione të veçanta. Për të përpunuar një varg, duhet t'i kaloni funksionit si argumente

  • adresa e grupit,
  • madhësia e grupit.

Përjashtim bëjnë funksionet e përpunimit të vargut, ku mjafton të kalohet vetëm adresa.

Kur kalohen variabla si argumente në një funksion, të dhënat kalohen si kopje. Kjo do të thotë që nëse një vlerë parametri ndryshon brenda një funksioni, kjo nuk do të ndikojë në vlerën e tij brenda funksionit thirrës.

Nëse një adresë e ndryshueshme (ose adresë vargu) i kalohet një funksioni, atëherë të gjitha operacionet e kryera në funksionin mbi të dhënat brenda fushëveprimit të adresës së specifikuar kryhen në të dhënat origjinale, kështu që grupi origjinal (ose vlera e ndryshores) mund të ndryshohet nga funksioni i thirrur.

Shembull në grupin C Dan prej 10 elementësh. Ndërroni elementët më të mëdhenj dhe fillestarë të grupit. Për operacionet maksimale të kërkimit dhe shkëmbimit të elementeve, përdorni funksionin.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#define _CRT_SECURE_NO_WARNINGS
#përfshi
// Funksioni i shkëmbimit
ndryshimi i zbrazët (int *x, int n)
{
// x - treguesi në grup (adresa e grupit)
// n - madhësia e grupit
int i;
int max, indeks;
max = x;
indeksi = 0;
// Gjetja e elementit maksimal
për (i = 1; i {
nëse (x[i]> max)
{
max = x[i];
indeksi = i;
}
}
// Shkëmbim
x = x;
x = max;
}
// Funksioni kryesor
int main()
{
int a;
int i;
për (i = 0; i<10; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
ndryshim (a, 10); // thirrni funksionin e shkëmbimit
// Dalja e elementeve të grupit
për (i = 0; i<10; i++)
printf("%d " , a[i]);
getchar ();
getchar ();
kthimi
p = p * x[i];
}
kthimi p;
}
// Funksioni kryesor
int main()
{
int a; // grupi i deklaruar a me 5 elementë
int i;
int pr;
// Futja e elementeve të grupit
për (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]); // &a[i] - adresa e elementit i-të të grupit
}
pr = func(a, 5); // llogarit produktin
printf("\n pr = %d" , pr); // nxjerr produktin e elementeve çift
getchar (); getchar ();
kthimi 0;
}




Mbylle