Vyplnenie poľa Pascal. Vyplnenie poľa. Pole je homogénna kolekcia prvkov

Pole je dátová štruktúra reprezentovaná ako skupina buniek rovnakého typu zjednotených pod jedným názvom. Polia sa používajú na spracovanie veľkého množstva údajov rovnakého typu. Názov poľa je , čo sú ukazovatele vysvetlím trochu neskôr. Jednotlivá dátová bunka poľa sa nazýva prvok poľa. Prvky poľa môžu byť ľubovoľné typy údajov. Polia môžu mať jeden alebo viac rozmerov. V závislosti od počtu rozmerov sa polia delia na jednorozmerné polia, dvojrozmerné polia, trojrozmerné polia atď. až po n-rozmerné pole. Najčastejšie sa v programovaní používajú jednorozmerné a dvojrozmerné polia, preto budeme brať do úvahy iba tieto polia.

Jednorozmerné polia v C++

Jednorozmerné pole je pole s jedným parametrom charakterizujúcim počet prvkov jednorozmerného poľa. V skutočnosti je jednorozmerné pole pole, ktoré môže mať iba jeden riadok a n stĺpcov. Stĺpce v jednorozmernom poli sú prvkami poľa. Obrázok 1 znázorňuje štruktúru celočíselného jednorozmerného poľa a. Veľkosť tohto poľa je 16 buniek.

Obrázok 1 - Polia v C++

Všimnite si, že maximálny index jednorozmerného poľa a je 15, ale veľkosť poľa je 16 buniek, pretože číslovanie buniek poľa vždy začína od 0. Index bunky je nezáporné celé číslo, pomocou ktorého je možné pristupovať ku každej bunke poľa a vykonávať s ňou akékoľvek akcie (bunka ).

//syntax pre deklaráciu jednorozmerného poľa v C++: /*typ údajov*/ /*názov jednorozmerného poľa*/; //príklad deklarovania jednorozmerného poľa znázorneného na obrázku 1: int a;

kde, int je celé číslo;

A je názov jednorozmerného poľa;
16 je veľkosť jednorozmerného poľa, 16 buniek.

Vždy hneď za názvom poľa sú hranaté zátvorky, ktoré určujú veľkosť jednorozmerného poľa, to je to, čo odlišuje pole od všetkých ostatných premenných.

//iný spôsob ako deklarovať jednorozmerné polia int mas, a;

Dve jednorozmerné polia mas a a sú deklarované s veľkosťou 10 a 16. Navyše pri tomto spôsobe deklarácie budú mať všetky polia rovnaký dátový typ, v našom prípade int .

// polia môžu byť inicializované pri deklarácii: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // inicializácia jednorozmerného poľa

Inicializácia jednorozmerného poľa sa vykonáva v zložených zátvorkách za znamienkom rovná sa, každý prvok poľa je oddelený od predchádzajúceho čiarkou.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // inicializácia poľa bez určenia jeho veľkosti.

V tomto prípade kompilátor sám určí veľkosť jednorozmerného poľa. Veľkosť poľa je možné vynechať iba pri jeho inicializácii; pri normálnej deklarácii poľa musíte určiť veľkosť poľa. Vyvinieme jednoduchý program na spracovanie jednorozmerného poľa.

// array.cpp: definuje vstupný bod pre aplikáciu konzoly. #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; }

// kód Kód::Blocks

// Kód Dev-C++

// array.cpp: definuje vstupný bod pre aplikáciu konzoly. #include pomocou menného priestoru 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; }

AT riadky 10-11 deklarované a inicializované celočíselné jednorozmerné pole s názvom pole1 , ktorého veľkosť sa rovná 16 bunkám, to znamená, že do takéhoto poľa je možné uložiť 16 čísel. Akékoľvek spracovanie poľa je možné len v spojení so slučkami. Aký cyklus si vyberiete na spracovanie poľa, je len na vás. Na túto úlohu sa však najlepšie hodí. Počítadlo premennej čítača použijeme na odkazovanie na prvky jednorozmerného poľa poľa1. V podmienke pokračovania cyklu for je prísne znamienko nerovnosti, pretože v jednorozmernom poli poľa1 neexistuje žiadny šestnásty index. A keďže číslovanie buniek začína od nuly, prvkov v poli je 16. V tele cyklu for príkaz cout vypíše prvky jednorozmerného poľa (pozri obrázok 2).

