შეავსეთ ორგანზომილებიანი მასივი ზუსტად გამოხატულებამდე. პასკალის ორი სამყაროს მასივები – მატრიცები. სახლი დამოუკიდებელი სათნოებისთვის

როდესაც არსებობს ერთი და იგივე ტიპის მონაცემების დიდი რაოდენობა, ცვლადი მონაცემები სხვადასხვა სახელებით, რადგან ისინი არ არის დალაგებული მეხსიერების მისამართებით, ართულებს პროგრამირებას. ასეთ შემთხვევებში ვიყენებთ ობიექტებს, რომლებსაც მასივები ეწოდება.

- ეს არის მეხსიერების უწყვეტი შენახვა იმავე ტიპის ობიექტების თანმიმდევრობის განსათავსებლად, რომელიც მითითებულია ერთი სახელით.

მასივი ხასიათდება შემდეგი ძირითადი ცნებებით:

მასიური ელემენტი (მასიური ელემენტის მნიშვნელობა)- მნიშვნელობა, რომელიც ინახება მეხსიერების განყოფილებაში, განაწილებული მასივს შორის, ისევე როგორც ამ მეხსიერების განყოფილების მისამართი.
მასივის კანის ელემენტი ხასიათდება სამი მნიშვნელობით:

• ელემენტის მისამართი - cob მეხსიერების მისამართი, რომელშიც ეს ელემენტი ბრუნავს;
• ელემენტის ინდექსი (ელემენტის რიგითი ნომერი მასივში);
• ელემენტის მნიშვნელობა.

Massiveu მისამართები – massivu cob ელემენტის მისამართები.

მასივის სახელი - იდენტიფიკატორი, რომელიც გამოიყენება მასივის ელემენტების ქვეგანყოფილებისთვის.

მასივის ზომა არის მასივის ელემენტების რაოდენობა

ელემენტის ზომა არის ბაიტების რაოდენობა, რომლებიც იკავებს მასივის ერთ ელემენტს.

კომპიუტერის მეხსიერებაში მასივის გრაფიკული გადაწყობა შეიძლება განხორციელდეს უწყვეტი მისამართის გვერდის დათვალიერებით.

წარმოადგენს q ელემენტების მცირე მასივს ინდექსებით 0-დან q-1-მდე. კანის ელემენტი იკავებს კომპიუტერის მეხსიერების k ბაიტს და ელემენტების ჩანაცვლება ხდება მეხსიერებაში თანმიმდევრულად.

მასივის i-ე ელემენტის მისამართებს აქვთ მნიშვნელობები

მასივის მისამართები არის მასივის cob (ნულოვანი) ელემენტის მისამართი. მასივში ელემენტების გამრავლებისთვის გამოითვლება ელემენტის სერიული ნომერი (ინდექსი), რომლის პირველი მნიშვნელობა 0-ის ტოლია. ასე რომ, თუ მასივი შეიცავს q ელემენტებს, მაშინ მასივის ელემენტების ინდექსები იცვლება 0-დან q-1-მდე.

Dovzhina მასივი - ბაიტების რაოდენობა, რომლებიც გამოყოფილია მეხსიერებაში მასივის ყველა ელემენტის შესანახად.

Dovzhina Massivu = ელემენტის ზომა * ელემენტების რაოდენობა

მასივის ელემენტის ზომის დასადგენად, შეგიძლიათ გამოიყენოთ ფუნქცია

int sizeof(type);

Მაგალითად,

ზომა (char) = 1;
sizeof(int) = 4;
sizeof(float) = 4;
ზომა (ორმაგი) = 8;

მასივების განსაცვიფრებელი და ინიციალიზაცია

ენაში მასივის დასამშვიდებლად გამოიყენება შემდეგი სინტაქსი:

სახელის ტიპი [განზომილება] = (ინიციალიზაცია);

ინიციალიზაცია არის მასივის ელემენტების კობ მნიშვნელობების ერთობლიობა, რომელიც ენიჭება ფიგურულ თაღებს და გამოყოფილია კომებით.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // მასივი a 10 მთელი რიცხვით

ვინაიდან ფიგურულ მკლავებში მითითებული საწყისი მნიშვნელობების რაოდენობა, მასივის ელემენტების ყველაზე მცირე რაოდენობა მითითებულია კვადრატულ მკლავებში, შემდეგ ყველა ელემენტი, რომელიც დაკარგულია მასივში (რომლის საწყისი არ არის ამოღებული) შესწავლილი მნიშვნელობები დაყენებულია ნულზე. ეს სიმძლავრე ხელით უნდა იქნას გამოყენებული მასივის ყველა ელემენტისთვის ნულოვანი მნიშვნელობების მინიჭებისთვის.

int b = (0); // b მასივი 10 ელემენტით, ინიციალიზებულია 0-მდე

თუ გამოთქმების მასივი ყრუა, მაშინ მისი ელემენტების მუდმივი მნიშვნელობები მითითებულია ფიგურის მკლავებში. ამ შემთხვევაში, კვადრატულ მკლავებში რამდენიმე ელემენტი შეიძლება გამოტოვდეს.

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

მასივის ელემენტებზე გაფართოებისას, საჭირო ელემენტის ინდექსი მითითებულია კვადრატულ მკლავებში.

კონდახი C-ში

1
2
3
4
5
6
7
8

#შეიცავს
int main()
{
int a = (5, 4, 3, 2, 1); // მასივი a შეიცავს 5 ელემენტს
printf("%d%d%d%d\n", a, a, a, a, a);
getchar();
დაბრუნება 0;
}

პროგრამის შედეგი:

თუმცა, პროგრამირების პროცესში ხშირად საჭიროა მასივის ელემენტების მნიშვნელობების დაზუსტება. რომლის ვიკორისტს აქვს გაოგნებული მასა ინიციალიზაციის გარეშე. ამ შემთხვევაში, კვადრატულ მკლავებში რიგი ელემენტების ჩასმა შეკრულია.

int a;

მასივის ელემენტების cob მნიშვნელობების დასადგენად, ხშირად გამოიყენება პარამეტრული ციკლი:

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

