Plotësoni mjetet e vargut. Paskalin

Mësimi shpjegon se si të punohet me vargje njëdimensionale në Pascal, si të përdoret një gjenerator numrash të rastësishëm - funksioni e rastit në Pascal. Është shqyrtuar një shembull se si të nxirren numrat Fibonacci.

Materialet në sit synojnë zotërimin praktik të gjuhës programuese Pascal. Informacioni i shkurtër teorik nuk pretendon të jetë një mbulim i plotë i materialit mbi temën; informacionet e nevojshme mund të gjenden në internet në sasi të mëdha. Detyrat tona përfshijnë ofrimin e mundësisë për të fituar aftësi praktike programimi në Pascal. Shembujt dhe detyrat vizuale të zgjidhura janë paraqitur sipas kompleksitetit në rritje, gjë që do ta bëjë të lehtë studimin e materialit nga e para.

Deklarata e vargut

Ekzistojnë dy lloje vargjesh në Pascal: një-dimensionale dhe dy-dimensionale.
Përcaktimi i një grupi njëdimensional në Pascal tingëllon kështu: një grup njëdimensional është një numër i caktuar elementësh që i përkasin të njëjtit lloj të dhënash, të cilët kanë të njëjtin emër, dhe secili element ka indeksin e vet - një numër serial.
Përshkrimi i një grupi në Pascal (deklarata) dhe qasja në elementët e tij është si më poshtë:

Deklarata e vargut

gjatësia var: vargu [1 .. 3] i numrit të plotë;

gjatësia e fillimit[1]: = 500;

për deklaratën, përdoret fjala e shërbimit Array (përkthyer nga anglishtja si "array" ose "set"); - numri (indeksi) i elementit të parë vendoset në kllapa katrore, pastaj dy pika dhe indeksi i elementit të fundit të vargut, d.m.th. në thelb, tregohet numri i elementeve; thirret numri i elementeve në një varg

dimensioni i grupit

i numrit të plotë (nga anglishtja "nga integers") - tregon se çfarë lloji është grupi, nga këtu është një fjalë ndihmëse. Njoftoni madhësia mund të jetë përmes një konstante: Inicializimi i një vargu:

konstante

, d.m.th. të gjithë elementët e tij në program janë të paracaktuara.

Përshkrimi i një grupi të tillë duket si ky:

const a: vargu [1.. 4] i numrit të plotë = (1, 3, 2, 5);

konst a: grup i numrave të plotë = (1, 3, 2, 5); Plotësimi me numra të njëpasnjëshëm:

writeln("shkruani numrin e elementeve: "); readln(n); (nëse sasia nuk dihet paraprakisht, ne e kërkojmë atë) për i:= 1 deri në n do fillojmë të shkruajmë("a[", i, "]=");

lexo (a[i]);

...fundi; ...

✍ Rezultati shembull:

konst a: grup i numrave të plotë = (1, 3, 2, 5); Shkruani numrin e elementeve: 3 a=5 a=7 a=4

fillo a[1]: = 2;

lexo (a[i]);

a[2]: = 4;

a[3]: = 8;

a[4]: = 6; a[5]: = 3; 6 writeln("Array A:");

(dalja e elementeve të grupit)

fund.

var a: grup i numrave të plotë; (grumbull prej pesë elementësh) i: numër i plotë; filloni një:=2; a:=4; a:=8; a:=6; a:=3; writeln("Array A:"); për i:= 1 deri 5 shkruani(a[i]:2); (elementet e grupit dalës) fundi.

Vargu A: 2 4 8 6 3

lexo (a[i]);

9 8 9 2 0 3 6 9 5 0

Për të punuar me vargje, përdoret më shpesh në Pascal me një parametër, pasi zakonisht e dini se sa elementë janë në grup dhe mund të përdorni një numërues cikli si tregues të elementeve. Detyra e grupit 0. Ju duhet të specifikoni një grup të vërtetë dimensionesh(d.m.th., gjashtë elemente); mbushni grupin me vlera hyrëse dhe shfaqni elementet në ekran. Përdorni dy sythe: i pari për futjen e elementeve, i dyti për dalje.