Spracovanie masívnych indexov prvok pole1 pole1 5 pole1 -12 pole1 -12 pole1 9 pole1 10 pole1 0 pole1 -9 pole1 -12 pole1 -1 pole1 23 pole1 65 pole1 64 pole1 11 pole1 43 pole1 39 pole1 -15 Pokračujte stlačením ľubovoľného klávesu. . .

Obrázok 2 - Polia v C++

Vyvinieme ďalší program na spracovanie jednorozmerného poľa v C++. Program musí postupne prečítať desať zadaných čísel z klávesnice. Spočítajte všetky zadané čísla, výsledok zobrazte na obrazovke.

// array_sum.cpp: definuje vstupný bod pre aplikáciu konzoly. #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; }

// kód Kód::Blocks

// Kód Dev-C++

// array_sum.cpp: definuje vstupný bod pre aplikáciu konzoly. #include pomocou menného priestoru std; int main(int argc, char* argv) ( int pole1; // vyhlásenie celočíselného poľa cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>pole1; // prečíta zadané čísla z klávesnice cout<< "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; }

Pred spracovaním poľa musí byť deklarované a veľkosť jednorozmerného poľa je 10, ako to určuje podmienka problému. V premennej sum budeme akumulovať súčet prvkov jednorozmerného poľa. Prvý cyklus for vyplní deklarované jednorozmerné pole číslami zadanými z klávesnice, riadky 12-13. Premenná počítadla sa používa na sekvenčný prístup k prvkom jednorozmerného poľa poľa1, počnúc indexom 0 a až 9. vrátane. Druhá slučka for zobrazuje prvky poľa, riadky 15-16. Tretí cyklus for sekvenčne číta prvky jednorozmerného poľa a sčítava ich, pričom súčet je akumulovaný v premennej sum, riadky 17-18. Pozrite si výsledok programu na obrázku 3.

Zadajte elementi massiva: 0 1 2 3 4 5 6 7 8 9 pole1 = (0 1 2 3 4 5 6 7 8 9 ) súčet = 45 Pokračujte stlačením ľubovoľného klávesu. . .

Obrázok 3 - Polia v C++

Najprv sa postupne zadalo všetkých 10 čísel, potom sa zobrazilo jednorozmerné pole a vytlačil sa súčet čísel v poli.

2D polia v C++

Až do tohto bodu sme uvažovali o jednorozmerných poliach, ktoré nie je možné vždy obmedziť. Povedzme, že potrebujete spracovať nejaké údaje z tabuľky. Tabuľka má dve charakteristiky: počet riadkov a počet stĺpcov. V dvojrozmernom poli sú okrem počtu prvkov poľa aj také charakteristiky, ako je počet riadkov a počet stĺpcov dvojrozmerného poľa. To znamená, že vizuálne je dvojrozmerné pole obyčajná tabuľka s riadkami a stĺpcami. V skutočnosti je dvojrozmerné pole jednorozmerné pole jednorozmerných polí. Štruktúra dvojrozmerného poľa s názvom a s veľkosťou m x n je znázornená nižšie (pozri obrázok 4).

Obrázok 4 - Polia v C++

kde m je počet riadkov dvojrozmerného poľa;
n je počet stĺpcov dvojrozmerného poľa;
m * n je počet prvkov poľa.

// syntax pre deklaráciu dvojrozmerného poľa /*typ údajov*/ /*názov poľa*/;

Pri deklarácii dvojrozmerného poľa, ako aj pri deklarácii jednorozmerného poľa, je v prvom rade potrebné zadať:

• Dátový typ;
• názov poľa.

