เติมอาร์เรย์สองมิติให้ตรงกับนิพจน์ อาร์เรย์สองโลกของปาสคาล – เมทริกซ์ บ้านแห่งความมีคุณธรรมที่เป็นอิสระ

เมื่อมีข้อมูลประเภทเดียวกันจำนวนมาก ข้อมูลตัวแปรที่มีชื่อต่างกัน เนื่องจากไม่ได้เรียงลำดับตามที่อยู่หน่วยความจำ จะทำให้การเขียนโปรแกรมซับซ้อนขึ้น ในกรณีเช่นนี้ เราใช้วัตถุที่เรียกว่าอาร์เรย์

- นี่คือการจัดเก็บหน่วยความจำอย่างต่อเนื่องเพื่อรองรับลำดับของวัตถุประเภทเดียวกันซึ่งถูกกำหนดด้วยชื่อเดียว

เทือกเขานี้มีเอกลักษณ์เฉพาะด้วยแนวคิดพื้นฐานดังต่อไปนี้:

องค์ประกอบขนาดใหญ่ (ความหมายขององค์ประกอบขนาดใหญ่)– ค่าที่จัดเก็บไว้ในช่องหน่วยความจำ กระจายระหว่างอาเรย์ รวมถึงที่อยู่ของช่องหน่วยความจำนี้
องค์ประกอบผิวหนังของเทือกเขามีลักษณะเป็นสามค่า:

• ที่อยู่ขององค์ประกอบ - ที่อยู่ของหน่วยความจำซังที่หมุนองค์ประกอบนี้
• ดัชนีองค์ประกอบ (หมายเลขลำดับขององค์ประกอบในอาร์เรย์);
• ความหมายขององค์ประกอบ

ที่อยู่ Massivu - ที่อยู่ขององค์ประกอบซัง Massivu

ชื่ออาร์เรย์ – ตัวระบุที่ใช้สำหรับการแบ่งย่อยองค์ประกอบอาร์เรย์

ขนาดของอาร์เรย์คือจำนวนองค์ประกอบในอาร์เรย์

ขนาดขององค์ประกอบคือจำนวนไบต์ที่ใช้องค์ประกอบอาร์เรย์หนึ่งรายการ

การจัดเรียงอาร์เรย์ในหน่วยความจำของคอมพิวเตอร์แบบกราฟิกสามารถทำได้โดยดูที่หน้าที่อยู่ต่อเนื่อง

แสดงถึงอาร์เรย์เล็กๆ ขององค์ประกอบ q โดยมีดัชนีตั้งแต่ 0 ถึง q-1 องค์ประกอบสกินใช้หน่วยความจำคอมพิวเตอร์จำนวน k ไบต์ และองค์ประกอบต่างๆ จะถูกแทนที่ด้วยหน่วยความจำตามลำดับ

ที่อยู่ขององค์ประกอบ i-th ของอาร์เรย์มีค่า

ที่อยู่อาร์เรย์คือที่อยู่ขององค์ประกอบ cob (ศูนย์) ของอาร์เรย์ สำหรับการคูณองค์ประกอบในอาร์เรย์ จะมีการคำนวณหมายเลขซีเรียล (ดัชนี) ขององค์ประกอบ ซึ่งค่าแรกจะเท่ากับ 0 ดังนั้นหากอาร์เรย์มีองค์ประกอบ q ดัชนีขององค์ประกอบอาร์เรย์จะเปลี่ยนระหว่าง 0 ถึง q-1

อาร์เรย์ Dovzhina - จำนวนไบต์ที่จัดสรรให้กับหน่วยความจำเพื่อบันทึกองค์ประกอบทั้งหมดของอาร์เรย์

Dovzhina Massivu = ขนาดของธาตุ * จำนวนธาตุ

ในการกำหนดขนาดขององค์ประกอบอาร์เรย์คุณสามารถใช้ฟังก์ชันได้

int sizeof(ชนิด);

ตัวอย่างเช่น,

ขนาดของ(ถ่าน) = 1;
ขนาดของ(int) = 4;
ขนาดของ(ลอย) = 4;
ขนาดของ(สองเท่า) = 8;

ที่น่าทึ่งและการเริ่มต้นของอาร์เรย์

หากต้องการปิดบังอาร์เรย์ในภาษา จะใช้ไวยากรณ์ต่อไปนี้:

ประเภทชื่อ [มิติ] = (การเริ่มต้น);

การเริ่มต้นคือชุดของค่าซังขององค์ประกอบอาเรย์ที่กำหนดให้กับส่วนโค้งที่คิดและคั่นด้วยโคม่า

int = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // อาร์เรย์ a ที่มีจำนวนเต็ม 10 ตัว