#შეიცავს
int main()
{
int a;
int i;
// ელემენტების შეყვანა მასივში
ამისთვის (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
// მასივის ელემენტების ჩვენება
ამისთვის (i = 0; i<5; i++)
printf("%d", a[i]); // ფორმატში არის ხარვეზი
getchar(); getchar();
დაბრუნება 0;
}

Vikonannya პროგრამის შედეგი

მდიდარი მსოფლიო მასივები

თქვენ შეიძლება გქონდეთ წვდომა მსოფლიოს ფართო ტერიტორიებზე. მდიდარი განზომილებიანი მასივის მნიშვნელობა ერთგანზომილებიან მასივთან შედარებით არის ის, რომ ერთგანზომილებიან მასივში ელემენტის პოზიცია აღინიშნება ერთი ინდექსით, ხოლო მდიდარ განზომილებიან მასივში - დეკალით. მდიდარი მასივის კონდახი არის მატრიცა.

მდიდარი მსოფლიო მასივის სისულელის ზაგალი ფორმა

სახელის ტიპი[dimension1][dimension2]...[dimensionm];

მდიდარი სამყაროს მასივის ელემენტები ბრუნავს მზარდი მისამართის ოპერატიული მეხსიერების თანმიმდევრულ ნაწილებში. კომპიუტერის მეხსიერებაში ტრიალებს მდიდარი მასივის ელემენტები, მაგალითად, მასივი, რომელსაც აქვს 2 მწკრივი და 3 სვეტი,

int a;

ინდუცირებულ ორგანზომილებიან მასივში ელემენტების რაოდენობა ჩნდება როგორც

რიგების რაოდენობა * რიგების რაოდენობა = 2 * 3 = 6.

მასივის გასანაწილებლად საჭირო მეხსიერების ბაიტების რაოდენობა გამოითვლება როგორც

ელემენტების რაოდენობა * ელემენტის ზომა = 6 * 4 = 24 ბაიტი.

მსოფლიოს უმდიდრესი მასივების ინიცირება

მრავალგანზომილებიანი მასივის ელემენტების მნიშვნელობები, როგორც ერთგანზომილებიან გამოსახულებაში, შეიძლება განისაზღვროს მუდმივი მნიშვნელობებით სვეტის შემთხვევაში, რომელიც მოთავსებულია მშვილდის ფორმაში (). თუმცა, ამ შემთხვევაში, სტრიქონებისა და სვეტების რიგი ელემენტები შეიძლება მკაცრად იყოს მითითებული კვადრატულ მკლავებში.

კონდახი C-ში

1
2
3
4
5
6
7
8
9

#შეიცავს
int main()
{
int a = (1, 2, 3, 4, 5, 6);
printf("%d%d%d\n", a, a, a);
getchar();
დაბრუნება 0;
}

თუმცა, უფრო ხშირად საჭიროა პროგრამირების პროცესში მდიდარი მასივის ელემენტების მნიშვნელობების შეყვანა. ამ მეთოდით შეგიძლიათ ხელით გაანალიზოთ პარამეტრული ციკლის ჩასმა.

კონდახი 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
#შეიცავს
int main()
{
int a; // მასივი 2 მწკრივით და 3 მწკრივით
int i, j;
// ელემენტების შეყვანა მასივში
ამისთვის (i = 0; i<2; i++) // ციკლი რიგებში
{
ამისთვის (j = 0; j<3; j++) // ასი ელემენტის ციკლი
{
printf("a[%d][%d] = ", i, j);
scanf("%d", &a[i][j]);
}
}
// მასივის ელემენტების ჩვენება
ამისთვის (i = 0; i<2; i++) // ციკლი რიგებში
{
ამისთვის (j = 0; j<3; j++) // ასი ელემენტის ციკლი
{
printf("%d", a[i][j]);
}
printf("\n"); // გადატანილია ახალ რიგში
}
getchar(); getchar();
დაბრუნება 0;
}

მასივის გადაცემა ფუნქციაზე

მასივის დამუშავება შეიძლება ხელით ორგანიზებული იყოს დამატებითი სპეციალური ფუნქციების გამოყენებით. მასივის ფუნქციის არგუმენტების სახით დასამუშავებლად, თქვენ უნდა გაიაროთ

• masivu მისამართები,
• მასივის ზომა.

აუცილებელია რიგების დამუშავების ფუნქციების დაყენება, ამიტომ საკმარისია მათი მისამართის გადატანა.

ცვლილებების არგუმენტად ფუნქციაში გადაცემისას, მონაცემები გადაეცემა ასლების სახით. ეს ნიშნავს, რომ ფუნქციის შუაში შეიცვლება პარამეტრის მნიშვნელობა, მაგრამ არანაირად არ შეიცვლება ფუნქციის შუა რიცხვებში, რომელიც გამოძახებულია.

თუ გადასვლის მისამართები (ან მისამართები მასივში) გადაეცემა ფუნქციას, მაშინ ყველა ოპერაცია, რომელიც მოიცავს ფუნქციას მინიჭებული მისამართის ხილვადობის ფარგლებში, განხორციელდება თავდაპირველ მონაცემებზე, შემდეგ გამომავალ მასივზე (ან მნიშვნელობებზე). ცვლილების სხვა) შეიძლება შეიცვალოს ფუნქციით, რომელიც ყვირის.

კონდახი C-ზე მოცემული მასივი 10 ელემენტისგან. შეცვალეთ მასივის მაქსიმალური და გამომავალი ელემენტები. მაქსიმალური ელემენტის მოსაძებნად და გაცვლისთვის გამოიყენეთ ფუნქცია.

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
#შეიცავს
// გაცვლის ფუნქცია
ბათილი ცვლილება (int * x, int n)
{
// x - მასივის მაჩვენებელი (მისამართები მასივზე)
// n - მასივის ზომა
int i;
int max, ინდექსი;
max = x;
ინდექსი = 0;
// მოძებნეთ მაქსიმალური ელემენტი
ამისთვის (i = 1; i {
თუ (x[i]> max)
{
max = x[i];
ინდექსი = i;
}
}
// Გაცვლა
x = x;
x = მაქს;
}
// ხელმძღვანელის ფუნქცია
int main()
{
int a;
int i;
ამისთვის (i = 0; i<10; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
ცვლილება (a, 10); // დააჭირეთ გაცვლის ფუნქციას
// მასივის ელემენტების ჩვენება
ამისთვის (i = 0; i<10; i++)
printf("%d", a[i]);
getchar();
getchar();
დაბრუნების
p = p * x[i];
}
დაბრუნება p;
}
// ხელმძღვანელის ფუნქცია
int main()
{
int a; // ცარიელი მასივი a 5 ელემენტით
int i;
int pr;
// ელემენტების შეყვანა მასივში
ამისთვის (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]); // &a[i] - მასივის i-ე ელემენტის მისამართები
}
pr = func(a, 5); // შემოქმედების გამოთვლა
printf("\n pr = %d", pr); // მე ვქმნი ახალ ელემენტებს
getchar(); getchar();
დაბრუნება 0;
}

დაყოფილია: Კომპიუტერული მეცნიერება

საგანი: ორი სამყაროს მასივი. ორი მსოფლიო მასივის დაჯავშნა მოცემული წესით.

მიზნები:ისწავლეთ ორი სამყაროს მასივის ელემენტებთან მუშაობა, ისწავლეთ ორი სამყაროს მასივების შენახვა მოცემული წესის მიხედვით, ისწავლეთ მდებარეობის გამოტანა მწკრივის რიცხვსა და სვეტის ნომერს შორის; მეცნიერთა ლოგიკური აზროვნების განვითარება.

ფარული სამუშაო

1. ცოდნის განახლება

მასივებს, რომელთა ელემენტების პოზიციები აღწერილია ორი ინდექსით, ეწოდება ორგანზომილებიანი. ასეთი მასივის სტრუქტურა შეიძლება წარმოდგენილი იყოს სწორი ჭრის მატრიცით. მატრიცის ტყავის ელემენტი ცალსახად ენიჭება მწკრივის ნომერს და საძილე ნომერს, მწკრივის ნომერს – i, საძილე ნომერს – j.
მოდით შევხედოთ n*m ზომის მატრიცას:

მატრიცა 3 მწკრივით და 4 სვეტით, სტრიქონების რაოდენობა n=3, სვეტების რაოდენობა m=4. ტყავის ელემენტს აქვს თავისი ნომერი, რომელიც შედგება ორი ნომრისგან - რიგის ნომერი, რომელშიც ელემენტი მდებარეობს და რიგის ნომერი. მაგალითად, a23 არის ელემენტი, რომელიც დგას მეორე რიგში და მესამე სვეტში.
Turbo Pascal-ის ორი სამყაროს მასივი შეიძლება აღწერილი იყოს სხვადასხვა გზით. ორგანზომილებიანი მასივის აღსაწერად, თქვენ უნდა იცოდეთ რა ტიპის ელემენტია და როგორ არის დანომრილი (რა ტიპის ინდექსია). ორგანზომილებიანი მასივის აღწერის რამდენიმე გზა არსებობს.

Const maxN = ...; (მაქსიმალური მნიშვნელობები მწკრივების რაოდენობისთვის)
maxM=…; (მაქსიმალური მნიშვნელობები მომხმარებელთა რაოდენობისთვის)

1 გზა

ტიპი Mas = მასივი<тип элементов>; (ერთგანზომილებიანი მასივი)
ტიპი Tmas = მასივი Mas; (ერთგანზომილებიანი მასივი, რომლის ელემენტები არის ერთგანზომილებიანი მასივები)

მეთოდი 2

ტიპი Tmas = მასივის მასივი<тип элементов>;
(ერთგანზომილებიანი მასივი, რომლის ელემენტები არის ერთგანზომილებიანი მასივები)

3 გზა

ტიპი<имя типа>= მასივი<тип элементов>; (ორი მსოფლიო მასივი)

უპირატესობა ენიჭება ორგანზომილებიანი მასივის აღწერის მესამე მეთოდს.

Მაგალითად:

Const N=3; M=4;
ტიპი Tmas = მთელი რიცხვების მასივი; (მთლიანი რიცხვების ორგანზომილებიანი მასივი)

ორგანზომილებიანი მასივის ფორმირება შესაძლებელია რამდენიმე გზით: კლავიატურიდან შემთხვევითი რიცხვების გენერატორის მეშვეობით შეყვანით, მოცემული წესით ან დამატებითი ფაილის გამოყენებით.

1) ორგანზომილებიანი მასივის ფორმირება კლავიატურიდან დამატებითი შეყვანის და მატრიცის ელემენტების მწკრივის ჩვენების ალგორითმის გამოყენებით.

Const N = 10; M = 10;
ტიპი Tmas = მთელი რიცხვების მასივი;
ვარ ა: თმასი; i,j: მთელი რიცხვი;
დაწყება
(მატრიცის ელემენტების გაცნობა)
იყიდება i:=1-დან N-მდე
იყიდება j:=1-დან M-მდე
წაკითხვა (A);
(მატრიცის ელემენტების ჩვენება)
იყიდება i:=1-დან N-მდე დაიწყება
იყიდება j:=1-დან M-მდე
ჩაწერა (A:4); (პირველი რიგის ბრძოლები)
Writeln (გადატანა ახალ რიგში)
დასასრული;
Დასასრული.