Potom je počet riadkov dvojrozmerného poľa uvedený v prvých hranatých zátvorkách, počet stĺpcov dvojrozmerného poľa je uvedený v druhých hranatých zátvorkách. Dvojrozmerné pole sa vizuálne líši od jednorozmerného poľa druhým párom hranatých zátvoriek. Uvažujme o príklade deklarovania dvojrozmerného poľa. Povedzme, že potrebujeme deklarovať dvojrozmerné pole s počtom prvkov rovným 15. V tomto prípade môže mať dvojrozmerné pole tri riadky a päť stĺpcov alebo päť riadkov a tri stĺpce.

// príklad deklarovania dvojrozmerného poľa: int a;

• a - názov celočíselného poľa
• číslo v prvých hranatých zátvorkách označuje počet riadkov v dvojrozmernom poli, v tomto prípade 5;
• číslo v druhej hranatej zátvorke udáva počet stĺpcov v dvojrozmernom poli, v tomto prípade 3.

// inicializácia dvojrozmerného poľa: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, jedna));

Toto pole má 5 riadkov, 3 stĺpce. za priraďovacím znakom sú umiestnené všeobecné zložené zátvorky, vo vnútri ktorých je toľko párov zložených zátvoriek, koľko má byť riadkov v dvojrozmernom poli, pričom tieto zátvorky sú oddelené čiarkami. Do každého páru zložených zátvoriek napíšte prvky dvojrozmerného poľa oddelené čiarkami. Všetky zložené zátvorky musia mať rovnaký počet prvkov. Keďže v poli je päť reťazcov, existuje aj päť vnútorných párov zátvoriek. Tri prvky sú napísané vo vnútorných zátvorkách, keďže počet stĺpcov je tri. Graficky bude naše pole vyzerať ako dvojrozmerná tabuľka (pozri obrázok 5).

Obrázok 5 - Polia v C++

V každej bunke dvojrozmerného poľa a zobrazí sa hodnota, v pravom dolnom rohu sa zobrazí adresa danej bunky. Adresa bunky dvojrozmerného poľa je názov poľa, číslo riadku a číslo stĺpca.

Vyvinieme jednoduchý program na spracovanie dvojrozmerného poľa, ktorý sa nazýva "Labyrint". Bludisko musí byť postavené na základe dvojrozmerného poľa. Veľkosť bludiska je len na vás.

// array2.cpp: definuje vstupný bod pre aplikáciu konzoly. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) inak cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kód Kód::Blocks

// Kód Dev-C++

// array2.cpp: definuje vstupný bod pre aplikáciu konzoly. #include pomocou menného priestoru std; int main(int argc, char* argv) ( // 1-podmienečne "steny bludiska" // 2-"správna cesta, výstup z bludiska" // 0-"falošná cesta" int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // inicializácia dvojrozmerného poľa ( 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,)); // dve slučky - vnútorná a vonkajšia, ktoré pristupujú ku každému prvku poľa for (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) inak cout<< " "; // вывести два пробела cout << endl; } return 0; }

Správna a nepravdivá cesta mohli byť označené rovnakým číslom, napríklad nula, ale pre prehľadnosť je správna cesta označená číslom 2. Pole bolo inicializované ručne, len kvôli zjednodušeniu programu. Keďže program spracováva dvojrozmerné pole, na prepínanie medzi prvkami dvojrozmerného poľa sú potrebné dve slučky. Prvá slučka for prepína medzi riadkami dvojrozmerného poľa. Keďže v dvojrozmernom poli je 33 riadkov, premenná počítadla i sa zvýši od 0 do 33, riadok 46. Vo vnútri prvého cyklu je cyklus for, ktorý cyklicky prechádza prvkami riadku dvojrozmerného poľa. V tele druhého cyklu for sa vnútri vykonáva operácia unárneho prevodu dátového typu - static_cast<>() , ktorá vytlačí znak , na čísle 176. Operácia konverzie typu údajov je duplikovaná, aby sa zväčšila šírka bludiska. Výsledok programu (pozri obrázok 6).

Obrázok 6 - Polia v C++

Sekcie: Informatika

Ciele:

1. Oboznámiť študentov s možnosťami vyplnenia a spracovania poľa.
2. Vytvorte grafické rozhranie pre projekt na vyplnenie poľa a vypočítajte súčet prvkov v danom poli.
3. Rozvíjajte kognitívny záujem o predmet
4. Pestujte si zodpovedný prístup k učeniu

POČAS VYUČOVANIA

1. Aktualizácia lekcie

Organizovanie času

Frontálny prieskum na predchádzajúcu tému „Koncept poľa. Jednorozmerné pole”

2. Formovanie zručností a schopností

Vysvetlenie nového materiálu

Vyhlásenie poľa

Pole sa deklaruje rovnakým spôsobom ako deklarácia premennej, len je potrebné špecifikovať rozsah zmeny indexu. Napríklad jednorozmerné celočíselné pole obsahujúce 10 prvkov je deklarované takto:

A: pole celých čísel;

Základné úlohy pri práci s poliami

1. Vytvorenie (vyplnenie) poľa

1.1. podľa vzorcov Pre i:=1 až 10 urob a[i]:= i*i;

1.2. generovať náhodne Pre i:=1 až 10 urobte a[i]:= random(20):

Zabudovaná funkcia RANDOM(MAX) vracia náhodné celé číslo rovnomerne rozdelené v rozsahu od 0 do MAX - 1 (MAX je inverzný parameter)

1.3. zadajte z klávesnice For i:=1 až 10 do read(a[i]);

2. Zoradiť pole (vzostupne, zostupne);

3. Vyhľadajte prvky v poli;

4. Výber prvkov z poľa podľa podmienky;

Náhodné vyplnenie poľa.

Ak chcete začať pracovať s poľom, musí byť vyplnené, t.j. priradiť prvkom poľa určité hodnoty. Na vygenerovanie postupnosti náhodných čísel použite funkciu Random(100). Keď spustíte program, táto funkcia zobrazí pseudonáhodnú postupnosť celých čísel v rozsahu od 0 do 100.

Na generovanie sekvencií náhodných čísel, ktoré sa navzájom líšia, sa odporúča použiť operátor Randomize

Akcie s jednorozmernými poľami

1. Výpočet súčtu prvkov

Pre I:= 1 až 10 Do s:=s+ a[i]; (zvyčajná akumulácia súčtu v s)

2. Výpočet produktu

Pre I:= 1 až 10 Do p:=p* a[i]; (zvyčajná akumulácia produktu v p)

3. Vyhľadajte prvok s danou hodnotou

3. Poznámka meniace sa zručnosti v praxi

Projekt „Súčet prvkov v poli“. Poďme vyvinúť projekt „Súčet prvkov v poli“, ktorý naplní pole náhodnými číslami a vypočíta súčet týchto čísel

Najprv vytvoríme postup vyplnenia poľa.

1. Spustite programovací systém Delphi.

2. Práca na projekte začína vytvorením grafického rozhrania v okne Form Builder ovládacie prvky sú umiestnené na formulári. Pre vytvorenie grafického rozhrania projektu umiestnime na formulár dve textové polia na zobrazenie číselných údajov (jedno na vyplnenie poľa, druhé na zobrazenie množstva) a dve tlačidlá na implementáciu procedúr udalostí: vyplnenie poľa a súčet.

3. Používanie Panely s nástrojmi umiestnite textové pole Editl a tlačidlo príkazu Buttonl do formulára Forml

Ďalším krokom je kódovanie procedúr udalostí. Dvojitým kliknutím na tlačidlo, pre ktoré chcete vytvoriť kód programu, sa zobrazí okno Programový kód s prázdnym útržkom procedúry udalosti.

4. Dvakrát kliknite na tlačidlo Buttonl, objaví sa útržok procedúry udalosti TForml.ButtonlClick: Declare an array A a popis premenných JE v sekcii var deklarácie

A:pole celého čísla;

procedure TForm1.Button1Click(Sender: TObject);

Pre I:= 1 až 10 Do

A[I] := Náhodné(10);

Edit1.Text:= Edit1.Text +" " + IntToStr(a[i]);