เนื่องจากจำนวนค่าเริ่มต้นในแขนคิดซึ่งน้อยกว่าจำนวนองค์ประกอบในอาเรย์จะถูกระบุในแขนสี่เหลี่ยมดังนั้นองค์ประกอบทั้งหมดที่หายไปในอาเรย์ (ซึ่งค่าเริ่มต้น คุณค่าที่ศึกษา ​​ถูกตั้งค่าเป็นศูนย์ ต้องใช้กำลังนี้ด้วยตนเองเพื่อกำหนดค่าศูนย์ให้กับองค์ประกอบทั้งหมดของอาร์เรย์

อินท์ ข = (0); // อาร์เรย์ b มี 10 องค์ประกอบ เริ่มต้นเป็น 0

หากอาร์เรย์ของการออกเสียงหูหนวกค่า cob คงที่ขององค์ประกอบจะถูกระบุผ่านแขนรูป ในกรณีนี้ องค์ประกอบจำนวนหนึ่งในแขนกลอาจถูกละเว้น

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

เมื่อขยายอาร์เรย์ไปยังองค์ประกอบ ดัชนีขององค์ประกอบที่ต้องการจะถูกระบุอยู่ในแขนสี่เหลี่ยม

ก้นใน C

1
2
3
4
5
6
7
8

#รวม
int หลัก()
{
int = (5, 4, 3, 2, 1); // อาร์เรย์ a มี 5 องค์ประกอบ
printf("%d%d%d%d\n", a, a, a, a, a);
รับชาร์();
กลับ 0;
}

ผลลัพธ์ของโปรแกรม:

อย่างไรก็ตาม บ่อยครั้งจำเป็นต้องระบุค่าขององค์ประกอบอาร์เรย์ในระหว่างขั้นตอนการเขียนโปรแกรม ซึ่งวิโคริสต์มีมวลมึนงงโดยไม่มีการเริ่มต้น ในกรณีนี้ การใส่องค์ประกอบจำนวนหนึ่งในแขนกลจะถูกผูกไว้

อินท์เอ;

ในการกำหนดค่าซังขององค์ประกอบของอาเรย์มักใช้วัฏจักรแบบพารามิเตอร์:

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

#รวม
int หลัก()
{
อินท์เอ;
ฉัน;
// การป้อนองค์ประกอบลงในอาร์เรย์
สำหรับ (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
// แสดงองค์ประกอบของอาร์เรย์
สำหรับ (i = 0; i<5; i++)
printf("%d", a[i]); // มีช่องว่างในรูปแบบ
รับชาร์(); รับชาร์();
กลับ 0;
}

ผลลัพธ์ของโปรแกรม Vikonannya

เทือกเขาโลกที่อุดมสมบูรณ์

คุณอาจสามารถเข้าถึงพื้นที่ต่างๆ ทั่วโลกได้มากมาย ความสำคัญของอาร์เรย์ริชมิติเมื่อเปรียบเทียบกับอาร์เรย์มิติเดียวคือในอาร์เรย์หนึ่งมิติ ตำแหน่งขององค์ประกอบจะถูกระบุด้วยดัชนีเดียว และในอาร์เรย์ริชมิติ - ด้วยรูปลอก ก้นของเทือกเขารวยคือเมทริกซ์

รูปแบบ zagal ของอาการมึนงงของเทือกเขาโลกที่ร่ำรวย

ประเภทชื่อ[มิติ1][มิติ2]...[มิติm];

องค์ประกอบของอาร์เรย์โลกที่ร่ำรวยจะถูกหมุนเวียนในส่วนที่ต่อเนื่องกันของหน่วยความจำปฏิบัติการของที่อยู่ที่กำลังเติบโต ในหน่วยความจำของคอมพิวเตอร์ องค์ประกอบของอาเรย์แบบสมบูรณ์จะถูกหมุน เช่น อาเรย์ที่มี 2 แถวและ 3 คอลัมน์

อินท์เอ;

จำนวนองค์ประกอบในอาเรย์สองมิติที่เหนี่ยวนำปรากฏเป็น

จำนวนแถว * จำนวนแถว = 2 * 3 = 6

จำนวนไบต์ของหน่วยความจำที่จำเป็นในการจัดสรรอาร์เรย์คำนวณดังนี้

จำนวนองค์ประกอบ * ขนาดองค์ประกอบ = 6 * 4 = 24 ไบต์

การเริ่มต้นของเทือกเขาที่ร่ำรวยที่สุดในโลก

ค่าขององค์ประกอบของอาร์เรย์หลายมิติเช่นเดียวกับในนิพจน์หนึ่งมิติสามารถระบุได้ด้วยค่าคงที่ในกรณีของคอลัมน์ซึ่งวางไว้ในรูปของธนู () อย่างไรก็ตาม ในกรณีนี้ อาจมีการระบุองค์ประกอบจำนวนหนึ่งในแถวและคอลัมน์ไว้ในแขนสี่เหลี่ยมอย่างเคร่งครัด

ก้นใน C

1
2
3
4
5
6
7
8
9

#รวม
int หลัก()
{
int = (1, 2, 3, 4, 5, 6);
printf("%d%d%d\n", a, a, a);
รับชาร์();
กลับ 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 หลัก()
{
อินท์เอ; // อาร์เรย์ที่มี 2 แถวและ 3 แถว
อินท์ฉันเจ;
// การป้อนองค์ประกอบลงในอาร์เรย์
สำหรับ (i = 0; i<2; i++) // วนซ้ำเป็นแถว
{
สำหรับ (เจ = 0; เจ<3; j++) // วนดูหนึ่งร้อยรายการ
{
printf("a[%d][%d] = ", i, j);
scanf("%d", &a[i][j]);
}
}
// แสดงองค์ประกอบของอาร์เรย์
สำหรับ (i = 0; i<2; i++) // วนซ้ำเป็นแถว
{
สำหรับ (เจ = 0; เจ<3; j++) // วนดูหนึ่งร้อยรายการ
{
printf("%d", a[i][j]);
}
printf("\n"); // โอนไปยังแถวใหม่
}
รับชาร์(); รับชาร์();
กลับ 0;
}

การส่งผ่านอาร์เรย์ไปยังฟังก์ชัน

การประมวลผลอาร์เรย์สามารถจัดระเบียบได้ด้วยตนเองโดยใช้ฟังก์ชันพิเศษเพิ่มเติม ในการประมวลผลอาร์เรย์เป็นอาร์กิวเมนต์ของฟังก์ชัน คุณต้องผ่าน

• ที่อยู่มาซิวู
• ขนาดของเทือกเขา

จำเป็นต้องตั้งค่าฟังก์ชั่นการประมวลผลแถวดังนั้นจึงเพียงพอที่จะโอนไปยังที่อยู่ได้

เมื่อส่งการเปลี่ยนแปลงเป็นอาร์กิวเมนต์ไปยังฟังก์ชัน ข้อมูลจะถูกส่งเป็นสำเนา ซึ่งหมายความว่าในช่วงกลางของฟังก์ชัน ค่าของพารามิเตอร์จะเปลี่ยนไป แต่จะไม่เปลี่ยนแปลงกับค่าที่อยู่ตรงกลางของฟังก์ชันที่ถูกเรียกแต่อย่างใด

หากที่อยู่ของการเปลี่ยนแปลง (หรือที่อยู่ของอาร์เรย์) ถูกส่งผ่านไปยังฟังก์ชัน การดำเนินการทั้งหมดที่เกี่ยวข้องกับฟังก์ชันกับข้อมูลที่อยู่ในการมองเห็นของที่อยู่ที่กำหนดจะถูกดำเนินการกับข้อมูลต้นฉบับ จากนั้นอาร์เรย์เอาต์พุต (หรือค่าของการเปลี่ยนแปลง) อื่นๆ) สามารถเปลี่ยนแปลงได้โดยฟังก์ชันที่ตะโกนออกมา

Butt on 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 สูงสุด, ดัชนี;
สูงสุด = x;
ดัชนี = 0;
// ค้นหาองค์ประกอบสูงสุด
สำหรับ (i = 1; i {
ถ้า (x[i]>สูงสุด)
{
สูงสุด = x[i];
ดัชนี = ฉัน;
}
}
// แลกเปลี่ยน
x = x;
x = สูงสุด;
}
// ฟังก์ชั่นหัวหน้า
int หลัก()
{
อินท์เอ;
ฉัน;
สำหรับ (i = 0; i<10; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
เปลี่ยน(ก, 10); // คลิกที่ฟังก์ชั่นการแลกเปลี่ยน
// แสดงองค์ประกอบของอาร์เรย์
สำหรับ (i = 0; i<10; i++)
printf("%d", a[i]);
รับชาร์();
รับชาร์();
กลับ
พี = พี * x[i];
}
กลับพี;
}
// ฟังก์ชั่นหัวหน้า
int หลัก()
{
อินท์เอ; // อาร์เรย์ว่าง a มี 5 องค์ประกอบ
ฉัน;
int ประชาสัมพันธ์;
// การป้อนองค์ประกอบลงในอาร์เรย์
สำหรับ (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]); // &a[i] - ที่อยู่ขององค์ประกอบ i-th ของอาร์เรย์
}
pr = func(a, 5); // การคำนวณความคิดสร้างสรรค์
printf("\n pr = %d", pr); // ฉันกำลังสร้างองค์ประกอบใหม่
รับชาร์(); รับชาร์();
กลับ 0;
}

แยก: วิทยาศาสตร์คอมพิวเตอร์

เรื่อง: เทือกเขาสองโลก การจองเทือกเขาสองโลกตามกฎที่กำหนด

เป้าหมาย:เรียนรู้วิธีทำงานกับองค์ประกอบของอาเรย์สองโลก เรียนรู้การเก็บอาเรย์สองโลกตามกฎที่กำหนด เรียนรู้การอนุมานตำแหน่งระหว่างหมายเลขแถวและหมายเลขคอลัมน์ พัฒนาการคิดเชิงตรรกะของนักวิทยาศาสตร์

งานที่ซ่อนอยู่

1. การอัพเดตความรู้

อาร์เรย์ที่ตำแหน่งขององค์ประกอบถูกอธิบายโดยดัชนีสองตัวเรียกว่าสองมิติ โครงสร้างของอาเรย์ดังกล่าวสามารถแสดงด้วยเมทริกซ์แบบตัดตรง องค์ประกอบหนังของเมทริกซ์ถูกกำหนดให้กับหมายเลขแถวและหมายเลขสลีปเปอร์ หมายเลขแถว – i หมายเลขสลีปเปอร์ – j โดยเฉพาะ
ลองดูเมทริกซ์ขนาด n*m:

เมทริกซ์ที่มี 3 แถว 4 คอลัมน์ จำนวนแถว n=3 จำนวนคอลัมน์ m=4 องค์ประกอบหนังจะมีหมายเลขของตัวเอง ซึ่งประกอบด้วยตัวเลขสองตัว ได้แก่ หมายเลขแถวที่มีองค์ประกอบนั้นอยู่ และหมายเลขของแถว ตัวอย่างเช่น a23 เป็นองค์ประกอบที่อยู่อีกแถวหนึ่งและคอลัมน์ที่สาม
อาร์เรย์สองโลกของ Turbo Pascal สามารถอธิบายได้หลายวิธี ในการอธิบายอาเรย์สองมิติ คุณจำเป็นต้องรู้ว่ามันเป็นองค์ประกอบประเภทใดและมีการกำหนดหมายเลขอย่างไร (เป็นดัชนีประเภทใด) มีหลายวิธีในการอธิบายอาร์เรย์สองมิติ

ค่าคอนสต์ maxN = ...; (ค่าสูงสุดสำหรับจำนวนแถว)
แม็กซ์เอ็ม=…; (ค่าสูงสุดตามจำนวนลูกค้า)

1 วิธี

ประเภท Mas = อาร์เรย์ของ<тип элементов>- (อาร์เรย์หนึ่งมิติ)
พิมพ์ TMas = อาร์เรย์ของ Mas; (อาร์เรย์หนึ่งมิติ องค์ประกอบที่เป็นอาร์เรย์หนึ่งมิติ)

วิธีที่ 2