2) პროგრამის ფრაგმენტი შემთხვევითი რიცხვების გენერატორის მეშვეობით ორგანზომილებიანი მასივის ფორმირებისთვის.

დაწყება
რანდომიზება; (შემთხვევითი რიცხვების გენერატორის ინიციალიზაცია)
(მატრიცის ელემენტების გაცნობა)
იყიდება i:=1-დან N-მდე
იყიდება j:=1-დან M-მდე
A:=შემთხვევითი(45)-22;

2. ახალი მასალის გაცნობა. მასივის დაჯავშნა წესით

მოდით შევხედოთ პროგრამების რამდენიმე ფრაგმენტს ორი სამყაროს მასივის შესავსებად რეალური კანონის უკან. ამ მიზნით აუცილებელია ცერის წესის გამოყვანა.

1. შეავსეთ A მასივი n*m ზომით ასეთი თანმიმდევრობით, მაგალითად

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

მასივი დაიცავს "გველის" პრინციპს. ჩანაცვლების წესი: თუ მწკრივის ნომერი არის დაუწყვილებელი რიცხვი, მაშინ A=(i-1)*m+j, წინააღმდეგ შემთხვევაში A=i*m-j+1.

პროგრამა M1A;

n, m, i, j: მთელი რიცხვი;
დაიწყოს
readln(n,m);
i:=1-დან n-მდე იწყება
ამისთვის j:=1-დან მ გავაკეთებ
დაიწყოს
თუ i mod 2 = 1 მაშინ
A=(i-1)*m+j
სხვა
A=i*m-j+1;
ჩაწერა (A:3);
დასასრული;
წერენ;
დასასრული;
წაკითხული;
დასასრული.

მოდით შევხედოთ პროგრამას სხვა გზით, რათა დავიცვათ მოცემული წესი:

პროგრამა M1B;
var A: მთელი რიცხვების მასივი;
n, m, i, j: მთელი რიცხვი;
c: მთელი რიცხვი;
დაიწყოს
readln(n,m);
c:=1;
იყიდება i:=1-დან n-მდე
დაიწყოს
ამისთვის j:=1-დან მ გავაკეთებ
დაიწყოს
A:=c;
თუ (i mod 2 = 0) და (j<>მ) შემდეგ
დეკ(გ)
სხვა
inc(c);
ჩაწერა (A:3);
დასასრული;
c:=c+m-1;
წერენ;
დასასრული;
წაკითხული;
დასასრული.

2. შეინახეთ A მასივი შემდეგი პრინციპის გამოყენებით:

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

პროგრამა M2;
var A: მთელი რიცხვების მასივი;
n, m, i, j: მთელი რიცხვი;
c: მთელი რიცხვი;
დაიწყოს
readln(n,m);
c:=0;
იყიდება i:=1-დან n-მდე
დაიწყოს
ამისთვის j:=1-დან მ გავაკეთებ
დაიწყოს
თუ (i-1+j) mod 2 = 0 მაშინ
A:=0
სხვა
დაიწყოს
inc(c);
A:=c;
დასასრული;
ჩაწერა (A:5);
დასასრული;
წერენ;
დასასრული;
წაკითხული;
დასასრული.

3. შეინახეთ A მასივი შემდეგი პრინციპის გამოყენებით:

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: მთელი რიცხვების მასივი;
n, m, i, j: მთელი რიცხვი;
c: მთელი რიცხვი;
დაიწყოს
readln(n,m);
c:=1;
ამისთვის j:=1-დან მ გავაკეთებ
დაიწყოს
იყიდება i:=1-დან n-მდე
დაიწყოს
A:=c;
თუ (j mod 2 = 0) და (i<>ო) შემდეგ
დეკ(გ)
სხვა
inc(c);
დასასრული;
c:=c+n-1;
დასასრული;
იყიდება i:=1-დან n-მდე
დაიწყოს
ამისთვის j:=1-დან მ გავაკეთებ
ჩაწერა (A:5);
წერენ;
დასასრული;
წაკითხული;
დასასრული.

4. შეინახეთ A მასივი შემდეგი პრინციპის გამოყენებით:

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: მთელი რიცხვი;

დაიწყოს
c:=1;
readln(m);
ამისთვის j:=1-დან მ გავაკეთებ
დაიწყოს
მე:=გ;
d:=1;
გაიმეორეთ
A:=d;
inc(i);
თუ მე ვარ მაშინ
i:=1;
inc(d);
სანამ i=c;
დეკ(გ);
თუ გ<= 0 then
c:=m-c;
დასასრული;
ამისთვის i:=1-დან მ გავაკეთებ
დაიწყოს
ამისთვის j:=1-დან მ გავაკეთებ
ჩაწერა (A:2);
წერენ;
დასასრული;
დასასრული.

5. შეინახეთ A მასივი შემდეგი პრინციპის გამოყენებით:

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: მთელი რიცხვი;
A: მთელი რიცხვების მასივი;
დაიწყოს
readln(m);
ამისთვის i:=1-დან მ გავაკეთებ
დაიწყოს
ამისთვის j:=1-დან მ გავაკეთებ
დაიწყოს
თუ (i=j) ან (m-i+1=j) მაშინ
A: = 1
სხვა
A:=0;
ჩაწერა (A:2);
დასასრული;
წერენ;
დასასრული;
დასასრული.

3. დიზაინი დამოუკიდებელი მიღწევებისთვის

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) შეინახეთ მასივი შემდეგი პრინციპით:

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) შეინახეთ მასივი შემდეგი პრინციპით:

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

სახლის დეკორაციები:

1) შეინახეთ მასივი შემდეგი პრინციპით:

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) შეინახეთ მასივი შემდეგი პრინციპით:

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) შეინახეთ მასივი შემდეგი პრინციპით:

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

მასივი არის მონაცემთა სტრუქტურა, რომელიც წარმოდგენილია იმავე ტიპის მონაცემთა ჯგუფის სახით, გაერთიანებული ერთი სახელის ქვეშ. მასიური ვიკორისტები გამოიყენება დიდი რაოდენობით მსგავსი მონაცემების დასამუშავებლად. მე მაქვს იმათთა მასივი, ვინც ცოტა მოგვიანებით ამოიცნობს იგივე ინდიკატორებს. ამ მასივის მიმდებარე ტერიტორიას მასივის ელემენტი ეწოდება. მასივის ელემენტები შეიძლება მიეცეს ნებისმიერ ტიპს. მასებს შეუძლიათ დედობა ან ერთი ან მოკვდეს ერთზე მეტი. აუცილებელია რამდენიმე განზომილებიანი მასივის დაყოფა ერთგანზომილებიან მასივებად, ორგანზომილებიან მასივებად, სამგანზომილებიან მასივებად და n-განზომილებიან მასივებამდე. ყველაზე ხშირად, დაპროგრამებულ ვიკორისტებს აქვთ ერთი და ორი სამყაროს მასივები, ამიტომ ორივე მასივს განვიხილავთ.

ერთგანზომილებიანი მასივები C++

ერთგანზომილებიანი მასივი არის მასივი ერთი პარამეტრით, რომელიც ახასიათებს ელემენტთა რაოდენობას ერთგანზომილებიან მასივში. სინამდვილეში, ერთგანზომილებიანი მასივი არის მასივი, რომელსაც შეიძლება ჰქონდეს ერთზე მეტი მწკრივი და სვეტების n-ე ნომერი. Stovpts ერთგანზომილებიანი მასივი არის მასივის ელემენტები. პატარა სურათი 1 გვიჩვენებს ერთგანზომილებიანი მასივის სტრუქტურას ა. ამ მასივის ზომა 16 ერთეულია.

მალიუნოკი 1 - მასივი C++-ში

გთხოვთ გაითვალისწინოთ, რომ ერთგანზომილებიანი მასივის მაქსიმალური ინდექსი აის 15-ზე მეტია, მაგრამ მასივის ზომა არის 16 შუა, რადგან მასივის შუა რიცხვების ნუმერაცია ყოველთვის იწყება 0-დან. შუას ინდექსი არის სრულიად უცნობი რიცხვი, რომლის გამოყენებაც შესაძლებელია კანზე გასაფართოებლად. მასივის შუა და თვალი nuvati be-yaki dii მის ზემოთ (შუაში).

//ერთგანზომილებიანი მასივის დაცლის სინტაქსი C++: /*მონაცემთა ტიპი*/ /*ერთგანზომილებიანი მასივის სახელი*/; // ბავშვის 1-ის მიერ გამოსახული განსაცვიფრებელი ერთგანზომილებიანი მასივის კონდახი: int a;