5. Uložiť projekt ako

6. Kompilácia projektu (Project - Compile)

Teraz si vytvoríme postup na výpočet súčtu prvkov vo vyplnenom poli

Používaním Panely nástrojov str Umiestnime tlačidlo Button2 a textové pole Edit2 na formulár Forml. Dvojitým kliknutím na tlačidlo Button2, pre ktoré chcete vytvoriť kód programu, sa zobrazí okno Programový kód s prázdnym útržkom procedúry udalosti.

procedure TForm1.Button2Click(Sender: TObject);

Pre I:= 1 až 10 Do

Edit2.Text:= Edit2.Text +" " + IntToStr(s)

Uloženie projektu celého projektu (Save Project).

Poďme skompilovať projekt (stlačením klávesy F9).

Kliknite na tlačidlá Vyplniť pole a Súčet.

V textovom poli sa zobrazia výsledky súčtov pre rôzne možnosti plnenia.

4. Zhrnutie

5. Domáca úloha: Vytvorte projekt „Súčin prvkov poľa“, ktorý zabezpečí vyplnenie poľa náhodnými číslami a možnosť zobraziť súčin všetkých prvkov poľa v textovom poli.

Sekcie: Informatika

Téma: Dvojrozmerné polia. Vyplnenie dvojrozmerného poľa podľa daného pravidla.

Ciele: rozvíjať zručnosti v práci s prvkami dvojrozmerného poľa, naučiť sa vyplniť dvojrozmerné polia podľa daného pravidla, naučiť sa odvodiť vzťah medzi číslom riadku a číslom stĺpca; rozvoj logického myslenia žiakov.

PROCES ŠTÚDIE

1. Aktualizácia znalostí

Polia, ktorých poloha prvkov je opísaná dvoma indexmi, sa nazývajú dvojrozmerné. Štruktúra takéhoto poľa môže byť reprezentovaná pravouhlou maticou. Každý prvok matice je jedinečne identifikovaný uvedením čísla riadku a stĺpca, číslo riadka je i, číslo stĺpca je j.
Uvažujme maticu A veľkosti n*m:

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

Matica s 3 riadkami a 4 stĺpcami, počet riadkov n=3, počet stĺpcov m=4. Každý prvok má svoje číslo, ktoré sa skladá z dvoch čísel – čísla riadku, v ktorom sa prvok nachádza, a čísla stĺpca. Napríklad a23 je prvok v druhom riadku a v treťom stĺpci.
Dvojrozmerné pole v Turbo Pascal možno opísať rôznymi spôsobmi. Na opis dvojrozmerného poľa je potrebné určiť, aký typ sú jeho prvky a ako sú očíslované (aký typ je jeho index). Existuje niekoľko spôsobov, ako opísať dvojrozmerné pole.

Const maxN=…; (Maximálne hodnoty riadkov)
maxM=…; (Maximálny počet hodnôt stĺpcov)

1 spôsob

Typ Mas = pole<тип элементов>; (jednorozmerné pole)
Typ Tmas = pole Mas; (Jednorozmerné pole, ktorého prvky sú jednorozmerné polia)

2 spôsobom

Typ Tmas = pole poľa<тип элементов>;
(Jednorozmerné pole, ktorého prvky sú jednorozmerné polia)

3 spôsob

typu<имя типа>= pole<тип элементов>; (Dvojrozmerné pole)

Uprednostňuje sa tretí spôsob popisu dvojrozmerného poľa.

Napríklad:

ConstN=3; M = 4;
Typ TMas= pole integer; (Dvojrozmerné pole celých čísel)

Vytvorenie dvojrozmerného poľa je možné vykonať štyrmi spôsobmi: zadaním z klávesnice, cez generátor náhodných čísel, podľa daného pravidla alebo pomocou súboru.

1) Vytvorenie dvojrozmerného poľa pomocou vstupu z klávesnice a algoritmu pre výstup maticových prvkov riadok po riadku.