Në këtë shembull të punës me një grup njëdimensional, ekziston një shqetësim i dukshëm: caktimi i vlerave për elementët.

Përpunimi i vargjeve në Pascal, si dhe mbushja e një grupi, zakonisht ndodh duke përdorur një cikli for.

konst a: grup i numrave të plotë = (1, 3, 2, 5); Funksioni i rastësishëm në Pascal

Për të mos kërkuar vazhdimisht vlerat e elementeve të grupit, përdoret një gjenerues i numrave të rastësishëm në Pascal, i cili zbatohet nga funksioni Random. Në fakt, gjenerohen numra pseudo të rastësishëm, por kjo nuk është çështja.

Për të gjeneruar numra nga 0 në n (duke mos përfshirë vlerën e vetë n-së, numrat e plotë në intervalin e numrit të plotë; i:integer; fillojë të rastësohet; për i:=1 deri në 10 do të fillojë f[i]:=random(10); ( interval ) shkruani (f[i]," fundi;

Për

numra realë

në interval

dhe shfaqja e elementeve në ekran: përcaktoni tre pozicione për shfaqjen e secilit element.

konst a: grup i numrave të plotë = (1, 3, 2, 5); Numrat e Fibonaçit në Pascal

f: vargu [0 .. 19] i numrit të plotë;

filloni f[0]: = 1; f[1]: = 1; për i: = 2 deri në 19 filloni f[ i] : = f[ i- 1 ] + f[ i- 2 ] ;

shkrimln (f[ i] ) fund ; fund. var i: numër i plotë; f: grup i numrit të plotë; fillon f:=1; f:=1; sepse i:=2 deri në 19 filloni f[i]:=f+f; shkrimln(f[i]) fund; fund. Në këtë shembull, parimi i punës me seritë e numrave bëhet i qartë. Zakonisht, për të nxjerrë një seri numrash, gjendet një formulë për përcaktimin e secilit element të kësaj serie. Pra, në rastin e numrave Fibonacci, kjo rregull-formulë duket si f[i]:=f+f. Prandaj duhet të përdoret në për lak

gjatë formimit të elementeve të grupit.

Detyra e grupit 2.

Jepet një rresht me 10 arbitrare

numrat: a, a, ... , a (përdor funksionin random()). Llogaritni dhe printoni shumat e trinjakëve duke qëndruar afër

numrat: a+a+a, a+a+a, a+a+a, ……, a+a+a Pseudokodi:

Gjetja e elementit maksimal sipas indeksit të tij: Detyra Array_min: Gjeni elementin minimal të grupit. Shtypni elementin dhe indeksin e tij. Detyra e grupit 4. Jepet një grup prej 10 elementësh me numra të plotë. Gjeni numrin e atyre negative dhe shfaqni numrin në ekran. Detyra e grupit 5.

Gjeni minimumin dhe maksimumin e n numrave të futur (vargu). Përcaktoni distancën midis këtyre elementeve. 3 2 6 1 3 4 7 2 >>> min=1, max=7, distanca=3

konst a: grup i numrave të plotë = (1, 3, 2, 5);

Detyra e grupit 6.

Jepet një grup i plotë i madhësisë

N

konst a: grup i numrave të plotë = (1, 3, 2, 5);. Shtypni të gjithë numrat çift që përmbahen në këtë grup në rend zbritës të indekseve të tyre, si dhe numrin e tyre K. N=4 mas: 8 9 2 5 >>> 2 8 sasia= 2.
Detyra e grupit 7. K Futni një grup prej 5 elementësh nga tastiera, gjeni dy elementët maksimalë dhe numrin e tyre në të. N=4 mas: 8 9 2 5 >>> 2 8 sasia= 2 Vargu fillestar: 4 -5 10 -10 5 maksimumi A=10, A=5

Jepet një grup prej 10 numrash. Përcaktoni nëse numri i futur nga përdoruesi është në grup. Nëse ka, prodhimi

var f: varg numrash të plotë; flamuri:boolean; i,c:numër i plotë; filloni të rëndomizoni; për i:=1 deri në 10 filloni f[i]:= rastësishme(10);

shkruani (f[i]," "); fundi; flamur:=false; writeln ("fut mostrën"); readln(c); për i:=1 deri në 10 bëni nëse f[i]=c atëherë filloni të shkruani n("gjetur");

flamur:=vërtetë; pushim;

fundi; nëse flag=false atëherë writeln("nuk u gjet"); fund.

• Le të shqyrtojmë
• zgjidhje efektive:

Detyra:

gjeni një element të barabartë me X në grup, ose vërtetoni se ai nuk ekziston.

Algoritmi: filloni nga elementi i parë (i:=1);

konst a: grup i numrave të plotë = (1, 3, 2, 5);

nëse elementi tjetër (A[i]) është i barabartë me X, atëherë përfundoni kërkimin përndryshe shkoni te elementi tjetër.

zgjidhje në Pascal Option 2. while loop:

konst a: grup i numrave të plotë = (1, 3, 2, 5); Ju ftojmë të shikoni një analizë të hollësishme video të kërkimit të një elementi në një grup (një algoritëm efektiv):

fundi; nëse flag=false atëherë writeln("nuk u gjet"); fund.
Plotësoni një grup prej 10 elementësh me numra të rastësishëm në interval dhe shtypni numrat e të gjithë elementëve të barabartë me X.

Vargu fillestar: 4 0 1 2 0 1 3 4 1 0 Çfarë po kërkojmë? 0 A, A, A

Zhvendosja ciklike zhvendosni elementët e grupit majtas me 1 pozicion, elementi i parë zëvendëson të fundit. Zgjidhja:.
konst a: grup i numrave të plotë = (1, 3, 2, 5); A:=A; A:=A;… A:=A[N];

Programi:

Detyra e grupit 9.

konst a: grup i numrave të plotë = (1, 3, 2, 5); Plotësoni një grup prej 10 elementësh me numra të rastësishëm në intervalin [-10..10] dhe kryeni një zhvendosje ciklike në të majtë

Detyra e grupit 8.

fundi; nëse flag=false atëherë writeln("nuk u gjet"); fund.

pa elementin e parë

Vargu fillestar: 4 0 1 2 0 1 3 4 1 0 Çfarë po kërkojmë? 0 A, A, A

Vargu fillestar: 4 -5 3 10 -4 -6 8 -10 1 0 Rezultati: 4 3 10 -4 -6 8 -10 1 0 -5 Rirregullimi i elementeve në një grup
konst a: grup i numrave të plotë = (1, 3, 2, 5); Le të shohim se si një grup është riorganizuar ose përmbysur.

riorganizoni elementet e grupit në rend të kundërt

konst a: grup i numrave të plotë = (1, 3, 2, 5); Pseudokodi:

Detyra e grupit 8.

Detyra e grupit 8. Detyra e grupit 10. Plotësoni një grup prej 10 elementësh me numra të rastësishëm në intervalin [-10..10] dhe ktheni mbrapsht të gjithë elementët përveç atij të fundit. Vargu burimor: -5 3 10 -4 -6 8 -10 1 0 4 Rezultati: 0 1 -10 8 -6 -4 10 3 -5 4 1 .

Zgjedhja e elementeve dhe ruajtja në një grup tjetër

gjeni elemente në një grup që plotësojnë disa kushte (për shembull, negative) dhe kopjoni ato në një grup tjetër

numëroni numrin e elementeve të gjetur duke përdorur numëruesin, instaloni elementin tjetër në vendin B. Duke përdorur një ndryshore numëroj
konst a: grup i numrave të plotë = (1, 3, 2, 5); duhet të caktohet

Prodhimi i grupit B:

writeln ("Artikuj të zgjedhur"); për i:=1 për të numëruar-1 shkruani(B[i], " ")

• Detyra e grupit 11.
• Gjatë përsëritjes së parë të ciklit, elementët e vargut krahasohen me njëri-tjetrin në çifte: i parafundit me të fundit, i parafundit me të parafundit etj. Nëse elementi i mëparshëm rezulton të jetë më i madh se ai pasues, atëherë ato shkëmbehen.
• Gjatë përsëritjes së dytë të lakut, nuk ka nevojë të krahasohet elementi i fundit me atë të parafundit. Elementi i fundit është tashmë në vend, është më i madhi. Kjo do të thotë se numri i krahasimeve do të jetë një më pak. E njëjta gjë vlen edhe për çdo përsëritje pasuese.

Ekzekutimi në Pascal:

A[ j] : = A[ j+ 1 ] ;

A[ j+ 1 ] : = с; fundi ; konst a: grup i numrave të plotë = (1, 3, 2, 5); fundi ;

sepse i:=1 deri në N-1 filloni për j:=N-1 deri te i bëj nëse A[j] > A atëherë filloni nga:= A[j];

• A[j] := A;
• A := c;

fundi;< A then min:=j; if min <>Detyra e grupit 12.

Plotësoni një grup prej 10 elementësh me numra të rastësishëm në interval dhe renditni gjysmën e parë të grupit në rend rritës dhe të dytën në rend zbritës (duke përdorur metodën "Bubble"). Vargu burimor: 14 25 13 30 76 58 32 11 41 97 Rezultati: 13 14 25 30 76 97 58 41 32 11 konst a: grup i numrave të plotë = (1, 3, 2, 5); Renditja sipas përzgjedhjes

elementi minimal kërkohet në grup dhe vendoset në vend të parë (vendoset me A);

fundi; nëse flag=false atëherë writeln("nuk u gjet"); fund.

Ekzekutimi në Pascal:

A[i]: = A[min];< last then begin X:= A[(first + last) div 2]; L:= first; R:= last; while L <= R do begin while A[L] < X do L:= L + 1; while A[R] >A[min] : = c;<= R then begin c:= A[L]; A[L]:= A[R]; A[R]:= c; L:= L + 1; R:= R - 1; end; end; QSort(first, R); QSort(L, last); end; end.

fundi ;
fundi ;

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ë e të dhënave individuale e një grupi 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 fillon gjithmonë 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 në të ( qeliza).

//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 — madhësia e një grupi njëdimensional, 16 qeliza.

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; }

NË 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 >>array1; // 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 kushti i 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 dhe deri te 9-ta përfshirëse. 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.

Vargje 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 do të thotë, 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 dy-dimensionale, 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 ai 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);<< static_castcout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kodi Kodi::Blloqe