დე, მთელი რიცხვები;

A - ერთგანზომილებიანი მასივის დასახელება;
16 - ერთგანზომილებიანი მასივის ზომა, 16 შუა.

მასივის სახელწოდებისთანავე არის კვადრატული მკლავები, რომლებშიც დაყენებულია ერთგანზომილებიანი მასივის ზომა და მასივი იყოფა ცვლილებების გადასაჭრელად.

//ერთგანზომილებიანი მასივების დამუნჯების სხვა გზა int mas, a;

გამოცხადდა მასის ორი ერთგანზომილებიანი მასივი 10 და 16 ზომით თითო ხაზით. უფრო მეტიც, ამ მეთოდით, ყველა მასივი მოითხოვს ახალი ტიპის მონაცემებს, int - int.

// მასივების ინიციალიზაცია შესაძლებელია ცარიელის დროს: int a = (5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); //ერთგანზომილებიანი მასივის ინიციალიზაცია

ერთგანზომილებიანი მასივის ინიციალიზაცია მითითებულია ხვეულ მკლავებზე ნიშნის შემდეგ. ერთი, მასივის კანის ელემენტი ძლიერდება წინა კომაში.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); //აწყობს მასივის ინიციალიზებას მისი ზომის მითითების გარეშე.

მას შემდეგ, რაც შემდგენელი თავად განსაზღვრავს ერთგანზომილებიანი მასივის ზომას. მასივის ზომა არ არის საჭირო მხოლოდ მისი ინიციალიზაციისთვის, მაგრამ საგანგებო სიტუაციის შემთხვევაში მასივი უნდა მიუთითოს მასივის ზომა. შევიმუშავოთ მარტივი პროგრამა ერთგანზომილებიანი მასივის დასამუშავებლად.

// array.cpp: განსაზღვრავს შესასვლელ წერტილს კონსოლის პროგრამისთვის. #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; }

// კოდი Code::Blocks

// Dev-C++ კოდი

// array.cpp: განსაზღვრავს შესასვლელ წერტილს კონსოლის პროგრამისთვის. #შეიცავს namespace std-ის გამოყენებით; int main(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; }

უ რიგები 10-11მთელი რიცხვი ერთგანზომილებიანი მასივი მასივის1 ზომებით, რომლის ზომა უდრის 16 რიცხვს, ცარიელია და ინიციალიზებულია, ასე რომ, ასეთ მასივს შეუძლია შეინახოს 16 რიცხვი. მასივის დამუშავება ერთბაშად ხდება თუ ციკლურად. როგორია შერჩევის ციკლი მასივის დასამუშავებლად? ის საუკეთესოდ შეეფერება ამ ამოცანას. ექიმის მრიცხველი გაიმარჯვებს, რათა გაფართოვდეს ერთგანზომილებიანი მასივის ელემენტებზე1. თუ for მარყუჟის გაგრძელებას აქვს უარყოფითი ნიშანი, მეთექვსმეტე ინდექსის ფრაგმენტები არ არის ერთგანზომილებიან მასივში1. ვინაიდან შუა რიცხვების ნუმერაცია იწყება ნულიდან, მაშინ მასივს აქვს 16 ელემენტი. Cout ოპერატორის ციკლში არის ერთგანზომილებიანი მასივის სხვა ელემენტები (არის 2 პატარა).

მასივის ინდექსების დამუშავება ელემენტი 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 arra1 დააჭირეთ ნებისმიერ ღილაკს. . .

მალიუნოკი 2 - მასივი C++-ში

მოდით ავაშენოთ სხვა პროგრამა ერთგანზომილებიანი C++ მასივის დასამუშავებლად. პროგრამამ თანმიმდევრულად უნდა წაიკითხოს კლავიატურიდან ათი შეყვანილი რიცხვი. ყველა შეყვანილი რიცხვი შეჯამებულია და შედეგი გამოჩნდება ეკრანზე.

// array_sum.cpp: განსაზღვრავს შესვლის წერტილს კონსოლის პროგრამისთვის. #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; }

// კოდი Code::Blocks

// Dev-C++ კოდი

// array_sum.cpp: განსაზღვრავს შესვლის წერტილს კონსოლის პროგრამისთვის. #შეიცავს namespace std-ის გამოყენებით; int main(int argc, char* argv) ( int array1; // ცარიელი მთელი მასივი cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> მასივი1; // კითხულობს ციფრებს, რომლებიც შეყვანილია კლავიატურიდან<< "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; }

მასივის დამუშავების დასრულებამდე აუცილებელია ხმის მიცემა, ხოლო ერთგანზომილებიანი მასივის ზომა 10-ზე მეტია, ვინაიდან ამას გონებრივი დავალება განსაზღვრავს. ცვლადი ჯამი აგროვებს ერთგანზომილებიანი მასივის ელემენტების ჯამს. პირველი for loop ავსებს ერთგანზომილებიან მასივს კლავიატურიდან შეყვანილი რიცხვებით, 12-13 რიგები. მრიცხველის ცვლადი გამოიყენება იმავე განზომილებიანი მასივის მასივის1 ელემენტებზე თანმიმდევრული წვდომისთვის, ინდექსი 0-დან 9-ის ჩათვლით. სხვა for loop აჩვენებს ელემენტების მასივს ეკრანზე, 15-16 რიგები. მესამე ციკლი თანმიმდევრულად კითხულობს ერთგანზომილებიანი მასივის ელემენტებს და აჯამებს მათ, ჯამი გროვდება ცვლად ჯამში. 17-18 რიგები. რობოტული პროგრამის შედეგია ბავშვის გაოცება 3.

შეიყვანეთ elementi massiva: 0 1 2 3 4 5 6 7 8 9 მასივი1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 გასაგრძელებლად დააჭირეთ ნებისმიერ ღილაკს. . .

მალიუნოკი 3 - მასივი C++-ში

ჯერ 10-ვე რიცხვი თანმიმდევრულად იყო შეყვანილი, რის შემდეგაც გამოჩნდა ერთგანზომილებიანი მასივი და მასივს დაემატა რიცხვების ჯამი.

ორი სამყაროს მასივები C++

რამდენად შორს გვინახავს ერთი მსოფლიო მასივები, რომლებითაც შეიძლება სამუდამოდ ვიყოთ გარშემორტყმული. შესაძლებელია, რომ დაგჭირდეთ ცხრილიდან მონაცემების დამუშავება. ცხრილს აქვს ორი მახასიათებელი: სტრიქონების რაოდენობა და სვეტების რაოდენობა. ასევე ორგანზომილებიან მასივში, მასივის ელემენტების რაოდენობის გარდა, არის ისეთი მახასიათებლები, როგორიცაა რიგების რაოდენობა და სვეტების რაოდენობა ორგანზომილებიან მასივში. ასე რომ, ვიზუალურად, არსებობს ორი სამყაროს მასივი - პირველადი ცხრილი რიგებით და სვეტებით. სინამდვილეში, ორგანზომილებიანი მასივი არის ერთგანზომილებიანი მასივის ერთგანზომილებიანი მასივი. ორგანზომილებიანი მასივის სტრუქტურა a ზომებით, ზომით m n-ზე ნაჩვენებია ქვემოთ (განყოფილება 4).

მალიუნოკი 4 - მასივი C++-ში

de, m - ორი სამყაროს მასივის რიგების რაოდენობა;
n - ადამიანების რაოდენობა ორ მსოფლიო მასივში;
m * n – მასივის ელემენტების რაოდენობა.

// ორგანზომილებიანი მასივის დაცლის სინტაქსი /*მონაცემთა ტიპი*/ /*მაივის სახელი*/;

ყრუ ორგანზომილებიან მასივში, ისევე როგორც ყრუ ერთგანზომილებიან მასივში, აუცილებელია შეიყვანოთ:

• მონაცემთა ტიპი;
• მე მასიური ვარ.

აქედან გამომდინარე, პირველი კვადრატული მკლავები მიუთითებს ორგანზომილებიანი მასივის მწკრივების რაოდენობაზე, ხოლო სხვა კვადრატული მკლავები მიუთითებს ორგანზომილებიანი მასივის მწკრივების რაოდენობაზე. ორგანზომილებიანი მასივი ვიზუალურად იყოფა კვადრატული მკლავების კიდევ ერთი წყვილით. მოდით, გადავხედოთ გაოგნებული ორი სამყაროს მასივის კონდახს. შესაძლოა, ჩვენ უნდა შევაფასოთ ორგანზომილებიანი მასივი იმდენი ელემენტით, რამდენიც 15. ამ ორგანზომილებიან მასივს შეიძლება ჰქონდეს სამი მწკრივი და ხუთი სვეტი ან ხუთი მწკრივი და სამი სვეტი.

