บทเรียนภาษาปาสคาลครั้งสุดท้ายเขียนเมื่อวันที่ 7 มีนาคม ตอนที่เรากำลังศึกษาอยู่ วันนี้เราจะมาดูกันว่ามันคืออะไร อาร์เรย์สองมิติในภาษาปาสคาลอธิบายอย่างไรและคืออะไร รายละเอียดเพิ่มเติมด้านล่าง

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

อาร์เรย์สองมิติอธิบายได้อย่างไร?มีหลายวิธีในการเขียนอาร์เรย์สองมิติ ฉันจะพิจารณา 2 วิธี

1 วิธีในการอธิบายอาร์เรย์: อาร์เรย์ของประเภทของตัวแปรในอาร์เรย์ (จำนวนเต็ม/จริง/ไบต์);

วิธีที่ 2 ในการอธิบายอาร์เรย์: อาร์เรย์ของอาร์เรย์ประเภทตัวแปรในอาร์เรย์

ขั้นแรกให้อธิบายแถว (1..m) จากนั้นจึงอธิบายคอลัมน์ (1..n)

วิธีที่สองอธิบายวิธีการอธิบายอาร์เรย์หนึ่งมิติสองชุด ซึ่งรวมกันเป็นอาร์เรย์สองมิติหนึ่งชุด

อาร์เรย์สองมิติสามารถอธิบายได้ในส่วน Type สำหรับการเข้าถึงในภายหลังหลายครั้ง หรือในส่วนคำอธิบายตัวแปร Var ฉันอยากจะชี้ให้เห็นว่าแทนที่จะใช้ m และ n คุณสามารถแทนที่ตัวเลข หรือคุณสามารถทำก็ได้ ใช้ค่าคงที่

ตัวอย่างการระบุอาร์เรย์สองมิติในส่วนคำอธิบายตัวแปร:

ต
ม. = 100;
n = 100;
var
a: อาร์เรย์ของจำนวนเต็ม

ในกรณีนี้ เราได้ระบุอาร์เรย์สองมิติ a ขนาด 100 x 100 นั่นคือ เรามีเมทริกซ์จตุรัส

ตัวอย่างการระบุอาร์เรย์เมทริกซ์โดยใช้ส่วนประเภท:

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

ในตัวอย่างที่สอง เราระบุอาร์เรย์เมทริกซ์ที่เหมือนกันสองตัวที่มีขนาด 100 x 100 เมื่ออธิบายอาร์เรย์ b เราไม่จำเป็นต้องอธิบายมิติและประเภทข้อมูลอีกครั้ง

จะเข้าถึงตัวแปรเซลล์ในอาเรย์สองมิติได้อย่างไร?

ในการเข้าถึงอาร์เรย์สองมิติ คุณต้องระบุหมายเลขแถวก่อนแล้วตามด้วยหมายเลขคอลัมน์ดังนี้:

x คือตัวแปรใดๆ a คือชื่อของอาร์เรย์ i คือหมายเลขแถว j คือหมายเลขคอลัมน์

ยิ่งไปกว่านั้น i และ j สามารถเป็นตัวแปรหรือจำนวนเต็มก็ได้

ตัวอย่างการเขียนข้อมูลลงในอาเรย์:

สำหรับ i:= 1 ถึง n do // ตั้งค่าหมายเลขบรรทัดในลูป
สำหรับ j:=1 ถึง m do //ตั้งค่าหมายเลขคอลัมน์ในลูป
a:=สุ่ม(100);

//กำหนดค่าสุ่มให้กับเซลล์ด้วยหมายเลขแถว i และหมายเลขคอลัมน์ j

เราเติมอาร์เรย์ด้วยตัวเลขสุ่มตั้งแต่ 1 ถึง 100

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

ฉัน, เจ: จำนวนเต็ม;
Begin //จุดเริ่มต้นของโปรแกรมหลัก

writeln("อาร์เรย์สองมิติ: "); // สนทนากับผู้ใช้
สำหรับ i:= 1 ถึง 10 do //เติมอาร์เรย์
สำหรับ j:= 1 ถึง 10 ทำ

เมทริกซ์:=สุ่ม(100);
สำหรับ i:= 1 ถึง 10 do //เติมอาร์เรย์
สำหรับ i:= 1 ถึง 10 ให้เริ่มต้น //Array output
เขียน(เมทริกซ์, " ");
เขียน
writeln("ไซต์"); //หากต้องการคุณสามารถลบได้

จบ; //สิ้นสุดโปรแกรม

//readln //ใช้ใน Turbo Pascal

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

พิจารณาอาร์เรย์ปาสคาลสองมิติที่มีขนาด 3*3 นั่นคือมันจะมีสามเส้น และแต่ละบรรทัดจะมีสามองค์ประกอบ:

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