// Kodi i Dev-C++

(176); 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);<< static_castcout<< " "; // вывести два пробела 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 dy-dimensional, 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 në programimështë një grup elementesh të të njëjtit lloj (të të njëjtit lloj).

Ka disa lloje vargjesh - njëdimensionale(vektor) dhe shumëdimensionale.

Elementet në një grup karakterizohen nga emrat e tyre dhe numrat serialë - indekset.

Një indeks është numri rendor i një elementi në një grup.

Në Pascal, çdo elementi i caktohet një ose më shumë indekse që përshkruajnë pozicionin e elementit në grup.

Vargu njëdimensional

Var a: grup i numrit të plotë;
Ku:
1 – nënshkrim
10 - mbishkrim
A – emri i variablit të grupit
– varg vlerash
Integer - lloji i të dhënave
A[ i ] – qasja në një element vargu në Pascal

Lloji i elementeve të grupit mund të jetë çdo lloj i vlefshëm në Pascal, përveç skedarëve (madje edhe një grupi).

Shembull i grupit: A = (1,-5,230,55,-88,0,100)

Kur deklarohet një grup, mbishkrimi i tij duhet të përcaktohet në mënyrë strikte.

Kur përshkruani një grup, memoria ndahet dhe përpiluesi duhet të dijë se sa memorie duhet të ndahet për grupin e përshkruar.