// განცვიფრებული დვომირნის მასივის კონდახი: int a;

• a - მთელი მასივის სახელი
• პირველი კვადრატული მკლავების რაოდენობა მიუთითებს ორგანზომილებიანი მასივის რიგების რაოდენობაზე, თითოეულს აქვს 5;
• სხვა კვადრატული მკლავების რიცხვი აჩვენებს ორგანზომილებიანი მასივის ელემენტების რაოდენობას, ერთი მათგანისთვის არის 3.

// ორგანზომილებიანი მასივის ინიციალიზაცია: int a = ((4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

ამ მასივს აქვს 5 მწკრივი, 3 სვეტი. მინიჭების ნიშნის შემდეგ შუაში მოთავსებულია ფორმის თაღები, რომელთა შუაში იმდენივე წყვილი ფორმის მკლავია, რამდენი მწკრივია ორგანზომილებიან მასივში და ეს მკლავები იყოფა გროვებად. წყვილი ფორმის თაღში კანში, ორგანზომილებიანი მასივის ელემენტები ჩაიწერება კომაში. ყველა ფორმის მკლავს აქვს რამდენიმე ელემენტი, რომლებიც შეიძლება გაერთიანდეს. ვინაიდან მასივს აქვს ხუთი მწკრივი, მაშინ ასევე არის ხუთი შიდა წყვილი მკლავი. შიდა თაღები სამი ელემენტია, ზოგიერთ თაღს კი სამი ელემენტი აქვს. გრაფიკულად, ჩვენი მასივი ჰგავს ორმაგ ცხრილს (განყოფილება 5).

მალიუნოკი 5 - მასივი C++-ში

ორშრიანი მასივის კანის ცენტრში ანაჩვენებია მნიშვნელობა, ქვედა მარჯვენა ველში ნაჩვენებია კომპანიის მისამართი. ორგანზომილებიანი მასივის შუა მისამართი არის მასივის სახელი, მწკრივის ნომერი და სვეტის ნომერი.

ჩვენ შევიმუშავეთ ძალიან რთული პროგრამა ორგანზომილებიანი მასივის დასამუშავებლად, სახელწოდებით "ლაბირინთი". ლაბირინთი შეიცავს სტიმულს, რომელიც დაფუძნებულია ორგანზომილებიან მასივზე. ლაბირინთის ზომა შეირჩევა ხელისუფლების შეხედულებისამებრ.

// array2.cpp: განსაზღვრავს შესასვლელ წერტილს კონსოლის პროგრამისთვის. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); კოუტ<< static_cast(176); ) სხვა კოუტ<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// კოდი Code::Blocks

// Dev-C++ კოდი

// array2.cpp: განსაზღვრავს შესასვლელ წერტილს კონსოლის პროგრამისთვის. #შეიცავს namespace std-ის გამოყენებით; int main(int argc, char* argv) ( // 1-გონებრივად „ლაბირინთის კედლები“ ​​// 2-„სწორი გზა, გასვლა ლაბირინთიდან“ // 0-„ჰიბნი ბილიკი“ int mas = ((1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // ორგანზომილებიანი მასივის ინიციალიზაცია ( 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,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,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,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,))); // ორი მარყუჟი - შიდა და გარე, რომელიც დაემატება მასივის კანის ელემენტს (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); კოუტ<< static_cast(176); ) სხვა კოუტ<< " "; // вывести два пробела cout << endl; } return 0; }

სწორი და არასწორი გზები შეიძლება განისაზღვროს ერთი ან იგივე რიცხვით, მაგალითად, ნული, ან, სიზუსტისთვის, მნიშვნელობების სწორი გზა 2 რიცხვით. მასივის ინიციალიზაცია გაკეთდა ხელით, უბრალოდ გამარტივებისთვის. პროგრამა. ვინაიდან პროგრამა ამუშავებს ორგანზომილებიან მასივს, მას სჭირდება ორი ციკლი ორგანზომილებიანი მასივის ელემენტებს შორის გადართვისთვის. პირველი for loop შედგება ორგანზომილებიანი მასივის რიგების მონაცვლეობით. ორგანზომილებიან მასივში მწკრივების ფრაგმენტები არის 33, შემდეგ ცვლილება-doctor i იზრდება 0-დან 33-მდე. რიგი 46. პირველი მარყუჟის შუაში არის for loop, რომელიც მონაცვლეობს ორგანზომილებიანი მასივის მწკრივის ელემენტებს შორის. სხვა for loop-ში, შუაში არის მონაცემთა ტიპის ტრანსფორმაციის უნიალური ოპერაცია - static_cast<>() , რომელიც არის კიდევ ერთი სიმბოლო დანომრილი 176. მონაცემთა ტიპების კონვერტაციის ოპერაცია დუბლირებულია ლაბირინთის სიგანის გასაზრდელად. რობოტული პროგრამის შედეგი (დივ. სურ. 6).

მალიუნოკი 6 - მასივი C++-ში

მასივ (ასევე ინდექსის მასივი, ინოდები მაგიდა, რიგი) - მეხსიერებიდან სათითაოდ ამოღებული ერთიდაიგივე ტიპის ცვლილების (მონაცემების) ნაკრების დასახელება (შეკვეთა), რომელთა წვდომა ექვემდებარება ინდექსი. უმარტივესი გზით მასივიის მუდმივად მუშაობს და ინახავს იმავე ტიპის მონაცემთა ერთეულებს.

ინდექსი w masiwu - ცე ნომერი მთლიანი, რომელიც მიუთითებს მასივის კონკრეტულ ელემენტზე

საძიებო მასივში ინდექსების რაოდენობა შეიძლება განსხვავდებოდეს. მასივებს ერთი ინდექსით ეწოდება ერთგანზომილებიანი, ორი - ორ განზომილებიანიდა ა.შ.

ერთგანზომილებიანიმასივი მკაცრად არ ემთხვევა ვექტორი მათემატიკაში, ორ განზომილებიანი - მატრიცები . ყველაზე ხშირად მასივი ჩერდება ერთიან კიდევ ორიინდექსები, ზოგჯერ სამი, კიდევ უფრო მეტი ინდექსიც კი იშვიათად გვხვდება.

მასივი აღწერილია შემდეგნაირად:

ინდექსის ყველაზე გავრცელებული ტიპია დიაპაზონი, მაგალითად:

ჯობია აღწერო მასივი B, რა ვითარდება 5 ელემენტები და სიმბოლური მასივი R, რა ვითარდება 34 ელემენტები. მასივუსთვის უგამოჩნდება მეხსიერების 5 * 6 = 30 ბაიტი (რადგან ცვალებადი ტიპის ქვეშ რეალურიჩნდება 6 ბაიტი მეხსიერების), მასივისთვის R - 1*34=34 ბაიტი მეხსიერება (ცვალებადი ტიპის მიხედვით ჩარ - 1 ბაიტი). ძირითადი ტიპიმასივის ელემენტები შეიძლება იყოს სტრუქტურირებული ნებისმიერი გზით, მაგალითად, ან სტრუქტურირებული, გარდა ფაილისა! მასივი შეიძლება გაჟღერდეს Wikoristanny-ზე ვლასნიტიპი:

ციკლი მას შეიძლება ეწოდოს ინსტრუქციების თანმიმდევრობა, რომელიც არის უაღრესად ლაკონური, ორგანიზებული რაიმე ფორმით (მაგალითად, გონებრივი გადასვლის დასახმარებლად).

სხეულის ერთი ციკლი ეწოდება გამეორება. ვირაზ, რაც ნიშნავს, რომ შემდეგ ჯერზე გაგიფუჭდებათ გამეორება, ან ციკლიდასასრული - ცე უმოვა გასასვლელი ჩი ციკლის დასასრული(ასევე, შესაძლებელია და ინტელექტუალური გაგრძელებაც). მეხსიერება, რომელიც ინახავს გამეორების ხაზის ნომერს, ეწოდება მკურნალის გამეორებაციკლი მარტივია ექიმიციკლი. ციკლიარ არის სავალდებულო შურისძიება ექიმი.

ციკლების გაბრაზება:

- ციკლი ექიმთან, რომელშიც ცვალებადი მოქმედება ცვლის მის მნიშვნელობას მითითებული მნიშვნელობიდან კობღირებულებამდე კინცევოგომოქმედების მნიშვნელობა კროსიდა სხეულის ცვლილების ციკლის კანის ღირებულება სრულდება ერთხელ. განხორციელებული ოპერატორის მიერ ამისთვის