Konšt. N = 10; M = 10;
Typ Tmas= pole integer;
VarA:Tmas; i,j:integer;
Začať
(Zadávanie prvkov matice)
Pre i:=1 až N do
Pre j:=1 až M urobte
Prečítaj);
(Výstup maticových prvkov)
Pre i:=1 až N začnite
Pre j:=1 až M urobte
Napíšte(A:4); (Vytlačený prvý riadok)
Writeln (nový riadok)
koniec;
koniec.

2) Fragment programu na generovanie dvojrozmerného poľa pomocou generátora náhodných čísel.

Začať
randomizovať; (Inicializácia generátora náhodných čísel)
(Zadávanie prvkov matice)
Pre i:=1 až N do
Pre j:=1 až M urobte
A:=random(45)-22;

2. Učenie sa nového materiálu. Vyplnenie poľa podľa pravidla

Zoberme si niekoľko fragmentov programov na vyplnenie dvojrozmerného poľa podľa určitého zákona. Aby ste to dosiahli, musíte odvodiť pravidlo plnenia.

1. Vyplňte pole A veľkosťou n*m ​​napríklad takto

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

Pole je vyplnené podľa princípu "hada". Pravidlo vyplnenia: ak je číslo riadku nepárne, potom A=(i-1)*m+j, inak A=i*m-j+1.

program M1A;

n,m,i,j: celé číslo;
začať
readln(n,m);
pre i:=1 až n sa začínajú
pre j:=1 až m do
začať
ak i mod 2 = 1 potom
A = (i-1)*m+j
inak
A = i*m-j+l;
písať(A:3);
koniec;
writeln;
koniec;
readln;
koniec.

Tu je príklad programu iného spôsobu plnenia podľa daného pravidla:

program M1B;
varA:pole celého čísla;
n,m,i,j: celé číslo;
c: celé číslo;
začať
readln(n,m);
c:=1;
pre i:=1 až n do
začať
pre j:=1 až m do
začať
A:=c;
ak (i ​​mod 2 = 0) a (j<>m) potom
dec(c)
inak
inc(c);
písať(A:3);
koniec;
c:=c+m-1;
writeln;
koniec;
readln;
koniec.

2. Vyplňte pole A podľa nasledujúceho princípu:

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

program M2;
varA:pole celého čísla;
n,m,i,j: celé číslo;
c: celé číslo;
začať
readln(n,m);
c:=0;
pre i:=1 až n do
začať
pre j:=1 až m do
začať
ak (i-1+j) mod 2 = 0 potom
A:=0
inak
začať
inc(c);
A:=c;
koniec;
písať(A:5);
koniec;
writeln;
koniec;
readln;
koniec.

3. Vyplňte pole A podľa nasledujúceho princípu:

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

varA:pole celého čísla;
n,m,i,j: celé číslo;
c: celé číslo;
začať
readln(n,m);
c:=1;
pre j:=1 až m do
začať
pre i:=1 až n do
začať
A:=c;
ak (j mod 2 = 0) a (i<>n) potom
dec(c)
inak
inc(c);
koniec;
c:=c+n-l;
koniec;
pre i:=1 až n do
začať
pre j:=1 až m do
písať(A:5);
writeln;
koniec;
readln;
koniec.

4. Vyplňte pole A podľa nasledujúceho princípu:

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: celé číslo;

začať
c:=1;
readln(m);
pre j:=1 až m do
začať
i:=c;
d:=1;
opakovať
A:=d;
inc(i);
ak som potom
i:=1;
inc(d);
kým i=c;
dec(c);
ak c<= 0 then
c:=m-c;
koniec;
for i:=1 to m do
začať
pre j:=1 až m do
písať(A:2);
writeln;
koniec;
koniec.

5. Vyplňte pole A podľa nasledujúceho princípu:

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: celé číslo;
A:pole celého čísla;
začať
readln(m);
for i:=1 to m do
začať
pre j:=1 až m do
začať
ak (i=j) alebo (m-i+1=j), potom
A:=1
inak
A:=0;
písať(A:2);
koniec;
writeln;
koniec;
koniec.