Nuk ka asnjë kufizim në numrin e indekseve në një grup Pascal. Megjithatë, grupi në vetvete nuk duhet të jetë më i madh se 65537 bajt.

Një grup mund të deklarohet gjithashtu në seksionin e deklarimit të tipit:

Lloji masë = grup i vërtetë; Var a,b,c: masë;
Elementet e grupit arrihen në një lak.

Mënyra më efikase për të përpunuar elementët e grupit në Pascal është operatori i ciklit me një parametër.

Pse mendoni ju? Po, sepse ne njohim një numër të kufizuar elementësh në grup.

Algoritmet për mbushjen e një vargu në Pascal

1. Futja e elementeve të grupit duke përdorur një kompjuter kryhet duke përdorur konstruksionin e mëposhtëm:

   Për i:= 1 deri në 10 Lexo (A[i]);

2. Vendosja e grupit në mënyrë të rastësishme.

   Vargu mund të vendoset rastësisht duke përdorur një sensor të ndryshueshëm të rastësishëm.

   Për të ekzekutuar një sensor të ndryshueshëm të rastësishëm në Pascal, duhet të shkruani një ndërtim të veçantë - Të rastësishme;

   Vlera e re gjenerohet duke përdorur funksionin Random(n), ku n është një numër i plotë. Në këtë rast, gjenerohet çdo numër me një gamë nga 0 në n.

   K:= E rastësishme (100);
   Nëse funksioni Random përdoret pa një parametër, ai gjeneron një numër real (lloji real) në intervalin 0< X < 1

   X:= E rastësishme;