კონდახი. Გადარჩენა მასივი:

ასე რომ თქვენ შეგიძლიათ გახსოვდეთ ორ განზომილებიანიმასივი:

- ციკლი გონების შეცვლასთან ერთად, რომელიც ასკვნის მაშინ, როცა გონების ჭეშმარიტი მუშაობა მითითებულია მისი კობის წინ. განხორციელებული ოპერატორის მიერ ხოლო.

- ციკლი პოსტუმოვასთან ერთად, რომელშიც გონება ხელახლა შემოწმდება მას შემდეგ, რაც სხეული დასრულდება ციკლში და, შემდეგ, სხეული ერთხელ მაინც აღდგება. mov Pascal-ში ამ ციკლს ახორციელებს ოპერატორი გაიმეორეთ... სანამ

პირველი ოპერაცია გამეორების გამოტოვება, თუ ძაფის გამეორებაში ციკლიაუცილებელია ყველა ბრძანების გამოტოვება დასრულებული მარყუჟის დასრულებამდე. ამ შემთხვევაში, თავად ციკლი არ არის დამნაშავე შეფერხების, არამედ გაგრძელების, მაგრამ გამომავალი არის საწყის რანგის დამნაშავე. განხორციელებული ოპერატორის მიერ გააგრძელე.

ასევე ციკლებში ბრძანება ხშირად გამარჯვებულია სტრიქონის წინასწარ გამოსვლა მარყუჟიდანმაგალითად, თუ სხეულის დასრულებისას ციკლი აჩვენებს შესვენებას, შემდგომი მუშაობის შემდეგ ციკლი არ აზიანებს გრძნობას. განხორციელებული ოპერატორის მიერ EXITან კიდევ შესვენება.

მოდით მივმართოთ კუბს, უფრო სწორად, კუბს კონდახი. ჩვენ უნდა გავარკვიოთ, რა უნდა გავაკეთოთ ამ პატარა პროგრამულ ნაწილთან:

გამომდინარე იქიდან, რაც ითქვა, vikorystvovany ორი მსოფლიო მასივი ა- ეს არის მატრიცის ზომა ნ x ნ. მიმდინარეობს ციკლის გაძლიერება ექიმთანერთიდან ნ, შესაძლოა ადრეც იყო მითითებული.

შუა ციკლი: ცვლილება თინახავს ორგანზომილებიანი მასივის მნიშვნელობებს ინდექსით (გ:=ა), ეხლა . შემდეგ, მასივში ამ ელემენტის ადგილზე, შეიყვანება იმავე მასივის ელემენტის მნიშვნელობები, ასევე ინდექსით (A:=A), ან როდის k:=1 (A:=A). ტობტო. პირველი რიგის ელემენტები შედის, რადგან ინდექსში პირველი რიცხვი მიუთითებს მატრიცაში მწკრივის ნომერზე - [ მეკ), ხოლო მეორეს სადგურის ნომრისთვის - . და ბოლოს, ელემენტის ადგილზე ინდექსით , შეიყვანება მასივის ელემენტის პირველადი მნიშვნელობად აინდექსით , როგორც ჭამის ბოლოს მივიტანეთ თ (A:=c).

და ჩვენი მნიშვნელობის ციკლის ყოველი გამეორებით მეიზრდება ერთი. მარტივია კროკებისთვის. დაიწყე ახლავე :

h:=A A:=A A:=c

h:=A A:=A A:=c

h:=A A:=A A:=c

დიახ ნჯერ ადრე . ტობტო. მატრიცის დიაგონალების მნიშვნელობები არის პირდაპირ მარჯვნივ და ქვევით. მე ამ დიაგონალის ელემენტები იცვლება ელემენტების მნიშვნელობებით პირველი მატრიცის დრენაჟები(ან კ- ეს რიგი). ასე რომ, სწორი პასუხია - ვარიანტი 3: ეს ალგორითმი ადგილებს ცვლის დიაგონალური ელემენტებიკცხრილის ე სვეტი.

პასკალი ორგანზომილებიან მასივს განიხილავს, როგორც ერთგანზომილებიან მასივს, რომლის ელემენტების ტიპი ასევე არის მასივი (მაივითა მასივი). ელემენტების პოზიციები პასკალის ორგანზომილებიან მასივებში აღწერილია ორი ინდექსით. ისინი შეიძლება წარმოდგენილი იყოს მართკუთხა მაგიდის ან მატრიცის სახით.

მოდით შევხედოთ პასკალის ორგანზომილებიან მასივს 3*3 ზომებით, შემდეგ მასში იქნება სამი მწკრივი და სამი ელემენტი თითოეულ რიგში:

ტყავის ელემენტს აქვს თავისი ნომერი, როგორც ერთშრიანი მასივების მსგავსად, მაგრამ რიცხვი ასევე შედგება ორი რიცხვისგან - რიგის რიცხვი, რომელშიც ელემენტი მდებარეობს და ეს რიცხვი გაერთიანებულია. ამ გზით, ელემენტის რაოდენობა მითითებულია მწკრივისა და სვეტის ჯვარედინი ზოლით. მაგალითად, 21 არის ელემენტი, რომელიც დგას მეორე რიგში და პირველ სვეტში.

პასკალის ორი სამყაროს მასივის აღწერა.

პასკალის ორგანზომილებიანი მასივის აფეთქების რამდენიმე გზა არსებობს.

უკვე შეგვიძლია აღვწეროთ ერთგანზომილებიანი მასივები, რომელთა ელემენტები შეიძლება იყოს ნებისმიერი ტიპის და შესაბამისად, თავად ელემენტები შეიძლება იყოს მასივები. მოდით შევხედოთ სხვადასხვა ტიპების შემდეგ აღწერას:

ტიპი
ვექტორი = მასივი<тип_элементов>;
მატრიცა = ვექტორის მასივი;
Var m: მატრიცა;

ჩვენ დავარქვით პასკალის ორგანზომილებიან მასივს m, რომელიც შედგება 10 მწკრივისაგან, თითოეული 5 მწკრივისაგან. ამ შემთხვევაში, m [i] შეიძლება დაემატოს კანის i-ე მწკრივს, ხოლო m [i, j] შეიძლება გამოყენებულ იქნას j-th კანის ელემენტზე i-ე რიგის შუაში.

ორგანზომილებიანი პასკალის მასივების ტიპების მნიშვნელობები შეიძლება განისაზღვროს ერთ რიგში:

ტიპი
მატრიცა = მასივის მასივი< тип элементов >;
ან კიდევ უფრო მარტივი:
ტიპი
მატრიცა = მასივი<тип элементов>;

ორგანზომილებიანი მასივის ელემენტებზე გადახვევა ასე გამოიყურება: M [i, j]. ეს ნიშნავს, რომ ჩვენ გვინდა წავშალოთ ელემენტი, რომელიც დამატებულია i-ე მწკრივში და j-ე სვეტში. აქ ჩვენ არ შეგვიძლია აგვერიოს რიგები კონტრტოპებთან, რადგან ჩვენ შეგვიძლია კიდევ ერთხელ დავიყვანოთ მხეცი წარმოუდგენელ ელემენტად. მაგალითად, M ელემენტზე ასვლამ შეიძლება შექმნას ჩანაწერის სწორი ფორმა, ან შეგიძლიათ დარეკოთ მოთხოვნა რობოტის პროგრამიდან.

ძირითადი ოპერაციები პასკალის ორგანზომილებიანი მასივებით

ყველაფერი, რაც ითქვა ერთგანზომილებიანი მასივების მთავარ მოქმედებებზე, ასევე მართალია მატრიცებისთვის. ერთადერთი მოქმედება, რომელიც შეიძლება შესრულდეს ერთი და იგივე ტიპის მატრიცებზე, როგორც მთლიანობაში, არის ფასი. ასე რომ, როდესაც პროგრამები აღწერს ერთი და იმავე ტიპის ორ მატრიცას, მაგალითად,

ტიპი
მატრიცა = მთელი რიცხვების მასივი;
ვარ
a, b: მატრიცა;

შემდეგ პროგრამის რედაქტირების დროს შეგიძლიათ მატრიცების მინიჭება ამატრიცის მნიშვნელობები ბ(ა: = ბ). ყველა სხვა მოქმედება ემატება ელემენტად ელემენტს და ყველა მოქმედი ოპერაცია შეიძლება დაემატოს ელემენტებს, როგორც ეს განსაზღვრულია ამ მასივის ელემენტების ტიპზე. ეს ნიშნავს, რომ თუ მასივი შედგება მთელი რიცხვებისგან, მაშინ მის ელემენტებზე შეგიძლიათ შეასრულოთ ოპერაციები, რომლებიც განკუთვნილია მთელი რიცხვებისთვის, თუ მასივი შედგება სიმბოლოებისგან, მაშინ მათზე ადრე შეგიძლიათ განახორციელოთ ოპერაციები, რომლებიც განკუთვნილია სიმბოლოებთან მუშაობისთვის.