3. Úlohy na samostatné riešenie

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) Vyplňte pole podľa nasledujúceho princípu:

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) Vyplňte pole podľa nasledujúceho princípu:

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

Domáca úloha:

1) Vyplňte pole podľa nasledujúceho princípu:

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) Vyplňte pole podľa nasledujúceho princípu:

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) Vyplňte pole podľa nasledujúceho princípu:

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

1 spôsob (plnenie z klávesnice. Dynamickývstupúdajov)

M:pole celého čísla;

Pre I:=1 až 10 Začnite

Write("Zadajte ",I," hodnota ");

2 spôsobom (pomocou generátora náhodných čísel)

M: pole celých čísel;

Pre I:=1 až 25 Začnite

M[I]:=náhodné(50);

3 spôsob (statický vstup)

M: pole celých čísel = (31,28,31,30,31,30,31,31,30,31,30,31);

Pre I:=1 až 9 urob

1.4 Príklady riešenia problémov

1. Algoritmy na vyhľadávanie a priraďovanie hodnôt prvkom poľa

1. Napíšte program na spracovanie poľa dimenzie n vyplneného celými číslami zadanými z klávesnice. Vytlačte indexy a hodnoty prvkov kladného poľa.

A:POLIE CELÉHO ČÍSLA;

(Vyplnenie poľa)

PRE JA:=1 AŽ N DO Začať

Write("Enter ",I," prvok poľa "); ReadLn(A[I]);

(Spracovanie prvkov poľa)

PRE JA:=1 AŽ N DO

IF A[I]>0 THEN WriteLn("Pozitívny prvok = ",A[I]," jeho index = ",I);

2. Napíšte program na výpočet a tlač hodnôt funkcie Y=sin(x-1)/2x. Nastavte hodnoty argumentov v poli X pozostávajúcom zo 6 prvkov. Zapíšte hodnoty funkcií do poľa Y.

X,Y:ARRAY OF REAL;

PRE JA:=1 AŽ 6 ZAČNITE

Write("Zadajte ",I," hodnotu argumentu"); ReadLn(X[I]);

PRE JA:=1 AŽ 6 ZAČNITE

Y[I]:=SIN(X[I]-1)/(2*X[I]);

WriteLn(" X= ",X[I]:4:1," Y=",Y[I]:5:2);

3. Je dané pole M pozostávajúce z 30 prvkov. Prvky poľa sú ľubovoľné celé čísla. Zobrazte hodnotu každého piateho a kladného prvku. Vytlačte zadané prvky v reťazci.

M:ARRAY INTEGER;

ClrScr; randomizovať;

WriteLn(" Hodnoty prvkov poľa");

PRE JA:=1 AŽ 30 ZAČNITE

M[I]: = náhodne (20)-4; Napíšte(M[I]:3);

WriteLn(" Hodnoty každého piateho a kladného prvku poľa");

Kým<=30 DO Begin

AK M[I] > 0 TAK Napíšte(M[I]:3);

Príklady pre nezávislé riešenie:

Dané jednorozmerné pole s rozmerom 10 vyplnené celými číslami zadanými z klávesnice a hodnotou N. Nahraďte záporné prvky N. Zobrazte upravené pole v jednom riadku.

Dané jednorozmerné pole dimenzie N, vyplnené náhodnými číslami v rozsahu od -15 do 20. Zobrazte hodnoty prvkov poľa, ktorých absolútna hodnota je >10.

Dané jednorozmerné pole dimenzie N, vyplnené náhodnými číslami. Odmocni každý tretí prvok poľa, ak je prvok záporný. Zobrazte upravené pole na obrazovke.

Napíšte program na výpočet a tlač hodnôt funkcie Y=(sinx+1)cos4x. Nastavte hodnoty argumentov v poli X pozostávajúcom z 10 prvkov. Zapíšte hodnoty funkcií do poľa Y.

Z prvkov poľa A pozostávajúceho z 25 prvkov vytvorte pole D rovnakého rozmeru podľa pravidla: prvých 10 prvkov nájdeme podľa vzorca Di=Ai+i, zvyšok - podľa vzorca Di= Ai-i.