Plotësimi i një grupi në mënyrë të rastësishme

Randomize ; Për i:= 1 deri në 10 Filloni A[i] := rastësor*100-70 ;

shkruaj(A[i]:6:2); Fundi ;

Ndani punën tuaj në rrjetet sociale

Nëse kjo punë nuk ju përshtatet, në fund të faqes ka një listë të veprave të ngjashme. Ju gjithashtu mund të përdorni butonin e kërkimit

Mbushje.

Ne mund të plotësojmë elementet e një grupi njëdimensional me vlera:

Futja e vlerave nga tastiera;

Rastësisht;

Sipas formulës.

Metodat për specifikimin e vargjeve njëdimensionale

Sythet përdoren për të futur dhe nxjerrë vlerat e vargjeve numerike.

Le të shqyrtojmë procedurat që do të formonin një grup njëdimensional në dy mënyra

1) në mënyrë të rastësishme,

2) futja e elementeve nga tastiera Le të supozojmë se do të punojmë me një grup numrash të plotë. Le të jetë e mjaftueshme që ne të kemi një numër maksimal elementësh të barabartë me 50. Procedura merr një parametër sipas referencës, një grup Massiv të një lloji të caktuar dhe një ndryshore numër të plotë n, i cili është përgjegjës për numrin e qelizave të grupit që duhet të plotësohen. Do të na duhet gjithashtu një ndryshore lokale i

, i cili do të veprojë si një parametër i ciklit dhe përdoret për të specifikuar një numër që identifikon vendndodhjen e elementit në grup., i cili është përgjegjës për numrin e qelizave të grupit që duhet të plotësohen. Do të na duhet gjithashtu një ndryshore lokale 1. Formimi i një vargu njëdimensional në mënyrë të rastësishme. Le të vendosim vlerën e secilit element në rezultatin e funksionit të rastësishëm Random(10). Ne do të vendosim mbushjen e grupit duke përdorur një operator ciklik për, në trupin e të cilit numri i rastësishëm llogaritet nga funksioni Random(10), pas së cilës kjo vlerë i caktohet në vijim

-elementi i grupit.

Procedura InsertMas1(Var massiv:mas; n:integer);

I: numër i plotë;

Filloni

Randomize;

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

Masiv[i] := E rastësishme(10);

Fundi ;

2. Formimi i një grupi njëdimensional duke futur elemente nga tastiera.

Procedura InsertMas1(Var massiv:mas; n:integer);

I: numër i plotë;

Randomize;

I: numër i plotë;

Procedura InsertMas2(Var massiv:mas; n:integer); shkruani ("Hyni", d.m.th

"elementi i grupit");

readln(array[i]);