พิมพ์ TMas = อาร์เรย์ของอาร์เรย์ของ<тип элементов>;
(อาร์เรย์หนึ่งมิติ องค์ประกอบที่เป็นอาร์เรย์หนึ่งมิติ)

3 ทาง

พิมพ์<имя типа>= อาร์เรย์ของ<тип элементов>- (เทือกเขาสองโลก)

ข้อได้เปรียบมอบให้กับวิธีที่สามในการอธิบายอาเรย์สองมิติ

ตัวอย่างเช่น:

ค่าคงที่ N=3; ม=4;
พิมพ์ TMas = อาร์เรย์ของจำนวนเต็ม; (อาร์เรย์สองมิติของจำนวนเต็ม)

การสร้างอาร์เรย์สองมิติสามารถทำได้หลายวิธี: โดยการป้อนจากแป้นพิมพ์ผ่านตัวสร้างตัวเลขสุ่ม ตามกฎที่กำหนด หรือโดยการใช้ไฟล์เพิ่มเติม

1) การสร้างอาร์เรย์สองมิติโดยใช้อินพุตเพิ่มเติมจากแป้นพิมพ์และอัลกอริทึมสำหรับการแสดงแถวขององค์ประกอบเมทริกซ์

ค่าคงที่ N = 10; ม = 10;
พิมพ์ Tmas = อาร์เรย์ของจำนวนเต็ม;
วาร์ A: Tmas; ฉัน,j:จำนวนเต็ม;
เริ่ม
(การแนะนำองค์ประกอบเมทริกซ์)
สำหรับ i:=1 ถึง N do
สำหรับ j:=1 ถึง M ทำ
อ่าน);
(การแสดงองค์ประกอบเมทริกซ์)
สำหรับ i:=1 ถึง N ให้เริ่มต้น
สำหรับ j:=1 ถึง M ทำ
เขียน(ก:4); (การต่อสู้แถวแรก)
Writeln (ย้ายไปที่แถวใหม่)
จบ;
จบ.

2) ส่วนของโปรแกรมสำหรับสร้างอาร์เรย์สองมิติผ่านตัวสร้างตัวเลขสุ่ม