პასკალის ორი სამყაროს მასივის გაცნობა.

ერთგანზომილებიანი მასივის ელემენტების თანმიმდევრულად დასანერგად, ჩვენ გამოვიყენეთ for loop, რომელშიც შევცვალეთ ინდექსის მნიშვნელობები 1-დან დანარჩენზე. ელემენტის პოზიცია ორგანზომილებიან პასკალურ მასივში მითითებულია ორი ინდექსით: მწკრივის ნომერი და სვეტის ნომერი. ეს ნიშნავს, რომ ჩვენ დაგვჭირდება თანმიმდევრულად შევცვალოთ მწკრივის ნომერი 1-დან დანარჩენზე და კანის მწკრივში დავალაგოთ მწკრივების ელემენტები 1-დან დანარჩენზე. ახლა ჩვენ გვჭირდება ორი მარყუჟი, რომელთაგან ერთი მეორეშია ჩასმული.

მოდით შევხედოთ პასკალის ორგანზომილებიანი მასივის კლავიატურიდან შეყვანის მაგალითს:

ტიპი
მატრიცა = მთელი რიცხვების მასივი;
ვარ
ა: მატრიცა;
i, j: მთელი რიცხვი; (ინდექსის მასივი)
დაიწყოს
i:=1-დან 5-მდე do (გამეორება ყველა მწკრივში)
readln(a[i, j]); (კლავიატურიდან შეიყვანეთ ელემენტი, რომელიც არის i-ე მწკრივში და j-ე სვეტში)

პასკალის ორი სამყაროს მასივი შეიძლება შენახული იყოს მარტივი გზით. გამოიყენეთ შემთხვევითი (N) ფუნქცია და ასევე მიანიჭეთ კონკრეტული ვირუსის მნიშვნელობა მატრიცის კანის ელემენტს. პასკალის ორგანზომილებიანი მასივის შევსების მეთოდი შეირჩევა დაკისრებული ამოცანის მიხედვით, მაგრამ ნებისმიერ შემთხვევაში, კანის ელემენტის მნიშვნელობები კანის მწკრივში და კანის ფენაშია დამნაშავე.

პასკალის ორი სამყაროს მასივის ეკრანზე გამოტანა.

პასკალის ორგანზომილებიანი მასივის ელემენტების დერივაცია ასევე თანმიმდევრულად მიმდინარეობს, აუცილებელია კანის რიგისა და კანის სვეტის ელემენტების გაჭიმვა. ვის სურს, რომ ელემენტები, როგორც ერთ რიგში, ხელიხელჩაკიდებული იყოს. ზედიზედ და საძილე ელემენტები ერთმანეთის მიყოლებით ეწყობოდა. რა უნდა გაკეთდეს, აქ არის მოქმედებების თანმიმდევრობა (მოდით, გადავხედოთ პროგრამის ფრაგმენტს მასივისთვის, რომელიც აღწერილია წინა მაგალითში):

i:=1-დან 5-მდე do (გამეორება ყველა მწკრივში)
დაიწყოს
j:=1-დან 10-მდე do (მწკრივის ყველა ელემენტის დახარისხება შპალების მიხედვით)
ჩაწერე(a[i, j]: 4); (დანარჩენი ელემენტები უნდა იყოს მატრიცის i-ე რიგში ეკრანის ერთ რიგში, რომლითაც შეყვანილია 4 პოზიცია კანის ელემენტის საჩვენებლად)
წერენ; (პირველ რიგში შეცვალეთ მწკრივის ნომერი მატრიცაში, თქვენ უნდა გადაიტანოთ კურსორი ეკრანის ახალი მწკრივის დასაწყისში)
დასასრული;

პატივისცემა ( Ეს მნიშვნელოვანია!): საკმაოდ ხშირად, სტუდენტების პროგრამებს პრობლემები ექმნებათ, როდესაც კლავიატურიდან ან ეკრანზე დისპლეის შეყვანა იძულებულია მოხდეს შემდეგი თანმიმდევრობით: readln(a), writeln(a), de ა- ეს მნიშვნელოვანია მასივის ტიპისთვის. ამ შემთხვევაში, ისინი გაკვირვებულნი არიან შემდგენელის ინფორმაციით, რომ შეუძლებელია ამ ტიპის ცვლილების აღბეჭდვა ან განხორციელება. ალბათ მიხვდებით, რატომ ვერ გამოიმუშავებთ რამეს, თუ დაინახავთ ნ კუკლოვს, რომელიც დგას რიგში, და თქვენს ხელში, მაგალითად, წყლის ქვაბი. შეგიძლიათ შეასრულოთ ბრძანება "დაასხით წყალი" და შეავსოთ ყველა გროვა ერთდროულად? თუ არ დაასველეთ, ტყავის ქურთუკში ცოტაოდენი ოკრამო უნდა ჩაასხათ. მასივის ელემენტების შევსება და ჩვენება ასევე უნდა მოხდეს თანმიმდევრულად და ელემენტ-ელემენტზე, რადგან EOM მეხსიერებაში, მასივის ელემენტები იზრდება თანმიმდევრობით.

ხსოვნისადმი მიძღვნილი ხარკი პასკალის ორი სამყაროს მასივისადმი

აბსტრაქტული მასივის ელემენტები აპარატის მეხსიერებაში ფიზიკურად ფართოვდება თანმიმდევრობით აღწერილობით. ამ შემთხვევაში კანის ელემენტი მეხსიერებაში იკავებს ბაიტების დიდ რაოდენობას, რაც მის ზომაზე მიუთითებს. მაგალითად, თუ მასივი შედგება მთელი რიცხვის ტიპის ელემენტებისაგან, მაშინ თითოეული ელემენტი იკავებს ორ ბაიტს. და მთელი მასივი იკავებს S 2 ბაიტს, სადაც S არის მასივის ელემენტების რაოდენობა.

რამდენ ადგილას აიღებ მასივს, რა მასივებზე, მერე. მატრიცა? ცხადია: S i^S j, სადაც S i არის რიგების რაოდენობა და S j არის ელემენტების რაოდენობა თითოეულ მწკრივში. მაგალითად, მასიური ტიპისთვის

მატრიცა = მთელი რიცხვების მასივი;

საჭიროა 12 ბაიტი მეხსიერება.

როგორ გავიხსენოთ ამ მასივის ელემენტები? მოდით გადავხედოთ მასივის M ტიპის მატრიცის განლაგებას მეხსიერებაში.

M ტიპის მთლიანი კანის ელემენტის ქვეშ არის მეხსიერების ორი განყოფილება. მეხსიერების მდებარეობა არის "ქვემოდან ზემოთ". ელემენტები მოთავსებულია ინდექსის ცვლილებების თანმიმდევრობით, რაც ასახავს დაბუდებული მარყუჟების სქემას: ჯერ მოთავსებულია პირველი რიგი, შემდეგ მეორე, მესამე... რიგის შუაში ელემენტები მიდიან თანმიმდევრობით: პირველი. , მეორე და ა.შ.

როგორც ვიცით, ნებისმიერ ცვლილებაზე წვდომა შესაძლებელია მხოლოდ მეხსიერების შუაში არსებული მისამართის შეყვანით, რომელშიც შენახულია ცვლილება. პროგრამების გამოყენებისას შეინიშნება კონკრეტული მეხსიერება, რათა შეიცვალოს, ასე რომ, ურთიერთშესაბამისი დამყარებულია ცვალებადი მეხსიერებასა და კომპიუტერის მისამართს შორის. თუ ცვლილებას მასივი დავარქვით, მაშინ პროგრამამ იცის მასივის cob-ის მისამართი, შემდეგ პირველი ელემენტი. როგორ მიიღწევა მასივის ყველა სხვა ელემენტზე წვდომა? როდესაც რეალურად წვდება მეხსიერებას, რომელშიც ინახება ორგანზომილებიანი მასივის ელემენტი, სისტემა ითვლის მის მისამართებს ფორმულის გამოყენებით:

Adr + SizeElem * Cols * (I -1) + SizeElem * (J -1),

de Adr – რეალური root მისამართი, სადაც მასივი მეხსიერებაშია; I, J – ელემენტების ინდექსები ორგანზომილებიან მასივში; SizeElem – მასივის ელემენტის ზომა (მაგალითად, ორი ბაიტი მთელი რიცხვის ტიპის ელემენტებისთვის); Cols - ელემენტების რაოდენობა ზედიზედ.