readln(array[i]);

Fundi;

Vargu shfaqet në ekran si më poshtë:

Procedura InsertMas1(Var massiv:mas; n:integer);

I: numër i plotë;

Procedura PrintMas(massiv:mas; n:integer);

Për i:=1 deri në n

Shkruaj (Massiv[i]:5);

Duhet të kujtojmë se në të tre rastet nuk mund të bëjmë pa organizuar një cikël.

Gjetja e elementit maksimal (minimal) të një vargu.

Le të kemi një grup njëdimensional:

20,-2, 4, 10,7, 21,-12, 0, 4, 17.

Le të mendojmë se cilat operacione duhet të kryhen nëse duhet të gjejmë elementin maksimal. Natyrisht, ne nuk mendojmë për operacionin e krahasimit, sepse ne gjithmonë krahasojmë një çift, "duke kaluar" nëpër të gjithë elementët e grupit. Ne do të ndërtojmë algoritmin për gjetjen e elementit maksimal (minimal) në mënyrë të tillë që të krahasojmë një çift numrash, duke përsëritur veprimin e krahasimit numrin e kërkuar herë.

Pra, duhet t'u përgjigjemi dy pyetjeve:

1) cilët numra përfshihen në çiftin që përbën veprimin e relacionit;

2) sa herë duhet të përsëritet operacioni i krahasimit. Le të prezantojmë një variabël shtesë të quajtur max. Do të jetë një nga numrat, numri i dytë është elementi tjetër i grupit. Për të kryer operacionin e parë të krahasimit, është e nevojshme t'i caktohet një vlerë fillestare ndryshores max. Këtu mund të ketë dy opsione:

1) caktoni elementin e parë të grupit në ndryshoren max;

2) caktoni një numër që është dukshëm më i vogël se të gjithë elementët e grupit.

Skema përmban informacione për numrin e studentëve në secilin grup të vitit të parë. Përcaktoni grupin me numrin maksimal të studentëve, duke supozuar se numri i grupit korrespondon me numrin serial të numrit në grup (supozojmë se ekziston vetëm një grup i tillë).

Me fjalë të tjera, ne duhet të gjejmë elementin maksimal dhe numrin e tij.

programi max_num;

tip mas=array[ 1.. 10] bajt;

var a: mas;

num, i: bajt;

maksimumi: byte;

fillojnë

(blloku i mbushjes)

për i:=l deri në 7 bëj

readln(a[i]);

(kërkoni maksimumin dhe numrin e tij)

max:==0;

(fut numrin më të vogël për këtë grup)

për i:=l të n bëj

nëse a[i]>max atëherë filloni

num:=i;

maksimumi:=a[i]

fundi;

writeln("numri maksimal i studentëve=",max);

writeln("numri i grupit=",num);

fund.

3) Gjeni elementin minimal midis elementeve çift të grupit.

Shpjegim: ne nuk mund t'i caktojmë ndryshores min elementin e parë të grupit, sepse mund të jetë e çuditshme. Prandaj, ne duhet të zgjedhim një numër shumë të madh për këtë lloj të dhënash.

Nëse shpallim atëherë elementet e grupit janë numër i plotë si kjo numri do të jetë +32767.

programi min_madje;

a: grup i numrave të plotë;

i: numër i plotë;

min: numër i plotë;

fillojnë

për i:=l deri në 10 do beein

writeln("futni elementin tjetër të grupit");

readln(a[i]);

fundi;

min:=32767;

për i:=l deri në 10 bëj