เริ่ม
สุ่ม; (การเริ่มต้นเครื่องกำเนิดตัวเลขสุ่ม)
(การแนะนำองค์ประกอบเมทริกซ์)
สำหรับ i:=1 ถึง N do
สำหรับ j:=1 ถึง M ทำ
ตอบ:=สุ่ม(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

Massiv จะปฏิบัติตามหลักการ "งู" กฎการแทนที่: หากหมายเลขแถวเป็นหมายเลขที่ไม่ได้จับคู่ ดังนั้น A=(i-1)*m+j มิฉะนั้น A=i*m-j+1

โปรแกรม M1A;

n, m, i, j: จำนวนเต็ม;
เริ่ม
อ่าน(n,m);
สำหรับ i:=1 ถึง n จะเริ่มต้น
สำหรับ j:=1 ถึง m ทำ
เริ่ม
ถ้าฉัน mod 2 = 1 แล้ว
A=(i-1)*ม+เจ
อื่น
A=i*ม-เจ+1;
เขียน(ก:3);
จบ;
เขียน;
จบ;
อ่าน;
จบ.

ลองดูโปรแกรมด้วยวิธีอื่นเพื่อปฏิบัติตามกฎที่กำหนด:

โปรแกรม M1B;
var A:อาร์เรย์ของจำนวนเต็ม;
n, m, i, j: จำนวนเต็ม;
ค:จำนวนเต็ม;
เริ่ม
อ่าน(n,m);
ค:=1;
สำหรับ i:=1 ถึง n ทำ
เริ่ม
สำหรับ j:=1 ถึง m ทำ
เริ่ม
ก:=ค;
ถ้า (i mod 2 = 0) และ (j<>ม)แล้ว
ธ.ค. (ค)
อื่น
รวม(c);
เขียน(ก:3);
จบ;
ค:=ค+ม-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: จำนวนเต็ม;
ค:จำนวนเต็ม;
เริ่ม
อ่าน(n,m);
ค:=0;
สำหรับ i:=1 ถึง n ทำ
เริ่ม
สำหรับ j:=1 ถึง m ทำ
เริ่ม
ถ้า (i-1+j) mod 2 = 0 แล้ว
ตอบ:=0
อื่น
เริ่ม
รวม(c);
ก:=ค;
จบ;
เขียน(ก: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: จำนวนเต็ม;
ค:จำนวนเต็ม;
เริ่ม
อ่าน(n,m);
ค:=1;
สำหรับ j:=1 ถึง m ทำ
เริ่ม
สำหรับ i:=1 ถึง n ทำ
เริ่ม
ก:=ค;
ถ้า (j mod 2 = 0) และ (i<>น)แล้ว
ธ.ค. (ค)
อื่น
รวม(c);
จบ;
ค:=ค+n-1;
จบ;
สำหรับ i:=1 ถึง n ทำ
เริ่ม
สำหรับ j:=1 ถึง m ทำ
เขียน(ก: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: จำนวนเต็ม;

เริ่ม
ค:=1;
อ่าน(m);
สำหรับ j:=1 ถึง m ทำ
เริ่ม
ฉัน:=ค;
ง:=1;
ทำซ้ำ
ก:=ง;
Inc(ฉัน);
ถ้าฉัน>m แล้ว
ฉัน:=1;
รวม(ง);
จนกระทั่ง i=c;
ธ.ค.(ค);
ถ้าค<= 0 then
ค:=mc;
จบ;
สำหรับ i:=1 ถึง m ทำ
เริ่ม
สำหรับ j:=1 ถึง m ทำ
เขียน(ก: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:อาร์เรย์ของจำนวนเต็ม;
เริ่ม
อ่าน(m);
สำหรับ i:=1 ถึง m ทำ
เริ่ม
สำหรับ j:=1 ถึง m ทำ
เริ่ม
ถ้า (i=j) หรือ (m-i+1=j) แล้ว
ตอบ:=1
อื่น
ก:=0;
เขียน(ก: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 หน่วย

Malyunok 1 - Masivi ใน C++

โปรดทราบว่าดัชนีสูงสุดของอาร์เรย์มิติเดียว กมีค่ามากกว่า 15 แต่ขนาดของอาเรย์คือ 16 ตัวกลาง เนื่องจากการกำหนดหมายเลขของตัวกลางของอาเรย์จะเริ่มต้นจาก 0 เสมอ ดัชนีของตัวกลางเป็นตัวเลขที่ไม่รู้จักโดยสิ้นเชิงซึ่งสามารถใช้เพื่อคำนวณจุดศูนย์กลางผิวหนังของ อาร์เรย์และตา nuvati be-yaki dii เหนือเธอ (ตรงกลาง)

//ไวยากรณ์สำหรับการล้างอาร์เรย์หนึ่งมิติ C++: /*ประเภทข้อมูล*/ /*ชื่อของอาร์เรย์หนึ่งมิติ*/; // ก้นของอาร์เรย์หนึ่งมิติที่น่าทึ่งซึ่งแสดงโดยทารก 1: int a;

เด, จำนวนเต็มจำนวนเต็ม;

A - ชื่อของอาร์เรย์มิติเดียว
16 - ขนาดของอาร์เรย์หนึ่งมิติ 16 ตรงกลาง

ทันทีหลังจากชื่อของอาร์เรย์ จะมีแขนสี่เหลี่ยมซึ่งมีการตั้งค่าขนาดของอาร์เรย์หนึ่งมิติ และอาร์เรย์จะถูกแบ่งเพื่อแก้ไขการเปลี่ยนแปลง

// อีกวิธีหนึ่งในการลดอาร์เรย์มิติเดียว int mas, a;

มีการประกาศอาร์เรย์ mas สองมิติที่มีขนาด 10 และ 16 ต่อบรรทัด นอกจากนี้ ในวิธีนี้ อาเรย์ทั้งหมดจำเป็นต้องมีข้อมูลประเภทใหม่ int - int

// อาร์เรย์สามารถเริ่มต้นได้เมื่อว่างเปล่า: int a = (5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); //การเริ่มต้นอาร์เรย์มิติเดียว

การเริ่มต้นของอาร์เรย์หนึ่งมิติจะแสดงที่แขนโค้งหลังเครื่องหมาย หนึ่งองค์ประกอบผิวหนังของเทือกเขามีความเข้มแข็งขึ้นที่อาการโคม่าด้านหน้า

Int=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); //เตรียมใช้งานอาร์เรย์โดยไม่ระบุขนาดของอาร์เรย์

เมื่อคอมไพเลอร์กำหนดขนาดของอาร์เรย์หนึ่งมิติเอง ไม่จำเป็นต้องระบุขนาดของอาเรย์เพื่อการเริ่มต้นเท่านั้น แต่ในกรณีฉุกเฉิน อาเรย์จะต้องระบุขนาดของอาเรย์ มาพัฒนาโปรแกรมอย่างง่ายสำหรับการประมวลผลอาร์เรย์หนึ่งมิติกันดีกว่า

// array.cpp: กำหนดจุดเริ่มต้นสำหรับโปรแกรมคอนโซล #รวม "stdafx.h" #รวม << "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; }

// รหัส รหัส::บล็อก

// รหัส Dev-C++

// array.cpp: กำหนดจุดเริ่มต้นสำหรับโปรแกรมคอนโซล #รวม ใช้เนมสเปซมาตรฐาน; 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 loop มีเครื่องหมายลบ จะไม่มีแฟรกเมนต์ของดัชนีที่สิบหกในอาร์เรย์อาร์เรย์หนึ่งมิติ array1 เนื่องจากการกำหนดหมายเลขของตรงกลางเริ่มต้นจากศูนย์ ดังนั้นอาร์เรย์จึงมี 16 องค์ประกอบ ในวงจรสำหรับตัวดำเนินการ cout มีองค์ประกอบอื่นๆ ของอาร์เรย์หนึ่งมิติ (มี 2 องค์ประกอบเล็กๆ)

กำลังประมวลผลดัชนี Massiva องค์ประกอบ 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 กดปุ่มอะไรก็ได้ - -

Malyunok 2 - Masivi ใน C++

มาสร้างโปรแกรมอื่นเพื่อประมวลผลอาร์เรย์ C++ มิติเดียวกัน โปรแกรมจะต้องอ่านตัวเลขที่ป้อนสิบตัวจากแป้นพิมพ์ตามลำดับ ตัวเลขที่ป้อนทั้งหมดจะถูกสรุปผลและผลลัพธ์จะแสดงบนหน้าจอ

// array_sum.cpp: กำหนดจุดเริ่มต้นสำหรับโปรแกรมคอนโซล #รวม "stdafx.h" #รวม << "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; }

// รหัส รหัส::บล็อก

// รหัส Dev-C++

// array_sum.cpp: กำหนดจุดเริ่มต้นสำหรับโปรแกรมคอนโซล #รวม ใช้เนมสเปซมาตรฐาน; int main (int argc, char * argv) ( int array1; // อาร์เรย์ว่างทั้งหมด<< "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 วงแรกจะเติมอาร์เรย์หนึ่งมิติด้วยตัวเลขที่ป้อนจากคีย์บอร์ด แถวที่ 12 - 13- ตัวแปรตัวนับใช้สำหรับการเข้าถึงองค์ประกอบของอาร์เรย์อาร์เรย์มิติเดียวกันตามลำดับ1 โดยเริ่มจากดัชนี 0 ถึง 9 รวม อีกอันสำหรับลูปแสดงอาร์เรย์ขององค์ประกอบบนหน้าจอ แถวที่ 15 - 16- วงที่สามสำหรับการอ่านองค์ประกอบของอาร์เรย์หนึ่งมิติตามลำดับและหาผลรวม ผลรวมจะสะสมอยู่ในผลรวมของตัวแปร แถวที่ 17 - 18- ผลลัพธ์ของโปรแกรมหุ่นยนต์คือการประหลาดใจกับลูกน้อย 3

ป้อนองค์ประกอบมวล: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) รวม = 45 หากต้องการดำเนินการต่อ ให้กดปุ่มใดก็ได้ - -

Malyunok 3 - Masivi ใน C++

ขั้นแรก ให้ป้อนตัวเลขทั้ง 10 ตัวตามลำดับ หลังจากนั้นจึงแสดงอาร์เรย์หนึ่งมิติ และเพิ่มผลรวมของตัวเลขลงในอาร์เรย์

อาร์เรย์สองโลก C ++

เราได้เห็นเทือกเขาโลกเดียวซึ่งเราสามารถล้อมรอบไปได้ไกลแค่ไหน เป็นไปได้ว่าคุณจะต้องประมวลผลข้อมูลจากตาราง ตารางมีสองลักษณะ: จำนวนแถวและจำนวนคอลัมน์ นอกจากนี้ในอาร์เรย์สองมิติ นอกเหนือจากจำนวนองค์ประกอบในอาร์เรย์แล้ว ยังมีลักษณะเฉพาะ เช่น จำนวนแถวและจำนวนคอลัมน์ในอาร์เรย์สองมิติ เมื่อมองเห็นแล้วจะมีอาเรย์สองโลก - ตารางหลักที่มีแถวและคอลัมน์ ที่จริงแล้ว อาร์เรย์สองมิติคืออาร์เรย์หนึ่งมิติของอาร์เรย์หนึ่งมิติ โครงสร้างของอาร์เรย์สองมิติที่มีขนาด a ขนาด m คูณ n แสดงไว้ด้านล่าง (ส่วนที่ 4)

Malyunok 4 - Masivi ใน C++

de, m - จำนวนแถวของอาร์เรย์สองโลก
n - จำนวนผู้คนในเทือกเขาสองโลก
m * n – จำนวนองค์ประกอบในอาร์เรย์

// ไวยากรณ์สำหรับการล้างอาร์เรย์สองมิติ /*data type*/ /*name of array*/;

ในอาร์เรย์สองมิติที่หูหนวก เช่นเดียวกับในอาร์เรย์หนึ่งมิติที่หูหนวก จำเป็นต้องป้อน:

• ประเภทข้อมูล;
• ฉันตัวใหญ่.

ดังนั้น แขนกลตัวแรกจึงระบุจำนวนแถวของอาร์เรย์สองมิติ ในขณะที่แขนสี่เหลี่ยมอื่นๆ ระบุจำนวนแถวของอาร์เรย์สองมิติ อาร์เรย์สองมิติถูกแบ่งย่อยด้วยแขนสี่เหลี่ยมอีกคู่หนึ่งอย่างเห็นได้ชัด มาดูก้นเทือกเขาสองโลกที่น่าตะลึงกัน บางทีเราจำเป็นต้องประเมินอาร์เรย์สองมิติที่มีองค์ประกอบมากเท่ากับ 15 อาร์เรย์สองมิตินี้สามารถมีสามแถวและห้าคอลัมน์ หรือห้าแถวและสามคอลัมน์

// ก้นของอาร์เรย์ dvomirny ที่น่าตะลึง: 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)

Malyunok 5 - Masivi ใน C++

ในใจกลางผิวหนังของเทือกเขาไบเลเยอร์ กค่าจะแสดง ในกล่องขวาล่างจะแสดงที่อยู่ของบริษัท ที่อยู่ตรงกลางของอาร์เรย์สองมิติคือชื่อของอาร์เรย์ หมายเลขแถว และหมายเลขคอลัมน์

เราได้พัฒนาโปรแกรมที่ซับซ้อนมากสำหรับการประมวลผลเทือกเขาสองมิติที่เรียกว่า "เขาวงกต" เขาวงกตมีสิ่งเร้าตามอาร์เรย์สองมิติ ขนาดของเขาวงกตจะถูกเลือกตามดุลยพินิจของเจ้าหน้าที่

// array2.cpp: กำหนดจุดเริ่มต้นสำหรับโปรแกรมคอนโซล #รวม "stdafx.h" #รวม < 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; }

// รหัส รหัส::บล็อก

// รหัส Dev-C++

// array2.cpp: กำหนดจุดเริ่มต้นสำหรับโปรแกรมคอนโซล #รวม ใช้เนมสเปซมาตรฐาน; int main(int argc, char* argv) ( // 1- "กำแพงของเขาวงกต" // 2- "เส้นทางที่ถูกต้อง, ออกจากเขาวงกต" // 0- "เส้นทาง hibny" int mas = ((1, 2,1 ,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,1,0,0,1,2,1,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,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,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,2,2,2,2,2,2,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,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,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,2,1,0,0,1,2,1,1,1,1,2,2,2 ,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,2,2,2,2,2,2,2,2,2,2,2 ,), (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,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 การเริ่มต้นอาร์เรย์ทำได้ด้วยตนเอง เพียงเพื่อลดความซับซ้อนของ โปรแกรม. เนื่องจากโปรแกรมกำลังประมวลผลอาร์เรย์สองมิติ จึงต้องใช้สองรอบในการสลับระหว่างองค์ประกอบของอาร์เรย์สองมิติ ลูปแรกประกอบด้วยการสลับระหว่างแถวของอาร์เรย์สองมิติ แฟรกเมนต์ของแถวในอาร์เรย์สองมิติคือ 33 จากนั้น change-doctor i จะเพิ่มขึ้นจาก 0 เป็น 33 แถวที่ 46- ตรงกลางของลูปแรกจะมี for loop ซึ่งสลับระหว่างองค์ประกอบของแถวของอาร์เรย์สองมิติ ในอีกลูปหนึ่งตรงกลางจะมีการดำเนินการแปลงประเภทข้อมูลแบบเอกเทศ - static_cast<>() ซึ่งเป็นอีกสัญลักษณ์หนึ่งที่มีหมายเลข 176 การดำเนินการแปลงชนิดข้อมูลจะทำซ้ำเพื่อเพิ่มความกว้างของเขาวงกต ผลลัพธ์ของโปรแกรมหุ่นยนต์ (div. รูปที่ 6)

Malyunok 6 - Masivi ในภาษา C++

มาซิฟ (อีกด้วย อาร์เรย์ดัชนี, ไอโหนด โต๊ะ, แถว) - การตั้งชื่อ (การสั่งซื้อ) ชุดของการเปลี่ยนแปลง (ข้อมูล) ประเภทเดียวกันที่ดึงมาจากหน่วยความจำทีละรายการการเข้าถึงซึ่งขึ้นอยู่กับ ดัชนี- ด้วยวิธีที่ง่ายที่สุด เทือกเขาทำงานอย่างต่อเนื่องและบันทึกหน่วยข้อมูลประเภทเดียวกัน

ดัชนี w masiwu - หมายเลข tse ทั้งหมดซึ่งระบุองค์ประกอบอาร์เรย์เฉพาะ

จำนวนดัชนีในอาร์เรย์ที่จะค้นหาอาจแตกต่างกันไป อาร์เรย์ที่มีดัชนีเดียวเรียกว่า มิติเดียว, สอง - สองมิติฯลฯ

มิติเดียวอาร์เรย์ไม่ตรงกันอย่างเคร่งครัด เวกเตอร์ ในวิชาคณิตศาสตร์ สองมิติ - เมทริกซ์ - ส่วนใหญ่แล้วเทือกเขาจะหยุดนิ่ง หนึ่งหรืออย่างอื่น สองดัชนีบางครั้งสามดัชนีก็ยิ่งพบได้ยากด้วยซ้ำ

อาร์เรย์มีคำอธิบายดังต่อไปนี้:

ประเภทของดัชนีที่พบบ่อยที่สุดคือช่วง เช่น:

ดีกว่าที่จะอธิบาย อาร์เรย์ B,พัฒนาด้วยอะไร 5 องค์ประกอบและสัญลักษณ์ อาร์เรย์อาร์,พัฒนาด้วยอะไร 34 องค์ประกอบ สำหรับมาซิวู ยู 5 * 6 = จะเห็นหน่วยความจำ 30 ไบต์ (เนื่องจากอยู่ภายใต้ประเภทที่เปลี่ยนแปลงได้ จริงปรากฏขึ้น 6 ไบต์ของหน่วยความจำ) สำหรับอาร์เรย์ R - 1*34=34 ไบต์ของหน่วยความจำ (ภายใต้ประเภทที่เปลี่ยนแปลงได้ ถ่าน - 1 ไบต์) ประเภทพื้นฐานองค์ประกอบของอาร์เรย์สามารถจัดโครงสร้างในลักษณะใด ๆ เช่น หรือจัดโครงสร้าง ยกเว้นไฟล์! เทือกเขาสามารถเปล่งเสียงได้ใน Wikoristanny วลาสนีพิมพ์:

วงจร เรียกได้ว่าเป็นลำดับคำสั่งที่กระชับมาก จัดระเบียบไม่ทางใดก็ทางหนึ่ง (เช่น เพื่อช่วยในการเปลี่ยนแปลงทางจิต)

เรียกว่าวัฏจักรเดียวของร่างกาย การวนซ้ำ. วิราซซึ่งหมายความว่าคุณจะถูกหลอกในครั้งต่อไป การวนซ้ำ, หรือ วงจรสิ้นสุด - tse umova ทางออกไค จุดสิ้นสุดของวงจร(นอกจากนี้ยังเป็นไปได้และความต่อเนื่องทางปัญญา) หน่วยความจำที่บันทึกหมายเลขบรรทัดของการวนซ้ำเรียกว่า การทำซ้ำของผู้รักษาวงจรนั้นง่าย หมอวงจร วงจรไม่จำเป็นต้องแก้แค้น หมอ.

ความโกรธของวัฏจักร:

- วงจร กับแพทย์ซึ่งการกระทำที่เปลี่ยนแปลงได้จะเปลี่ยนค่าจากค่าที่ระบุ ซังมูลค่าสูงถึง คินต์เซโวโกความหมายของการกระทำ จระเข้และค่าผิวของวงจรการเปลี่ยนแปลงของร่างกายจะครบเพียงครั้งเดียว ดำเนินการโดยผู้ปฏิบัติงาน สำหรับ

ก้น บันทึก เทือกเขา:

และเพื่อให้คุณจำได้ สองมิติอาร์เรย์:

- วงจร ด้วยการเปลี่ยนใจซึ่งกำลังสรุปในขณะที่งานที่แท้จริงของจิตใจถูกแสดงต่อหน้าซังของเขา ดำเนินการโดยผู้ปฏิบัติงาน ในขณะที่.

- วงจร กับโพสตูโมว่าโดยจิตใจจะถูกตรวจสอบอีกครั้งหลังจากร่างกายครบวงจรแล้วจึงสร้างร่างกายใหม่อย่างน้อยหนึ่งครั้ง ใน mov Pascal วงจรนี้ดำเนินการโดยผู้ปฏิบัติงาน ทำซ้ำ...จนกระทั่ง

การดำเนินการครั้งแรก ข้ามการทำซ้ำหากเป็นการวนซ้ำเธรด วงจรจำเป็นต้องข้ามคำสั่งทั้งหมดไปจนกว่าจะสิ้นสุดการวนซ้ำที่เสร็จสมบูรณ์ ในกรณีนี้ วงจรนั้นไม่ได้ถูกตำหนิสำหรับการหยุดชะงัก แต่สำหรับการต่อเนื่อง แต่ผลลัพธ์จะถูกตำหนิสำหรับอันดับเริ่มต้น ดำเนินการโดยผู้ปฏิบัติงาน ดำเนินการต่อ.

นอกจากนี้ในรอบต่างๆ คำสั่งมักจะได้รับชัยชนะ ออกจากลูปก่อนสตริงตัวอย่างเช่น ถ้าเมื่อร่างกายเสร็จสิ้น วงจรแสดงการหยุดพัก หลังจากทำงานต่อไป วงจรนั้นจะไม่เป็นอันตรายต่อประสาทสัมผัส ดำเนินการโดยผู้ปฏิบัติงาน ออกหรืออย่างอื่น หยุดพัก.

หันไปหาซังหรือมากกว่าซัง ก้น. เราจำเป็นต้องค้นหาว่าจะทำอย่างไรกับซอฟต์แวร์ชิ้นเล็กๆ นี้:

มาจากสิ่งที่กล่าวไว้ว่า vikorystvovany เทือกเขาสองโลก ก- นี่คือขนาดเมทริกซ์ n x n- วงจรกำลังได้รับชัยชนะ กับแพทย์จากหนึ่งถึง nอาจมีการระบุไว้ก่อนหน้านี้

กลางรอบ: การเปลี่ยนแปลง ชม.เก็บค่าของอาร์เรย์สองมิติพร้อมดัชนี (ค:=ก), ตอนนี้ - จากนั้นที่ตำแหน่งขององค์ประกอบนี้ในอาร์เรย์จะมีการป้อนค่าขององค์ประกอบของอาร์เรย์เดียวกันรวมทั้งดัชนีด้วย (ก:=ก) หรือเมื่อใด ก:=1 (ก:=ก- โตโต้ องค์ประกอบของแถวแรกรวมอยู่ด้วย เพราะ ตัวเลขแรกในดัชนีระบุหมายเลขแถวในเมทริกซ์ - [ ฉัน j) และอีกอันสำหรับหมายเลขสถานี - . สุดท้าย ณ ตำแหน่งองค์ประกอบที่มีดัชนี จะถูกป้อนเป็นค่าหลักขององค์ประกอบอาร์เรย์ กด้วยดัชนี เหมือนเราเอามันมาปิดท้ายมื้ออาหาร ชม. (ก:=ค).

และทุกครั้งที่วนซ้ำวงจรความหมายของเรา ฉันเพิ่มขึ้นโดย หนึ่ง- ง่ายสำหรับจระเข้ เริ่มตอนนี้ :

ชั่วโมง:=ก ก:=ก ก:=ค

ชั่วโมง:=ก ก:=ก ก:=ค

ชั่วโมง:=ก ก:=ก ก:=ค

ใช่ nครั้งก่อน - โตโต้ ค่าของเส้นทแยงมุมของเมทริกซ์จะตรงไปทางขวาและลง ฉัน องค์ประกอบของการเปลี่ยนแปลงในแนวทแยงนี้ด้วยค่าขององค์ประกอบ อันดับแรก ท่อระบายน้ำเมทริกซ์(หรือ เค-แถวนั้น) ดังนั้นคำตอบที่ถูกต้องคือ- ตัวเลือก 3: อัลกอริทึมนี้เปลี่ยนสถานที่ องค์ประกอบแนวทแยงเคคอลัมน์ที่ 3 ของตาราง.

ปาสคาลถือว่าอาร์เรย์สองมิติเป็นอาร์เรย์หนึ่งมิติ ประเภทขององค์ประกอบที่เป็นอาร์เรย์ด้วย (อาร์เรย์ของอาร์เรย์) ตำแหน่งขององค์ประกอบในอาร์เรย์สองมิติของ Pascal อธิบายด้วยดัชนีสองตัว สามารถนำเสนอในรูปแบบของตารางสี่เหลี่ยมหรือเมทริกซ์

ลองดูอาร์เรย์สองมิติของ Pascal ที่มีขนาด 3*3 จากนั้นจะมีสามแถวในนั้น และสามองค์ประกอบในแต่ละแถว:

องค์ประกอบหนังจะมีหมายเลขของตัวเอง เช่นเดียวกับในอาร์เรย์ชั้นเดียว แต่ตัวเลขนั้นก็ประกอบด้วยตัวเลขสองตัวเช่นกัน นั่นคือหมายเลขของแถวที่มีองค์ประกอบนั้นอยู่และหมายเลขนั้นถูกนำมารวมกัน ด้วยวิธีนี้ จำนวนองค์ประกอบจะถูกระบุโดยคานประตูของแถวและคอลัมน์ ตัวอย่างเช่น 21 คือองค์ประกอบที่อยู่ในแถวอื่นและในคอลัมน์แรก

คำอธิบายอาเรย์สองโลกของปาสคาล

มีหลายวิธีในการระเบิดอาร์เรย์สองมิติของ Pascal

เราสามารถอธิบายอาร์เรย์หนึ่งมิติได้แล้วซึ่งองค์ประกอบสามารถเป็นประเภทใดก็ได้ดังนั้นองค์ประกอบจึงสามารถเป็นอาร์เรย์ได้ ลองมาดูคำอธิบายประเภทต่างๆดังต่อไปนี้:

พิมพ์
เวกเตอร์ = อาร์เรย์ของ<тип_элементов>;
เมทริกซ์ = อาร์เรย์ของเวกเตอร์;
วาร์ ม: เมทริกซ์;

เราตั้งชื่ออาร์เรย์สองมิติของ Pascal ว่า m ซึ่งประกอบด้วย 10 แถว แต่ละแถวมี 5 แถว ในกรณีนี้ คุณสามารถเพิ่ม m [i] ให้กับสกินแถวที่ i และ m [i, j] สามารถนำไปใช้กับอิลิเมนต์สกิน j-th ที่อยู่ตรงกลางของแถวที่ i

ค่าของประเภทสำหรับอาร์เรย์ Pascal สองมิติสามารถระบุได้ในแถวเดียว:

พิมพ์
Matrix = อาร์เรย์ของอาร์เรย์ของ< тип элементов >;
หรือง่ายกว่านั้น:
พิมพ์
เมทริกซ์ = อาร์เรย์ของ<тип элементов>;

การสะสมองค์ประกอบของอาร์เรย์สองมิติจะมีลักษณะดังนี้: M [i, j] ซึ่งหมายความว่าเราต้องการลบองค์ประกอบที่เพิ่มในแถวที่ i และคอลัมน์ที่ j ที่นี่เราไม่สามารถสับสนระหว่างแถวกับเคาน์เตอร์ได้ เพราะเราสามารถลดสัตว์ร้ายให้เป็นองค์ประกอบที่นึกไม่ถึงได้อีกครั้ง ตัวอย่างเช่น การขึ้นไปที่องค์ประกอบ M สามารถสร้างรูปแบบที่ถูกต้องของรายการ หรือคุณสามารถเรียกคำขอจากโปรแกรมหุ่นยนต์ได้

การดำเนินการพื้นฐานกับอาร์เรย์สองมิติของ Pascal

ทุกสิ่งที่กล่าวถึงเกี่ยวกับการดำเนินการหลักกับอาร์เรย์หนึ่งมิติก็เป็นจริงสำหรับเมทริกซ์เช่นกัน การดำเนินการเดียวที่สามารถทำได้กับเมทริกซ์ประเภทเดียวกันโดยรวมคือราคา ดังนั้น เมื่อโปรแกรมอธิบายเมทริกซ์สองตัวที่เป็นชนิดเดียวกัน ตัวอย่างเช่น

พิมพ์
เมทริกซ์ = อาร์เรย์ของจำนวนเต็ม;
var
ก, ข: เมทริกซ์;

ในระหว่างการแก้ไขโปรแกรม คุณสามารถกำหนดเมทริกซ์ได้ กค่าเมทริกซ์ ข(ก: = ข) การดำเนินการอื่นๆ ทั้งหมดจะถูกเพิ่มทีละองค์ประกอบ และการดำเนินการที่ถูกต้องทั้งหมดสามารถเพิ่มลงในองค์ประกอบได้ ตามที่กำหนดไว้สำหรับประเภทขององค์ประกอบอาร์เรย์เหล่านี้ ซึ่งหมายความว่าหากอาร์เรย์ประกอบด้วยจำนวนเต็มคุณสามารถดำเนินการสำหรับจำนวนเต็มในองค์ประกอบได้หากอาร์เรย์ประกอบด้วยสัญลักษณ์จากนั้นคุณสามารถดำเนินการที่มีไว้สำหรับการทำงานกับสัญลักษณ์ก่อนหน้านั้นได้

บทนำเกี่ยวกับอาเรย์สองโลกของปาสคาล

เพื่อแนะนำองค์ประกอบของอาร์เรย์มิติเดียวตามลำดับ เราใช้ for loop ซึ่งเราเปลี่ยนค่าดัชนีจาก 1 เป็นส่วนที่เหลือ ตำแหน่งขององค์ประกอบในอาร์เรย์ Pascal สองมิติจะถูกระบุด้วยดัชนีสองตัว ได้แก่ หมายเลขแถวและหมายเลขคอลัมน์ ซึ่งหมายความว่าเราจะต้องเปลี่ยนหมายเลขแถวจาก 1 เป็นแถวที่เหลืออย่างสม่ำเสมอและในแถวสกินจะเรียงลำดับองค์ประกอบของแถวจาก 1 เป็นแถวที่เหลือ ตอนนี้ เราต้องการ for for loop สองอัน โดยอันหนึ่งซ้อนกันอยู่ภายในอีกอัน

มาดูตัวอย่างการป้อนอาเรย์สองมิติของ Pascal จากคีย์บอร์ด:

พิมพ์
เมทริกซ์ = อาร์เรย์ของจำนวนเต็ม;
var
ก: เมทริกซ์;
ฉัน, เจ: จำนวนเต็ม; (เทือกเขาดัชนี)
เริ่ม
สำหรับ i:=1 ถึง 5 do (วนซ้ำเพื่อวนซ้ำทุกแถว)
readln(a[i, j]); (ป้อนองค์ประกอบที่อยู่ในแถวที่ i และคอลัมน์ที่ j จากแป้นพิมพ์)

เทือกเขาสองโลกของ Pascal สามารถจัดเก็บด้วยวิธีง่ายๆ ใช้ฟังก์ชันสุ่ม (N) และกำหนดค่าของไวรัสเฉพาะให้กับองค์ประกอบสกินของเมทริกซ์ วิธีการเติมอาเรย์สองมิติของ Pascal นั้นถูกเลือกขึ้นอยู่กับงานที่ทำอยู่ แต่ในกรณีใด ๆ ค่าขององค์ประกอบสกินในแถวสกินและชั้นผิวหนังจะต้องถูกตำหนิ

นำเรื่องราวสองโลกของปาสคาลมาสู่จอภาพยนตร์

การได้มาขององค์ประกอบของอาเรย์สองมิติของ Pascal ก็ดำเนินไปตามลำดับเช่นกัน จำเป็นต้องยืดองค์ประกอบของแถวสกินและคอลัมน์สกิน ใครอยากมีองค์ประกอบแบบแถวเดียวจับมือกันแล้ว เรียงกันเป็นแถวและองค์ประกอบเครื่องนอนก็ถูกจัดเรียงทีละชิ้น สำหรับสิ่งที่ต้องทำ นี่คือลำดับของการดำเนินการ (ลองดูที่ส่วนของโปรแกรมสำหรับอาร์เรย์ ตามที่อธิบายไว้ในตัวอย่างก่อนหน้านี้):

สำหรับ i:=1 ถึง 5 do (วนซ้ำเพื่อวนซ้ำทุกแถว)
เริ่ม
สำหรับ j:=1 ถึง 10 do (เรียงลำดับตามองค์ประกอบทั้งหมดของแถวตามสลีปเปอร์)
เขียน (a[i, j]: 4); (องค์ประกอบอื่นๆ ควรอยู่ในแถวที่ i-th ของเมทริกซ์ในแถวหน้าจอเดียว โดยป้อน 4 ตำแหน่งเพื่อแสดงองค์ประกอบสกิน)
เขียน; (ขั้นแรกให้เปลี่ยนหมายเลขแถวในเมทริกซ์ คุณต้องเลื่อนเคอร์เซอร์ไปที่จุดเริ่มต้นของแถวหน้าจอใหม่)
จบ;

เคารพ ( มันสำคัญ!): บ่อยครั้ง โปรแกรมของนักเรียนประสบปัญหาเมื่ออินพุตจากคีย์บอร์ดหรือการแสดงผลบนหน้าจอถูกบังคับให้เกิดขึ้นในลำดับต่อไปนี้: readln(a), writeln(a), de ก- นี่เป็นสิ่งสำคัญสำหรับประเภทเทือกเขา ในกรณีนี้ พวกเขาแปลกใจกับข้อมูลของคอมไพเลอร์ว่าไม่สามารถบันทึกหรือบังคับใช้การเปลี่ยนแปลงประเภทนี้ได้ บางทีคุณอาจเข้าใจว่าทำไมคุณไม่สามารถหารายได้ได้หากคุณเห็น N kuklov ยืนอยู่เป็นแถวและในมือของคุณมีกาต้มน้ำอยู่ คุณสามารถทำตามคำสั่ง “เทน้ำ” และเติมน้ำให้เต็มกองพร้อมกันได้หรือไม่? หากไม่เปียก ก็ต้องเทกระเจี๊ยบเขียวลงในแจ็กเก็ตหนัง การเติมและการแสดงองค์ประกอบอาร์เรย์จะต้องดำเนินการตามลำดับและองค์ประกอบต่อองค์ประกอบเนื่องจาก ในหน่วยความจำ EOM องค์ประกอบของอาเรย์จะเติบโตตามลำดับ

เป็นการรำลึกถึงอาร์เรย์สองโลกของ Pascal ในความทรงจำ

องค์ประกอบของอาร์เรย์นามธรรมในหน่วยความจำของเครื่องจะถูกขยายทางกายภาพตามลำดับพร้อมกับคำอธิบาย ในกรณีนี้ องค์ประกอบสกินใช้ไบต์จำนวนมากในหน่วยความจำ ซึ่งระบุขนาดขององค์ประกอบ ตัวอย่างเช่น หากอาร์เรย์ประกอบด้วยองค์ประกอบประเภทจำนวนเต็ม แต่ละองค์ประกอบจะใช้พื้นที่สองไบต์ และอาร์เรย์ทั้งหมดใช้ S 2 ไบต์ โดยที่ S คือจำนวนองค์ประกอบในอาร์เรย์

คุณจะไปเทือกเขากี่แห่ง แล้วไปเทือกเขาอะไร เมทริกซ์? แน่นอน: S i^S j โดยที่ S i คือจำนวนแถว และ S j คือจำนวนองค์ประกอบในแต่ละแถว ตัวอย่างเช่นสำหรับประเภทขนาดใหญ่

Matrix = อาร์เรย์ของจำนวนเต็ม;

ต้องใช้หน่วยความจำ 12 ไบต์

เราจะจำองค์ประกอบของเทือกเขานี้ได้อย่างไร? มาดูโครงร่างของเมทริกซ์ประเภทอาเรย์ M ในหน่วยความจำกัน

ภายใต้องค์ประกอบสกินจำนวนเต็มประเภท M มีช่องหน่วยความจำสองช่อง ตำแหน่งของความทรงจำคือ “จากล่างขึ้นบน” องค์ประกอบต่างๆ จะถูกวางตามลำดับการเปลี่ยนแปลงดัชนี ซึ่งแสดงให้เห็นโครงร่างของลูปที่ซ้อนกัน: แถวแรกจะถูกวางไว้ก่อน จากนั้นแถวที่สอง แถวที่สาม... ตรงกลางแถว องค์ประกอบต่างๆ จะเรียงตามลำดับ: แถวแรก , อื่น ๆ ฯลฯ

ดังที่เราทราบ การเข้าถึงการเปลี่ยนแปลงใด ๆ ทำได้โดยการป้อนที่อยู่ตรงกลางหน่วยความจำที่บันทึกการเปลี่ยนแปลงเท่านั้น หน่วยความจำเฉพาะสามารถมองเห็นการเปลี่ยนแปลงได้เมื่อใช้โดยโปรแกรม เพื่อให้เกิดการติดต่อร่วมกันระหว่างหน่วยความจำที่เปลี่ยนแปลงได้และที่อยู่ของคอมพิวเตอร์ หากเราตั้งชื่อการเปลี่ยนแปลงเป็นอาร์เรย์ โปรแกรมจะรู้ที่อยู่ของซังของอาร์เรย์ จากนั้นจึงเป็นองค์ประกอบแรก การเข้าถึงองค์ประกอบอื่น ๆ ทั้งหมดของอาร์เรย์เกิดขึ้นได้อย่างไร? เมื่อเข้าถึงหน่วยความจำที่เก็บองค์ประกอบอาร์เรย์สองมิติไว้จริง ระบบจะคำนวณที่อยู่โดยใช้สูตร:

Addr + SizeElem * Cols * (I -1) + SizeElem * (J -1)

de Addr - ที่อยู่รูทจริงซึ่งมีอาร์เรย์อยู่ในหน่วยความจำ I, J – ดัชนีองค์ประกอบในอาร์เรย์สองมิติ SizeElem – ขนาดขององค์ประกอบอาร์เรย์ (เช่น สองไบต์สำหรับองค์ประกอบประเภทจำนวนเต็ม) Cols – จำนวนองค์ประกอบในแถว

Viraz SizeElem * Cols * (I -1) + SizeElem * (J -1) เรียกว่าการกระจัดของเทือกเขาซัง

มีหน่วยความจำเท่าใดสำหรับอาเรย์?

เรามาดูกันไม่มากนักว่าจำนวนหน่วยความจำที่มองเห็นได้ภายใต้อาเรย์ (ซึ่งเราได้กล่าวไว้ในหัวข้อที่แล้ว) แต่อยู่ที่ขนาดสูงสุดที่อนุญาตของอาเรย์ ซึ่งรับผิดชอบในการดูแลหน่วยความจำ

สำหรับโปรแกรมโรบอติก หน่วยความจำจะถูกมองเห็นในส่วนละ 64 KB และอย่างน้อยหนึ่งรายการจะถูกกำหนดให้เป็น ส่วนข้อมูล- แกนของส่วนนี้เป็นข้อมูลเดียวกับที่โปรแกรมประมวลผล แน่นอนว่าโปรแกรมไม่สามารถขยายได้มากกว่าหนึ่งครั้งในเซ็กเมนต์เดียว ดังนั้น เนื่องจากมีการเปลี่ยนแปลงเพียงครั้งเดียวในกลุ่ม จึงอธิบายว่าเป็นอาร์เรย์ และจึงไม่สามารถแยกข้อมูลเกิน 65536 ไบต์ได้ นอกเหนือจากอาเรย์ในส่วนข้อมูลแล้ว Ale อาจยังมีคำอธิบายของการเปลี่ยนแปลงอื่น ๆ ดังนั้นที่เก็บข้อมูลหน่วยความจำจริงซึ่งสามารถมองเห็นได้ภายใต้อาเรย์จึงอยู่ภายใต้สูตร: 65536-S โดยที่ S - ที่เก็บข้อมูลหน่วยความจำ นิมิตภายใต้เราก็ยังเปลี่ยนแปลงได้

คุณจำเป็นต้องรู้อะไรบ้าง? เพื่อไม่ให้แปลกใจเมื่อคอมไพล์นักแปลจะแสดงการแจ้งเตือนเกี่ยวกับการคอมไพล์อาร์เรย์ที่ยาวนานหากมีคำอธิบายในโปรแกรม (ถูกต้องในแง่ของไวยากรณ์):

พิมพ์ myArray = อาร์เรย์ของจำนวนเต็ม;

คุณรู้อยู่แล้วว่าเมื่อใช้จำนวนเต็มไบต์คู่ คุณสามารถอ่านอาร์เรย์ที่มีองค์ประกอบจำนวนมากได้ ซึ่งเท่ากับ 65536/2 –1=32767 และเป็นเพียงเพราะจะไม่มีการเปลี่ยนแปลงอื่นใดอีก กลุ่มมารดาที่มีความผิดในโลกสองกลุ่มมีขอบเขตระหว่างดัชนีที่เล็กกว่าด้วยซ้ำ

ใช้ปัญหาการแยกตัวจากอาร์เรย์สองมิติของ Pascal

ซาฟดันเนีย:ค้นหาจำนวนองค์ประกอบที่ไม่ใช่ศูนย์ของเมทริกซ์

การตัดสินใจ:

• สำหรับงานที่สำคัญที่สุด เราต้องการการเปลี่ยนแปลงต่อไปนี้: เมทริกซ์ซึ่งประกอบด้วยองค์ประกอบทั้งหมด ตัวอย่างเช่น P – การเพิ่มองค์ประกอบย่อยภายใต้ 0; I, J – ดัชนีอาร์เรย์; N, M – จำนวนแถวและคอลัมน์ในเมทริกซ์
• ข้อมูลอินพุตคือ N, M - ค่าจะถูกป้อนจากแป้นพิมพ์ เมทริกซ์ – การแนะนำเมทริกซ์สามารถจัดทำอย่างเป็นทางการเป็นขั้นตอนการเติมเมทริกซ์ด้วยคำสั่งพิเศษได้ สำหรับฟังก์ชัน Random() เพิ่มเติม
• ข้อมูลเอาต์พุตจะเป็นค่า P (ทึบ) ที่เปลี่ยนแปลงได้
• ในการตรวจสอบความถูกต้องของการแสดงผลของโปรแกรม คุณจะต้องแสดงเมทริกซ์บนหน้าจอ ซึ่งเราจะกำหนดขั้นตอนในการแสดงเมทริกซ์
• ความคืบหน้าของงาน:

เรามาหารือเกี่ยวกับการใช้งานโปรแกรมหลักเบื้องต้น การดำเนินการตามขั้นตอนจะมีการหารือในภายหลัง:

• ป้อนค่า N และ M;
• เราแนะนำอาร์เรย์สองมิติของ Pascal ซึ่งไปที่โพรซีเดอร์ vvod (a) โดยที่ a คือเมทริกซ์
• มาสร้างเมทริกซ์กัน ซึ่งเราไปที่ขั้นตอนการพิมพ์ (a)
• การเปลี่ยนแปลงค่าซัง Nadamo P =1;
• เราจะวนซ้ำตามลำดับในทุกแถว I จากตำแหน่งที่ 1 ถึง N สำหรับแถวสกิน เราจะวนซ้ำในคอลัมน์ J ทั้งหมดตั้งแต่ตำแหน่งที่ 1 ถึง M สำหรับองค์ประกอบสกินของเมทริกซ์นั้นสามารถตรวจสอบได้ทางจิตใจ: ij คืออะไร 0, tvir P จะถูกคูณด้วยองค์ประกอบ a ij (P = P * a ij);
• ค่าขององค์ประกอบที่ไม่ใช่ศูนย์เพิ่มเติมของเมทริกซ์จะแสดงบนหน้าจอ - P;

ตอนนี้เรามาพูดถึงขั้นตอนต่างๆ

เคารพ (นี้เป็นสิ่งสำคัญ!) พารามิเตอร์ขั้นตอนสามารถเปลี่ยนเป็นประเภทที่กำหนดได้ ซึ่งหมายความว่าในการส่งอาร์เรย์ไปยังขั้นตอนในฐานะพารามิเตอร์ ประเภทของอาร์เรย์จะขึ้นอยู่กับคำอธิบายด้านหลัง ตัวอย่างเช่น:

พิมพ์
Matrix = อาร์เรย์ของจำนวนเต็ม;
ไพรเมอร์ขั้นตอน (a: เมทริกซ์);
..............................

ให้เราหันไปใช้ขั้นตอนของเรา

ขั้นตอนการป้อนเมทริกซ์เรียกว่าพารามิเตอร์ vvod ของโพรซีเดอร์ - เมทริกซ์และด้วยเหตุนี้จึงถูกถ่ายโอนไปยังโปรแกรมหลักและจะต้องส่งพารามิเตอร์ต่อไป ส่วนหัวของกระบวนการของเราจึงมีลักษณะดังนี้:

ขั้นตอน vvod (var m: matrix);

เพื่อนำวงจรการแทรกของโพรซีเดอร์ไปใช้ เราจำเป็นต้องมีตัวเปลี่ยนเฉพาะที่ เช่น k และ h ได้มีการพูดคุยถึงอัลกอริทึมสำหรับการเติมเมทริกซ์แล้ว ดังนั้นเราจะไม่ทำซ้ำ

ขั้นตอนในการแสดงเมทริกซ์บนหน้าจอเรียกว่าการพิมพ์ พารามิเตอร์ของขั้นตอนคือเมทริกซ์ และในกรณีนี้พารามิเตอร์อินพุตจะถูกส่งไปตามค่าด้วย ชื่อของขั้นตอนนี้จะมีลักษณะดังนี้:

ขั้นตอนการพิมพ์ (m: เมทริกซ์);

และอีกครั้ง สำหรับการนำวงจรการลงทุนไปใช้ในระหว่างกระบวนการ เราจำเป็นต้องมีแพทย์เพิ่ม เรียกพวกเขาแบบนั้น - k และ h อัลกอริธึมสำหรับการแสดงเมทริกซ์บนหน้าจอได้รับการอธิบายไว้อย่างรวดเร็วยิ่งขึ้นในคำอธิบายนี้

โปรแกรมที่ผลิต;
พิมพ์
Matrix = อาร์เรย์ของจำนวนเต็ม;
วาร์
ตอบ: เมทริกซ์;
N, m, i, j: ไบต์;
ป: จำนวนเต็ม;
ขั้นตอน vvod (var m: matrix);
Var k, h: ไบต์;
เริ่ม
สำหรับ i:=1 สิ่งที่ต้องทำ (เปลี่ยน n สำหรับโพรซีเดอร์ซึ่งเป็นส่วนกลางและ "มองเห็นได้")
สำหรับ j:=1 ถึง m do (เปลี่ยน m สำหรับโพรซีเดอร์เป็นแบบโกลบอล ดังนั้นจึง "มองเห็นได้")
ม:= สุ่ม(10);
จบ;
ขั้นตอนการพิมพ์ (m: เมทริกซ์);
Var k, h: ไบต์;
เริ่ม
สำหรับ i:=1 ถึง n ทำ
เริ่ม
สำหรับ j:=1 ถึง m ทำ
เขียน(พ:4);
เขียน;
จบ;
จบ;
Begin (เริ่มโปรแกรมหลัก)
Writeln("ระบุขนาดเมทริกซ์:");
อ่าน(N, M);
วอด(ก);
พิมพ์(ก);
ป:=1;
สำหรับ i:=1 ถึง N do
สำหรับ j:=1 ถึง M ทำ
ถ้าก<>0 จากนั้น p:=p*a;
เขียน(p);
จบ.