คำอธิบายของอาร์เรย์ Pascal สองมิติ

มีหลายวิธีในการประกาศอาร์เรย์ปาสคาลสองมิติ

ตัวอย่างของคำอธิบายอาร์เรย์ Pascal สองมิติ
พิมพ์<тип_элементов>;
เวกเตอร์ = อาร์เรย์ของ
เมทริกซ์= อาร์เรย์ของเวกเตอร์;

วาร์ ม: เมทริกซ์;

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

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

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

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

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

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

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

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

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

และหนึ่งในนั้นจะซ้อนอยู่ภายในอีกอันหนึ่ง

พิมพ์
โปรแกรมตัวอย่างสำหรับการป้อนอาร์เรย์ Pascal สองมิติจากแป้นพิมพ์
var
เมทริกซ์=อาร์เรย์ของจำนวนเต็ม;
ก, : เมทริกซ์;
ฉัน, เจ: จำนวนเต็ม; (ดัชนีอาร์เรย์)
เริ่ม
สำหรับ i:=1 ถึง 5 do (วนซ้ำเพื่อวนซ้ำทุกแถว)

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

การพิมพ์อาร์เรย์ Pascal สองมิติลงบนหน้าจอ

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

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

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

การแสดงอาร์เรย์ Pascal สองมิติในหน่วยความจำ

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

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

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

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

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

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

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

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

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

นิพจน์ 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 - เราจะป้อนค่าจากแป้นพิมพ์ เมทริกซ์ – เราจะป้อนเมทริกซ์ในรูปแบบของขั้นตอน; เราจะเติมเมทริกซ์แบบสุ่ม เช่น โดยใช้ฟังก์ชันสุ่ม()
• ข้อมูลเอาต์พุตจะเป็นค่าของตัวแปร P (ผลิตภัณฑ์)
• เพื่อตรวจสอบการทำงานที่ถูกต้องของโปรแกรม จำเป็นต้องแสดงเมทริกซ์บนหน้าจอ เพื่อสิ่งนี้ เราจะจัดขั้นตอนการแสดงเมทริกซ์อย่างเป็นทางการ
• ความคืบหน้าในการแก้ไขปัญหา:

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

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

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

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

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

ให้เรากลับไปที่ขั้นตอนของเราตอนนี้

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

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

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

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

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

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

การผลิตโปรแกรม
พิมพ์
เมทริกซ์=อาร์เรย์ของจำนวนเต็ม;
วาร์
ตอบ: เมทริกซ์;
N, m, i, j: ไบต์;
ป: จำนวนเต็ม;
ขั้นตอน vvod (var m: matrix);
Var k, h: ไบต์;
เริ่ม
สำหรับ i:=1 ที่ต้อง n ทำ (ตัวแปร 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);
จบ.

อาร์เรย์สองมิติโครงสร้างข้อมูลที่จัดเก็บเมทริกซ์สี่เหลี่ยมของแบบฟอร์ม:

ก 11 ก 12 ก 13 ก 14 ก 15 ...ก 1มก 21 ก 22 ก 23 ก 24 ก 25 ...ก 2มก 31 ก 32 ก 33 ก 34 ก 35 ...ก 3มก 41 ก 42 ก 43 ก 44 ก 45 ...ก 4มก 51 ก 52 ก 53 ก 54 ก 55 ...ก 5ม... ... ... ... ... ... ... ก n1ก n2ก n3ก n4ก n5...ก นาโนเมตร