nëse (a[i]

nëse min=32767, atëherë writeln ("nuk ka elemente çift në grup") tjetër writein ("elementi minimal midis elementeve çift të grupit = = ",min)

fund.

Ju lutemi vini re: është e nevojshme të kontrolloni nëse vlera e ndryshores min ka ndryshuar, sepse mund të mos ketë as elementë.

Vargjet njëdimensionale. Formimi i një grupi dhe shfaqja e elementeve të tij

Përkufizimi i konceptit

Një grup është një koleksion të dhënash të të njëjtit lloj me një emër të përbashkët për të gjithë elementët.

Elementet e grupit janë të numëruar dhe secili prej tyre mund të aksesohet me numër. Numrat e elementeve të grupit quhen ndryshe indekse, dhe vetë elementët e grupit quhen variabla të indeksuar.

Vektor (lineare Futni një grup prej 5 elementësh nga tastiera, gjeni dy elementët maksimalë dhe numrin e tyre në të. grup njëdimensional) është një shembull i një grupi në të cilin elementët numërohen me një indeks të vetëm.

• Si numrat (indeksi) elementi i grupit, në përgjithësi përdoret shprehja lloji rendor(më shpesh kjo është një konstante e plotë ose një ndryshore e tipit të plotë: numër i plotë, fjalë, bajt Futni një grup prej 5 elementësh nga tastiera, gjeni dy elementët maksimalë dhe numrin e tyre në të. shkurtim)
• Kur aksesoni një element grupi, indeksi tregohet në kllapa katrore. Për shembull, një masë.
• Elementet e grupit përpunohen kur ndryshojnë indekset e elementeve. Për shembull, kur përdorni një shprehje, variablat e mëposhtëm janë të dobishëm për të kaluar nëpër elementet e një grupi:
  • a[i] - të gjithë elementët;
  • a - elementë të vendosur në vende të barabarta;
  • a - elemente në vende tek

Përshkrimi i grupit

• Përcaktimi i një variabli si një grup pa deklaruar më parë llojin e grupit

Shënim

• • Përshkrimi i grupit kërkohet nga përpiluesi për të ndarë memorie për elementët e tij.
  • Një variabël përcaktohet si një grup duke përdorur një fjalë funksioni varg(arresë). Gama tregohet në kllapa katrore, d.m.th., kufijtë e poshtëm dhe të sipërm të vlerës së indeksit të grupit. Vlera e kufirit të sipërm nuk mund të jetë më e vogël se kufiri i poshtëm.
  • Këtu variablat s dhe k konsiderohen të jenë të llojeve të ndryshme. Për të siguruar përputhshmërinë, është e nevojshme të përdoren deklaratat e variablave përmes një deklarate paraprake të tipit.
  • Nëse llojet e vargjeve janë identike, atëherë në një program një grup mund t'i caktohet një tjetri. Në këtë rast, vlerat e të gjitha variablave në një grup do t'u caktohen elementëve përkatës të grupit të dytë.
  • Nuk ka operacione relacionale të përcaktuara në vargje. Mund të krahasoni vetëm dy vargje element pas elementi.
• Përshkrimi paraprak i llojit të grupit

Shënim

• • Elementet e grupit do të aksesohen si kjo: a, a, a, a, a (d.m.th. grupi përmban pesë elemente).
  • Duke përdorur konstante(në këtë shembull n) kur përshkruhet një grup është i preferueshëm, pasi nëse madhësia e grupit ndryshon, nuk do të ketë nevojë të bëhen korrigjime në të gjithë tekstin e programit.
• Vendosja e një vargu në një konstante të shtypur

Shënim

• • Në këtë shembull, jo vetëm që memoria ndahet për grupin, por qelizat janë gjithashtu të mbushura me të dhëna.
  • Elementet e grupit mund të jenë ndryshim gjatë programit (si të gjitha konstantet e shtypura).

Mbushja e një vargu me të dhëna

§ Për të mbushur një grup të dhënat (dhe prodhimi i tyre), më së shpeshti përdoret një lak me një parametër për

§ Për të mbushur një grup me numra të rastit, përdorni funksionin e rastit dhe procedurën rastësoj(inicializimi i gjeneratorit të numrave të rastësishëm). Formati i regjistrimit është: rastësor (B - A) + A, ku A dhe B merren nga intervali :4);

Shembull i programit për hyrjen dhe daljen e një grupi

Deklarata e problemit. Merrni shumën e elementeve të një grupi të përbërë nga 10 elementë të plotë. Elementet e grupit futen nga tastiera.

shuma =

Deklarata e problemit.", shuma)