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

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

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

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

მასივი ასეა აღწერილი:

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

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

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

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

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

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

მაგალითი. შეავსეთ მასივი:

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

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

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

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

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

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

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

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

და ჩვენი მარყუჟის ყოველი გამეორებით მნიშვნელობა მეიზრდება ერთეული. მივყვეთ ნაბიჯებს. ჯერ ეს :

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

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

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

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

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

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

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

ორგანზომილებიანი პასკალური მასივის აღწერა.

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

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

ორგანზომილებიანი პასკალური მასივის აღწერის მაგალითი

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

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

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

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

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

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

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

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

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

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

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

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

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

ტიპი
matrix= მთელი რიცხვის მასივი;
ვარ
a, : მატრიცა;
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), სადაც აარის მასივის ცვლადი. ამავდროულად, ისინი გაკვირვებულნი არიან შემდგენელი მესიჯით, რომ ამ ტიპის ცვლადის წაკითხვა ან დაბეჭდვა შეუძლებელია. იქნებ მიხვდეთ, რატომ არ შეიძლება ამის გაკეთება, თუ წარმოგიდგენიათ N ჭიქები ზედიზედ მდგარი და თქვენს ხელში, მაგალითად, წყლის ქვაბი. შეგიძლიათ გამოიყენოთ ბრძანება "დაასხით წყალი" ყველა კათხის ერთდროულად შესავსებად? რაც არ უნდა ეცადოთ, თითოეულ ფინჯანში ცალკე უნდა ჩაასხით. მასივის ელემენტების შევსება და ჩვენება ასევე უნდა მოხდეს თანმიმდევრულად და ელემენტ-ელემენტზე, რადგან კომპიუტერის მეხსიერებაში მასივის ელემენტები განლაგებულია თანმიმდევრულ უჯრედებში.

ორგანზომილებიანი პასკალური მასივის წარმოდგენა მეხსიერებაში

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

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

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

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

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

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

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

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

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

გამოთქმას SizeElem * Cols *(I -1)+ SizeElem *(J -1) ეწოდება ოფსეტი მასივის დასაწყისთან მიმართებაში.

რამდენი მეხსიერებაა გამოყოფილი მასივისთვის?

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

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

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

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

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

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

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

გამოსავალი:

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

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

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

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

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

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

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

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

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

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

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

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

და ისევ, პროცედურის შიგნით წყობილი მარყუჟების განსახორციელებლად, ჩვენ გვჭირდება მრიცხველები, დაე მათ იგივე ვუწოდოთ - 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);
Დასასრული.

მატრიცა– in – ორგანზომილებიანი მასივის ანალოგი – კვადრატული ან მართკუთხა ცხრილი, რომელიც შედგება რიგებისა და სვეტებისგან:

ორგანზომილებიანი მასივის ზომა- ელემენტების რაოდენობა M*N მასივში,

სადაც M არის მწკრივების რაოდენობა, N არის სვეტების რაოდენობა (ბუნებრივი რიცხვები).

კვადრატული მატრიცა- მატრიცა რიგებისა და სვეტების თანაბარი რაოდენობით.

მატრიცის თანმიმდევრობა -კვადრატული მატრიცის რიგების (სვეტების) რაოდენობა.

1. ორგანზომილებიანი მასივის აღწერა

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

პასკალში ინდექსები ჩასმულია კვადრატულ ფრჩხილებში:

A, A,..A.

2-განზომილებიანი მასივის აღწერის 2 გზა არსებობს:

1 მასივის აღწერა ცვლადების განყოფილებაშიVAR:

istart..icon, jstart..jcon- ინდექსის დიაპაზონები (სტრიქონები, სვეტები);

t - ელემენტის ტიპი.

Მაგალითად:

VAR y: მთელი რიცხვი;

VAR F: რეალობის მასივის მასივი;

VAR mb: უძრავის მასივი;

VAR C: სტრიქონის მასივი;

CONST M= 4; N=2;

VAR A: მთელი რიცხვის მასივი;

2 მასივის აღწერა ტიპის აღწერილობის განყოფილებაშიტიპი:

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

შევსება სვეტების მიხედვით:

ა	ა	…	…	…
ა	…	…	…	…
ა	…	…	…	…
ა	…	…	…	…

სავარჯიშოები 2 განზომილებიანი მასივების შევსებაზე

სავარჯიშო მასა 1:შეავსეთ A(5, 10) მატრიცა სტრიქონი-სტრიქონით შემთხვევითი რიცხვების გენერირების მეთოდით.

პროგრამა mas_1; (მატრიცის შევსება მწკრივად)

A: მასივი INTEGER;

writeLn('მატრიცა A:');

FOR i:= 1-დან 5-მდე DO(გარე მარყუჟი რიგების მიხედვით)

j:=1-დან 10-მდე DO(შიდა მარყუჟი სვეტების მეშვეობით)

A:= შემთხვევითი (10);

ჩაწერა (A:3); (დაბეჭდეთ მთელი ხაზი ზედიზედ)

ჩაწერაLn; (გადადით ახალ ხაზზე)

სავარჯიშო მასა 2:შეავსეთ A(3, 4) მატრიცა სვეტად კლავიატურიდან რიცხვების შეყვანით.

პროგრამა mas_2; (მატრიცის შევსება სვეტების მიხედვით)

Const N =4; M =3;

Var A: მასივი INTEGER;

FOR j:= 1-დან M DO(გარე მარყუჟი სვეტებზე)

FOR i:=1 დან N DO(შიდა მარყუჟი რიგებში)

write('შეიყვანეთ ელემენტი A[",i",",","j,"]=');

readLn(A);

writeLn('შედეგის მატრიცა A:');

i:=1-დან N-მდე (მატრიცის გამომავალი)

j:=1-დან M-ისთვის

დაწერე,' ');

სავარჯიშო მასა 3:მოცემულია მატრიცა A(N? M), რომელიც შედგება ნატურალური რიცხვებისგან. განსაზღვრეთ მისი მაქსიმალური ელემენტი და მისი ინდექსები.

პროგრამა mas_3; (მატრიცის მაქსიმალური ელემენტი)

CONST t= 10; r=10;

A: მასივი INTEGER;

n, m, Max, iMax, jMax, k: მთელი რიცხვი;

write('შეიყვანეთ ხაზების რაოდენობა N='); readLn(N);

write('შეიყვანეთ სვეტების რაოდენობა M='); readLn(M);

writeLn('მატრიცა:');

FOR i:= 1-დან N DO-მდე (მაივის შევსება შემთხვევითი რიცხვების გენერირებით)

FOR J:=1 TO M DO

A:= შემთხვევითი (10);

ჩაწერა (A:3);

მაქს:= A; iMax:=1; jMax:=1; k:=0;(ვიღებთ საწყის მნიშვნელობას Max = 1 ელემენტის მნიშვნელობა)

იყიდება i:=1-დან N-მდე

იყიდება j:=1-დან M-მდე

IF A > მაქს მაშინ

მაქს:= A; iMax:=i; jMax:=j; k:=1

WriteLn('Max= ' ,Max,' მწკრივში: ',imax, ' column:', jmax);

სექციები: Კომპიუტერული მეცნიერება

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

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

კლასის პროგრესი

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

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

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

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= მთელი რიცხვის მასივი; (მთლიანი რიცხვების 2D მასივი)

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

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

Const N=10;M=10;
ტიპი Tmas= მთელი რიცხვის მასივი;
ვარ A: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