• ในเมทริกซ์ แต่ละองค์ประกอบจะถูกกำหนดโดยหมายเลขแถวและหมายเลขคอลัมน์ตรงจุดตัดที่องค์ประกอบนั้นตั้งอยู่
• ในภาษาปาสคาล อาร์เรย์สองมิติจะถือเป็นอาร์เรย์ที่มีองค์ประกอบเป็นอาร์เรย์เชิงเส้น (อาร์เรย์ของอาร์เรย์) คำอธิบายสองรายการต่อไปนี้ของอาร์เรย์สองมิติจะเหมือนกัน var มวล:อาร์เรย์ของอาร์เรย์ของจริง; var มวล:อาร์เรย์ของจริง;
• เมทริกซ์ที่เรียกว่าจำนวนแถวเท่ากับจำนวนคอลัมน์ เมทริกซ์จตุรัส.
• ในการเข้าถึงองค์ประกอบเมทริกซ์ คุณต้องใช้ดัชนีสองตัวที่ระบุหมายเลขแถวและหมายเลขคอลัมน์ ตัวอย่างเช่น MyArr1- ในกรณีนี้ องค์ประกอบอาร์เรย์ (MyArr1) จะอยู่ในแถวที่สี่และคอลัมน์ที่ห้า
• ทุกสิ่งที่กล่าวถึงเกี่ยวกับการดำเนินการพื้นฐานกับอาร์เรย์หนึ่งมิติก็เป็นจริงสำหรับเมทริกซ์เช่นกัน เมื่อวนซ้ำผ่านองค์ประกอบอาร์เรย์ต่อองค์ประกอบในลูป ตัวแปรประเภทจำนวนเต็มจะทำหน้าที่เป็นดัชนี โดยปกติแล้ว ตัวระบุ “ ใช้เพื่อระบุดัชนีแถว ฉัน “ และคอลัมน์ – “ เจ “.
• การประมวลผลเมทริกซ์ประกอบด้วยขั้นแรกโดยพิจารณาองค์ประกอบของแถวแรก (คอลัมน์) จากนั้นจึงพิจารณาแถวที่สอง ฯลฯ จนถึงแถวสุดท้าย
• หากหมายเลขแถวขององค์ประกอบตรงกับหมายเลขคอลัมน์ ( ฉัน = เจ) ซึ่งหมายความว่าองค์ประกอบนั้นอยู่บน เส้นทแยงมุมหลัก เมทริกซ์
• หากองค์ประกอบอยู่บนเส้นทแยงมุมด้านข้าง ดัชนีจะสัมพันธ์กับจำนวนองค์ประกอบ ( n) โดยความเท่าเทียมกันดังต่อไปนี้: ฉัน + เจ = n + 1

คำอธิบายของอาร์เรย์สองมิติ

มีหลายวิธีในการประกาศ (อธิบาย) อาร์เรย์สองมิติในภาษาปาสคาล

คำอธิบายเบื้องต้นประเภทอาร์เรย์

การกำหนดตัวแปรเป็นอาร์เรย์โดยไม่ต้องประกาศประเภทอาร์เรย์ก่อน

การเริ่มต้นอาร์เรย์สองมิติ

เมื่อเริ่มต้นอาร์เรย์สองมิติ แต่ละบรรทัดจะอยู่ในวงเล็บคู่พิเศษ:

มวลคงที่:อาร์เรย์ = ((2,3,1,0), (1,9,1,3), (3,5,7,0));

อินพุต/เอาต์พุตของค่าองค์ประกอบของอาร์เรย์สองมิติ

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

การเติมอาร์เรย์ด้วยตัวเลขสุ่ม

writeln (ไปที่

บรรทัดใหม่

คำชี้แจงของปัญหา ให้จำนวนเต็มบวก M และ N สร้างเมทริกซ์จำนวนเต็มขนาด M × N โดยที่องค์ประกอบทั้งหมดของคอลัมน์ที่ J มีค่า 5·J (J = 1, …, N)

ค่าคอนส ม. = 7;

n = 10; var i, j:byte;

เมทริกซ์:อาร์เรย์ของจำนวนเต็ม; เริ่มต้นสำหรับ i:= 1 ถึง m ทำเพื่อ j:= 1 ถึง n ทำเมทริกซ์ := 5 * j; ... (เอาต์พุตอาร์เรย์)

ตัวอย่างที่ 2

คำชี้แจงของปัญหา ให้จำนวนเต็มบวก M, N และเซตของตัวเลข M สร้างเมทริกซ์ M × N โดยแต่ละคอลัมน์ประกอบด้วยตัวเลขทั้งหมดจากชุดเดิม (ในลำดับเดียวกัน)

1. ค่าคอนส ม. = 5; n = 7;เวกเตอร์:อาร์เรย์ของจำนวนเต็ม = (3, 5, 2, 7, 4); var i, j:byte;
2. เมทริกซ์:อาร์เรย์ของจำนวนเต็ม; เริ่มต้นสำหรับ j:= 1 ถึง n do (ใช้คอลัมน์ j-th) สำหรับ i:= 1 ถึง m do (เข้าถึงองค์ประกอบของคอลัมน์ j-th ตามแถว) เมทริกซ์ := vector[i]; (การนำไปปฏิบัติ) ... (เอาต์พุตของอาร์เรย์สองมิติผลลัพธ์)
3. การบ้านให้จำนวนเต็มบวก M และ N สร้างเมทริกซ์จำนวนเต็มขนาด M × N ซึ่งองค์ประกอบทั้งหมด
4. การบ้านบรรทัดที่ 1 มีค่าเป็น 10·I (I = 1, …, M)ให้จำนวนเต็มบวก M, N และเซตของตัวเลข N สร้างเมทริกซ์ขนาด M × N โดยแต่ละแถวประกอบด้วยตัวเลขทั้งหมดจากชุดเดิม (ในลำดับเดียวกัน)