Viraz SizeElem * Cols * (I -1) + SizeElem * (J -1) ეწოდება კობის მასივის გადაადგილებას.

რამდენი მეხსიერებაა ხელმისაწვდომი მასივისთვის?

მოდით შევხედოთ არა იმდენად, თუ რამდენი მეხსიერება ჩანს მასივის ქვეშ (რაზეც წინა ნაწილში ვისაუბრეთ), არამედ მასივის მაქსიმალურ დასაშვებ ზომაზე, რომელიც პასუხისმგებელია მეხსიერების მოვლაზე.

რობოტული პროგრამებისთვის მეხსიერება ჩანს სეგმენტებში 64 KB თითოეული და მათგან ერთი ყველაზე მცირეა მონაცემთა სეგმენტი. ამ სეგმენტის ღერძი არის იგივე მონაცემი, რომელსაც ამუშავებს პროგრამა. რა თქმა უნდა, პროგრამები არ შეიძლება გაფართოვდეს ერთზე მეტჯერ ერთ სეგმენტში. ამიტომ, ვინაიდან სეგმენტში მხოლოდ ერთი ცვლილებაა, ის აღწერილია როგორც მასივი და შეუძლებელია 65536 ბაიტზე მეტი ამოღება. და მაინც, მონაცემთა სეგმენტში მასივის გარდა, იქნება სხვა ცვლილებების აღწერა, ასე რომ, მეხსიერების რეალური მეხსიერება, რომელიც ჩანს მასივის ქვეშ, იქნება ნაპოვნი ფორმულით: 65536-S, სადაც S არის მეხსიერების შენახვა, ასევე მასივის ქვეშ არსებული ხედვები, ჩვენი ცვალებადია.

რა უნდა იცოდე? იმისათვის, რომ არ გაგიკვირდეთ, შედგენისას, მთარგმნელი აჩვენებს შეტყობინებას დიდი ხნის მასივის შედგენის შესახებ, თუ პროგრამაში არის აღწერა (სწორია სინტაქსის მიხედვით):

აკრიფეთ myArray = მთელი რიცხვის მასივი;

თქვენ უკვე იცით, რომ მთელი რიცხვების ორბაიტიანი რიცხვების გამოყენებით, თქვენ შეგიძლიათ წაიკითხოთ მასივი მრავალი ელემენტით, რაც უდრის 65536/2 –1=32767. და ეს მხოლოდ იმიტომ, რომ სხვა ცვლილებები არ იქნება. დამნაშავე დედების ორი სამყაროს მასივებს კიდევ უფრო მცირე საზღვრები აქვთ ინდექსებს შორის.

პასკალის ორგანზომილებიანი მასივიდან გამოყოფის ამოცანების გამოყენება.

ზავდანნია:იპოვეთ მატრიცის არანულოვანი ელემენტების რაოდენობა.

გადაწყვეტილება:

• ყველაზე მნიშვნელოვანი ამოცანისთვის გვჭირდება შემდეგი ცვლილებები: მატრიცა, რომელიც შედგება, მაგალითად, მთლიანი ელემენტებისაგან; P - ელემენტების დამატება 0-ის ქვეშ; I, J – მასივის ინდექსები; N, M - რიგების და სვეტების რაოდენობა მატრიცაში.
• შეყვანის მონაცემები არის N, M - მათი მნიშვნელობები შეყვანილია კლავიატურაზე; მატრიცა - მატრიცის დანერგვა შეიძლება ფორმალიზებული იყოს, როგორც სპეციალური შეკვეთით მატრიცის შევსების პროცედურა. დამატებითი random() ფუნქციისთვის.
• გამომავალი მონაცემები იქნება ცვალებადი P (მყარი) მნიშვნელობა.
• პროგრამის ჩვენების სისწორის შესამოწმებლად საჭიროა ეკრანზე გამოსახოთ მატრიცა, რისთვისაც ჩამოვაყალიბებთ მატრიცის ჩვენების პროცედურას.
• დავალების პროგრესი:

განვიხილოთ ძირითადი პროგრამის საწყისი განხორციელება, პროცედურების განხორციელება ცოტა მოგვიანებით იქნება განხილული:

• შეიყვანეთ მნიშვნელობები N და M;
• წარმოგიდგენთ პასკალის ორგანზომილებიან მასივს, რომელიც მიდის vvod (a) პროცედურაზე, სადაც a არის მატრიცა;
• შევქმნათ მატრიცა, რისთვისაც გადავდივართ print(a) პროცედურაზე;
• ნადამოს კობის მნიშვნელობის ცვლილება P =1;
• ჩვენ თანმიმდევრულად ვიმეორებთ I ყველა მწკრივში 1-დან N-მდე, კანის მწკრივისთვის ჩვენ ვიმეორებთ ყველა სვეტს J 1-დან M-მდე, მატრიცის კანის ელემენტისთვის გონებრივად შემოწმებადია: რა არის ij? 0, tvir P გამრავლდება a ij ელემენტზე (P = P * a ij);
• ეკრანზე ნაჩვენებია მატრიცის დამატებითი არანულოვანი ელემენტების მნიშვნელობები - P;

ახლა მოდით ვისაუბროთ პროცედურებზე.

პატივისცემა (ეს მნიშვნელოვანია!) პროცედურის პარამეტრი შეიძლება შეიცვალოს მინიჭებულ ტიპზე, რაც ნიშნავს, რომ მასივის პროცედურაში პარამეტრად გადასაცემად, მისი ტიპი შემდგომში უნდა იყოს აღწერილი. Მაგალითად:

ტიპი
მატრიცა = მთელი რიცხვების მასივი;
პროცედურის პრაიმერი (ა: მატრიცა);
..............................

ახლა მოდით მივმართოთ ჩვენს პროცედურებს.

მატრიცაში შესვლის პროცედურას ეწოდება პროცედურის vvod პარამეტრი - მატრიცა და შედეგად, ის გადადის მთავარ პროგრამაში და პარამეტრი უნდა გადავიდეს. ასე რომ, ჩვენი პროცედურის სათაური ასე გამოიყურება:

პროცედურა vvod (var m: matrix);

პროცედურის ჩასმის ციკლების განსახორციელებლად, ჩვენ გვჭირდება ლოკალური ჩეინჯერები, მაგალითად, k და h. მატრიცის შევსების ალგორითმი უკვე განხილულია, ამიტომ აღარ გავიმეორებთ.

ეკრანზე მატრიცის გამოტანის პროცედურას ეწოდება ბეჭდვა, პროცედურის პარამეტრი არის მატრიცა და ამ შემთხვევაში შეყვანის პარამეტრი ასევე გადადის მნიშვნელობებზე. ამ პროცედურის სათაური ასე გამოიყურება:

პროცედურის ბეჭდვა (მ: მატრიცა);

და ისევ, შუა პროცედურებში საინვესტიციო ციკლების განსახორციელებლად, მეტი ექიმი დაგვჭირდება, ასე დავარქვათ - კ და თ. ამ აღწერაში უფრო სწრაფად არის აღწერილი მატრიცის ეკრანზე ჩვენების ალგორითმი.

შემუშავებული პროგრამა;
ტიპი
მატრიცა = მთელი რიცხვების მასივი;
ვარ
A: მატრიცა;
N, m, i, j: ბაიტი;
P: მთელი რიცხვი;
პროცედურა vvod (var m: matrix);
Var k, h: ბაიტი;
დაწყება
იყიდება i:=1-დან n-მდე (შეცვალეთ n პროცედურა, რომელიც არის გლობალური და ასევე „ხილული“)
j:=1-დან m do (პროცედურისთვის m ცვლილება გლობალურია და, შესაბამისად, „ხილული“)
M:= შემთხვევითი (10);
Დასასრული;
პროცედურის ბეჭდვა (მ: მატრიცა);
Var k, h: ბაიტი;
დაწყება
იყიდება i:=1-დან n-მდე
დაიწყოს
იყიდება j:=1-დან m-მდე
ჩაწერა (M:4);
დაწერა;
დასასრული;
Დასასრული;
დასაწყისი (მთავარი პროგრამის დასაწყისი)
Writeln ("შეიყვანეთ მატრიცის ზომა:");
Readln(N, M);
ვვოდ(ა);
ბეჭდვა (ა);
P:=1;
იყიდება i:=1-დან N-მდე
იყიდება j:=1-დან M-მდე
Თუ<>0 შემდეგ p:=p*a;
Writeln(p);
Დასასრული.