Vyplňte pole prostředky. Pascal

Lekce vysvětluje, jak pracovat s jednorozměrnými poli v Pascalu, jak používat generátor náhodných čísel - funkci náhodný v Pascalu. Je zvažován příklad, jak odvodit Fibonacciho čísla.

Materiály na stránce jsou zaměřeny na praktické zvládnutí programovacího jazyka Pascal. Stručné teoretické informace si nečiní nárok na úplné pokrytí materiálu na dané téma; potřebné informace lze nalézt na internetu na adrese velké množství. Mezi naše úkoly patří poskytování příležitostí získat praktické programovací dovednosti v Pascalu. Řešené vizuální příklady a úkoly jsou prezentovány v pořadí se zvyšující se složitostí, což usnadní studium materiálu od začátku.

Prohlášení pole

V Pascalu existují dva typy polí: jednorozměrné a dvourozměrné.
Definování jednorozměrného pole v Pascalu zní takto: jednorozměrné pole je určitý počet prvků patřících ke stejnému datovému typu, které mají stejný název a každý prvek má svůj vlastní index – pořadové číslo.
Popis pole v Pascalu (deklarace) a přístup k jeho prvkům je následující:

Prohlášení pole

var length: array [ 1 .. 3 ] of integer ;

počáteční délka[ 1 ] : = 500 ;

pro deklaraci je použito servisní slovo Array (přeloženo z angličtiny jako „pole“ nebo „set“); - do hranatých závorek se umístí číslo (index) prvního prvku, dále dvě tečky a index posledního prvku pole, tzn. v podstatě je uveden počet prvků; se nazývá počet prvků v poli

rozměr pole

of integer (z anglického „from integers“) - označuje, o jaký typ pole se jedná, zde je pomocné slovo. Oznámit velikost lze použít prostřednictvím konstanty: Inicializace pole:

konstantní

, tj. všechny jeho prvky v programu jsou předem určeny.

Popis takového pole vypadá takto:

const a: pole [ 1 .. 4 ] z celého čísla = (1 , 3 , 2 , 5 ) ;

const a:array of integer = (1, 3, 2, 5); Vyplnění po sobě jdoucích čísel:

writeln("zadejte počet prvků: "); readln(n); (pokud množství není předem známo, ptáme se na něj) for i:= 1 až n do begin write("a[", i, "]=");

read(a[i]);

...konec; ...

✍ Příklad výsledku:

const a:array of integer = (1, 3, 2, 5); Zadejte počet prvků: 3 a=5 a=7 a=4

begin a[ 1 ] : = 2 ;

read(a[i]);

a[2]: = 4;

a[3]: = 8;

a[4]: = 6; a[5]: = 3; 6 writeln("Pole A:");

(výstup prvků pole)

konec.

var a: pole celého čísla; (pole pěti prvků) i: celé číslo; begin a:=2; a:=4; a:=8; a:=6; a:=3; writeln("Pole A:"); for i:= 1 až 5 do write(a[i]:2); (prvky výstupního pole) end.

Pole A: 2 4 8 6 3

read(a[i]);

9 8 9 2 0 3 6 9 5 0

Pro práci s poli se nejčastěji používá v Pascalu s parametrem, protože obvykle víte, kolik prvků je v poli, a jako indexy prvků můžete použít počítadlo smyček. Pole 0 úkolu. Musíte zadat skutečné pole dimenzí(tj. šest prvků); vyplňte pole vstupními hodnotami a zobrazte prvky na obrazovce. Použijte dvě smyčky: první pro vkládání prvků, druhou pro výstup.

V tomto příkladu práce s jednorozměrným polem je zjevná nepříjemnost: přiřazování hodnot prvkům.

Zpracování polí v Pascalu, stejně jako vyplnění pole, se obvykle provádí pomocí cyklu for.

const a:array of integer = (1, 3, 2, 5); Náhodná funkce v Pascalu

Aby se neustále nevyžadovaly hodnoty prvků pole, používá se generátor náhodných čísel v Pascalu, který je implementován funkcí Random. Ve skutečnosti se generují pseudonáhodná čísla, ale o to nejde.

Generování čísel od 0 do n (bez hodnoty n samotného, ​​celá čísla v intervalu celé číslo; i:integer; begin randomize; for i:=1 až 10 do begin f[i]:=random(10); ( interval ) write(f[i]," ");

Pro

reálná čísla

v intervalu

a zobrazení prvků na obrazovce: definujte tři pozice pro zobrazení každého prvku.

const a:array of integer = (1, 3, 2, 5); Fibonacciho čísla v Pascalu

f: pole [0 .. 19] celého čísla;

begin f[ 0 ] : = 1 ; f[1]: = 1; for i: = 2 až 19 do begin f[ i] : = f[ i- 1 ] + f[ i- 2 ] ;

writeln (f[ i] ) end ; konec. var i:integer; f:arrayof integer; begin f:=1; f:=1; pro i:=2 až ​​19 do begin f[i]:=f+f; writeln(f[i]) konec; konec. Na tomto příkladu se objasňuje princip práce s číselnými řadami. Obvykle se pro odvození číselné řady najde vzorec pro určení každého prvku této řady. Takže v případě Fibonacciho čísel vypadá toto pravidlo vzorce f[i]:=f+f. Proto musí být použit v pro smyčku

při vytváření prvků pole.

Pole 2 úkol.

Vzhledem k řadě 10 libovolný

čísla: a, a, ... , a (použijte funkci random()). Vypočítejte a vytiskněte součty trojic stojící poblíž

čísla: a+a+a , a+a+a , a+a+a , …… , a+a+a Pseudokód:

Nalezení maximálního prvku podle jeho indexu:Úkol Array_min: Najděte minimální prvek pole. Vytiskněte prvek a jeho index. Pole 4 úkol. Je dáno pole 10 celočíselných prvků. Najděte počet záporných čísel a zobrazte číslo na obrazovce. Pole 5 úkolů.

Najděte minimum a maximum z n zadaných čísel (pole). Určete vzdálenost mezi těmito prvky. 3 2 6 1 3 4 7 2 >>> min=1, max=7, vzdálenost=3

const a:array of integer = (1, 3, 2, 5);

Pole 6 úkolů.

Je dáno celočíselné pole velikosti

N

const a:array of integer = (1, 3, 2, 5);. Vytiskněte všechna sudá čísla obsažená v tomto poli v sestupném pořadí jejich indexů a také jejich počtu K. N=4 mas: 8 9 2 5 >>> 2 8 množství= 2.
Pole 7 úkolu. K Zadejte pole 5 prvků z klávesnice, najděte v něm dva maximální prvky a jejich čísla. N=4 mas: 8 9 2 5 >>> 2 8 množství= 2 Počáteční pole: 4 -5 10 -10 5 maximum A=10, A=5

Dané pole 10 čísel. Zjistěte, zda je číslo zadané uživatelem v poli. Pokud existuje, výstup

var f: pole celého čísla; flag:boolean; i,c:integer; začít randomizovat; for i:=1 až 10 do begin f[i]:=random(10);

write(f[i]," "); konec; flag:=false; writeln("zadat vzorek"); readln(c); for i:=1 až 10 proveďte if f[i]=c then begin writeln("nalezeno");

flag:=true; přerušení; konec; if flag=false then writeln("nenalezeno"); konec.

Uvažujme

• efektivní řešení:
• Úkol:

najít prvek rovný X v poli nebo zjistit, že neexistuje.

Algoritmus:

začít od 1. prvku (i:=1); pokud je další prvek (A[i]) roven X, dokončete vyhledávání, jinak přejděte na další prvek.

const a:array of integer = (1, 3, 2, 5);

řešení v Pascalu Option 2. Smyčka while:

Zveme vás ke shlédnutí podrobné video analýzy hledání prvku v poli (efektivní algoritmus):

const a:array of integer = (1, 3, 2, 5); Pole 8 úkolů.

Uvažujme
Počáteční pole: 4 0 1 2 0 1 3 4 1 0 Co hledáme? 0 A, A, A

Cyklický posun

posuňte prvky pole doleva o 1 pozici, první prvek nahradí poslední.Řešení: A:=A; A:=A;... A:=A[N];.
const a:array of integer = (1, 3, 2, 5); Naprogramovat:

Pole 9 úkolu.

Vyplňte pole 10 prvků náhodnými čísly v intervalu [-10..10] a proveďte cyklický posun doleva

const a:array of integer = (1, 3, 2, 5); bez prvního prvku

Vyplňte pole 10 prvků náhodnými čísly v intervalu a vytiskněte čísla všech prvků rovna X .

Uvažujme

Počáteční pole: 4 -5 3 10 -4 -6 8 -10 1 0 Výsledek: 4 3 10 -4 -6 8 -10 1 0 -5

Cyklický posun

Změna uspořádání prvků v poli Podívejme se, jak je pole přeskupeno nebo obráceno.
const a:array of integer = (1, 3, 2, 5); uspořádat prvky pole v opačném pořadí

Pseudokód:

const a:array of integer = (1, 3, 2, 5); Pole 10 úkolů.

Vyplňte pole 10 prvků náhodnými čísly v intervalu a vytiskněte čísla všech prvků rovna X .

Vyplňte pole 10 prvků náhodnými čísly v intervalu a vytiskněte čísla všech prvků rovna X . Vyplňte pole 10 prvků náhodnými čísly v intervalu [-10..10] a otočte všechny prvky kromě posledního. Zdrojové pole: -5 3 10 -4 -6 8 -10 1 0 4 Výsledek: 0 1 -10 8 -6 -4 10 3 -5 4 Výběr prvků a uložení do jiného pole 1 .

najděte prvky v poli, které splňují nějakou podmínku (například zápornou) a zkopírujte je do jiného pole

spočítat počet nalezených prvků pomocí počítadla počtu, nainstalovat další prvek na místo B. Pomocí proměnné

počítat musí být přiděleno
const a:array of integer = (1, 3, 2, 5); Výstup pole B:

writeln("Vybrané položky"); pro i:=1 počítat-1 napiš(B[i], " ")

Úkol pole 11.

• Vyplňte pole náhodnými čísly v intervalu a do jiného pole zapište všechna čísla, která končí 0.
• Během první iterace cyklu jsou prvky pole porovnávány mezi sebou ve dvojicích: předposlední s posledním, předposlední s předposledním atd. Pokud se ukáže, že předchozí prvek je větší než následující, jsou vyměněny.
• Při druhé iteraci cyklu není potřeba porovnávat poslední prvek s předposledním. Poslední prvek je již na svém místě, je největší. To znamená, že počet srovnání bude o jedno méně. Totéž platí pro každou následující iteraci.

Provedení v Pascalu:

A[j]: = A[j+1];

A[ j+ 1 ] : = с; konec ; const a:array of integer = (1, 3, 2, 5); konec ;

for i:=1 až N-1 do begin for j:=N-1 down to i to if A[j] > A then begin from:= A[j];

• A[j] := A;
• A := c;

Pole 12 úkolů.< A then min:=j; if min <>Vyplňte pole 10 prvků náhodnými čísly v intervalu a seřaďte první polovinu pole vzestupně a druhou sestupně (pomocí metody ‚Bubble‘).

Zdrojové pole: 14 25 13 30 76 58 32 11 41 97 Výsledek: 13 14 25 30 76 97 58 41 32 11Řazení podle výběru const a:array of integer = (1, 3, 2, 5); minimální prvek je prohledán v poli a umístěn na první místo (prohozená místa s A);

Mezi zbývajícími prvky se hledá i ten minimální, který se umístí na druhé místo (prohozená místa s A) atp.

Uvažujme

Provedení v Pascalu:

A[min]: = c;< last then begin X:= A[(first + last) div 2]; L:= first; R:= last; while L <= R do begin while A[L] < X do L:= L + 1; while A[R] >konec ;<= R then begin c:= A[L]; A[L]:= A[R]; A[R]:= c; L:= L + 1; R:= R - 1; end; end; QSort(first, R); QSort(L, last); end; end.

konec ;
pro i:= 1 až N-1 do begin min:= i;

Pole je datová struktura reprezentovaná jako skupina buněk stejného typu sjednocených pod jedním jménem. Pole se používají ke zpracování velkého množství dat stejného typu. Název pole je to, co jsou ukazatele, řeknu vám to o něco později. Jednotlivá datová buňka pole se nazývá prvek pole. Prvky pole mohou být data libovolného typu. Pole mohou mít jeden nebo více než jeden rozměr. V závislosti na počtu dimenzí se pole dělí na jednorozměrná pole, dvourozměrná pole, trojrozměrná pole a tak dále až po n-rozměrné pole. Při programování se nejčastěji používají jednorozměrná a dvourozměrná pole, proto budeme uvažovat pouze tato pole.

Jednorozměrná pole v C++

Jednorozměrné pole je pole s jedním parametrem charakterizujícím počet prvků jednorozměrného pole. Ve skutečnosti je jednorozměrné pole pole, které může mít pouze jeden řádek a n počet sloupců. Sloupce v jednorozměrném poli jsou prvky pole. Obrázek 1 ukazuje strukturu celočíselného jednorozměrného pole A. Velikost tohoto pole je 16 buněk.

Obrázek 1 - Pole v C++

Všimněte si, že maximální index jednorozměrného pole A je 15, ale velikost pole je 16 buněk, protože číslování buněk pole vždy začíná od 0. Index buňky je nezáporné celé číslo, pomocí kterého můžete přistupovat ke každé buňce pole a provádět s ní jakékoli akce ( buňka).

//syntaxe pro deklaraci jednorozměrného pole v C++: /*datový typ*/ /*název jednorozměrného pole*/; //příklad deklarace jednorozměrného pole znázorněného na obrázku 1: int a;

kde, int je celé číslo;

A je název jednorozměrného pole;
16 je velikost jednorozměrného pole, 16 buněk.

Vždy hned za názvem pole jsou hranaté závorky, ve kterých je uvedena velikost jednorozměrného pole, tím se pole odlišuje od všech ostatních proměnných.

//další způsob, jak deklarovat jednorozměrná pole int mas, a;

Dvě jednorozměrná pole mas a a jsou deklarována s velikostí 10 a 16, v tomto pořadí. Navíc v tomto způsobu deklarace budou mít všechna pole stejný datový typ, v našem případě - int.

// pole lze inicializovat při deklaraci: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // inicializace jednorozměrného pole

Inicializace jednorozměrného pole se provádí ve složených závorkách za znaménkem rovná se, každý prvek pole je oddělen od předchozího čárkou.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // inicializace pole bez určení jeho velikosti.

V tomto případě si velikost jednorozměrného pole určí sám překladač. Velikost pole lze vynechat pouze při jeho inicializaci při normální deklaraci pole, velikost pole musí být zadána. Pojďme vyvinout jednoduchý program pro zpracování jednorozměrného pole.

// array.cpp: Definuje vstupní bod pro konzolovou aplikaci. #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 pro konzolovou aplikaci. #zahrnout pomocí jmenného prostoru 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; }

V řádky 10-11 Bylo deklarováno a inicializováno celočíselné jednorozměrné pole s názvem pole1, jehož velikost je 16 buněk, to znamená, že takové pole může uložit 16 čísel. Jakékoli zpracování pole je možné pouze ve spojení se smyčkami. Jakou smyčku zvolit pro zpracování pole, je na vás. Pro tento úkol se ale hodí nejlépe. Pro přístup k prvkům jednorozměrného pole pole1 použijeme proměnnou čítače counter. Podmínka pokračování cyklu for obsahuje přísné znaménko nerovnosti, protože v jednorozměrném poli pole1 není žádný šestnáctý index. A protože číslování buněk začíná od nuly, je v poli 16 prvků V těle cyklu for vytiskne operátor cout prvky jednorozměrného pole (viz obrázek 2).

Obrabotka massiva indexy prvek massiva 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 stisknutím libovolné klávesy. . .

Obrázek 2 - Pole v C++

Pojďme vyvinout další program pro zpracování jednorozměrného pole v C++. Program musí postupně přečíst deset zadaných čísel z klávesnice. Všechna zadaná čísla se sečtou a výsledek se zobrazí na obrazovce.

// array_sum.cpp: Definuje vstupní bod pro konzolovou aplikaci. #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 pro konzolovou aplikaci. #zahrnout pomocí jmenného prostoru std; int main(int argc, char* argv) ( int pole1; // deklarace celočíselného pole cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>pole1; // čtení čísel zadaných 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; }

Před zpracováním pole musí být deklarováno a velikost jednorozměrného pole je 10, jak je stanoveno podmínkou úlohy. V součtové proměnné budeme akumulovat součet prvků jednorozměrného pole. První cyklus for vyplní deklarované jednorozměrné pole čísly zadanými z klávesnice, řádky 12-13. Proměnná čítače se používá k sekvenčnímu přístupu k prvkům jednorozměrného pole pole1, počínaje indexem 0 až po 9. včetně. Druhá smyčka for zobrazuje prvky pole, řádky 15-16. Třetí cyklus for sekvenčně čte prvky jednorozměrného pole a sečte je, součet je akumulován v proměnné součtu. řádky 17-18. Výsledek programu je znázorněn na obrázku 3.

Zadejte elementi massiva: 0 1 2 3 4 5 6 7 8 9 pole1 = (0 1 2 3 4 5 6 7 8 9 ) součet = 45 Pokračujte stisknutím libovolné klávesy. . .

Obrázek 3 - Pole v C++

Nejprve bylo postupně zadáno všech 10 čísel, poté se zobrazilo jednorozměrné pole a vytiskl se součet čísel v poli.

Dvourozměrná pole v C++

Až do tohoto bodu jsme uvažovali o jednorozměrných polích, která nelze vždy omezit. Řekněme, že potřebujete zpracovat nějaká data z tabulky. Tabulka má dvě vlastnosti: počet řádků a počet sloupců. Ve dvourozměrném poli jsou kromě počtu prvků pole také takové charakteristiky, jako je počet řádků a počet sloupců dvourozměrného pole. To znamená, že vizuálně je dvourozměrné pole běžná tabulka s řádky a sloupci. Ve skutečnosti je dvourozměrné pole jednorozměrné pole jednorozměrných polí. Struktura dvourozměrného pole s názvem a o velikosti m x n je znázorněna níže (viz obrázek 4).

Obrázek 4 - Pole v C++

kde m je počet řádků dvourozměrného pole;
n je počet sloupců dvourozměrného pole;
m * n — počet prvků pole.

// syntaxe pro deklaraci dvourozměrného pole /*datový typ*/ /*název pole*/;

Při deklaraci dvourozměrného pole, stejně jako při deklaraci jednorozměrného pole, musíte nejprve zadat:

• datový typ;
• název pole.

Poté první hranaté závorky označují počet řádků dvourozměrného pole a druhé hranaté závorky označují počet sloupců dvourozměrného pole. Dvourozměrné pole je vizuálně odlišeno od jednorozměrného pomocí druhého páru hranatých závorek. Podívejme se na příklad deklarace dvourozměrného pole. Řekněme, že potřebujeme deklarovat dvourozměrné pole s počtem prvků rovným 15. V tomto případě může mít dvourozměrné pole tři řádky a pět sloupců nebo pět řádků a tři sloupce.

// příklad deklarace dvourozměrného pole: int a;

• a je název celočíselného pole
• číslo v prvních hranatých závorkách udává počet řádků dvourozměrného pole, v tomto případě je jich 5;
• číslo ve druhé hranaté závorce udává počet sloupců dvourozměrného pole, v tomto případě jsou 3.

// inicializace dvourozměrného pole: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1));

Toto pole má 5 řádků, 3 sloupce. za přiřazovacím znakem jsou umístěny obecné složené závorky, uvnitř kterých je umístěno tolik párů složených závorek, kolik má být řádků ve dvourozměrném poli, a tyto závorky jsou odděleny čárkami. Do každého páru složených závorek napište prvky dvourozměrného pole oddělené čárkami. Ve všech složených závorkách musí být počet prvků stejný. Protože je v poli pět řádků, existuje také pět vnitřních párů závorek. Ve vnitřních závorkách jsou zapsány tři prvky, protože počet sloupců je tři. Graficky bude naše pole vypadat jako dvourozměrná tabulka (viz obrázek 5).

Obrázek 5 - Pole v C++

V každé buňce dvourozměrného pole A je zobrazena hodnota, adresa této buňky je zobrazena v pravém dolním rohu. Adresa buňky dvourozměrného pole je název pole, číslo řádku a číslo sloupce.

Pojďme vyvinout jednoduchý program pro zpracování dvourozměrného pole, nazvaný „Labyrint“. Labyrint musí být postaven na základě dvourozměrného pole. Velikost labyrintu zvolíme dle vlastního uvážení.

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

// kód Kód::Blocks

// Kód Dev-C++

(176); pomocí jmenného prostoru std; int main(int argc, char* argv) ( // 1-podmíněně „stěny bludiště“ // 2-„správná cesta, výstup z bludiště“ // 0-„falešná cesta“ int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // inicializace dvourozměrného pole ( 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,)); // dvě smyčky - interní a externí, přístup ke každému prvku pole for (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176);<< static_castcout<< " "; // вывести два пробела cout << endl; } return 0; }

Správná a nepravdivá cesta by mohla být označena stejným číslem, například nula, ale pro přehlednost je správná cesta označena číslem 2. Pole bylo inicializováno ručně, pouze pro zjednodušení programu. Protože program zpracovává dvourozměrné pole, jsou pro přepínání mezi prvky dvourozměrného pole potřeba dvě smyčky. První smyčka for přepíná mezi řádky dvourozměrného pole. Protože ve dvourozměrném poli je 33 řádků, proměnná čítače i se zvýší z 0 na 33, řádek 46. Uvnitř první smyčky je smyčka for, která cyklicky prochází prvky řádků dvourozměrného pole. V těle druhé smyčky for je uvnitř provedena operace unárního převodu datového typu - static_cast<>() , který vytiskne číslo znaku 176. Operace převodu datového typu je duplikována, aby se zvětšila šířka bludiště. Výsledek programu (viz obrázek 6).

Obrázek 6 - Pole v C++

Pole v programování je množina prvků stejného typu (stejného typu).

Existuje několik typů polí - jednorozměrný(vektor) a multidimenzionální.

Prvky v poli jsou charakterizovány svými názvy a pořadovými čísly - indexy.

Index je pořadové číslo prvku v poli.

V Pascalu je každému prvku přiřazen jeden nebo více indexů, které popisují pozici prvku v poli.

Jednorozměrné pole

Var a: array Of integer ;
Kde:
1 – dolní index
10 – horní index
A – název proměnné pole
– rozsah hodnot
Integer – datový typ
A[ i ] – přístup k prvku pole v Pascalu

Typ prvků pole může být jakýkoli platný typ v Pascalu, kromě souborů (dokonce i pole).

Příklad pole: A = (1,-5,230,55,-88,0,100)

Když je pole deklarováno, jeho horní index musí být přesně definován.

Při popisu pole je alokována paměť a kompilátor musí vědět, kolik paměti je potřeba pro popisované pole alokovat.

Počet indexů v poli Pascal není nijak omezen. Samotné pole však nesmí být větší než 65537 bajtů.

Pole lze také deklarovat v sekci deklarace typu:

Typ mass = array Of real ; Var a,b,c: hmotnost ;
K prvkům pole se přistupuje ve smyčce.

Nejúčinnějším způsobem zpracování prvků pole v Pascalu je operátor smyčky s parametrem.

proč myslíš? Ano, protože známe konečný počet prvků v poli.

Algoritmy pro vyplnění pole v Pascalu

1. Zadávání prvků pole pomocí počítače se provádí pomocí následující konstrukce:

   For i:= 1 až 10 Do read(A[i]);

2. Nastavení pole náhodně.

   Pole může být nastaveno náhodně pomocí senzoru s náhodnou proměnnou.

   Chcete-li spustit senzor náhodné proměnné v Pascalu, musíte napsat speciální konstrukci - Randomizovat;

   Nová hodnota je generována pomocí funkce Random(n), kde n je celé číslo. V tomto případě se vygeneruje libovolné číslo s rozsahem od 0 do n.

   K:= Náhodný(100);
   Pokud je funkce Random použita bez parametru, generuje reálné číslo (typ real) v rozsahu 0< X < 1

   X:= Náhodné ;

Náhodné vyplnění pole

Randomizovat ; Pro i:= 1 až 10 Začátek A[i] := náhodný*100-70 ;

napsat(A[i]:6:2) ; Konec;

Sdílejte svou práci na sociálních sítích

Pokud vám tato práce nevyhovuje, dole na stránce je seznam podobných prací. Můžete také použít tlačítko vyhledávání

Plnicí.

Prvky jednorozměrného pole můžeme naplnit hodnotami:

Zadávání hodnot z klávesnice;

Náhodně;

Podle vzorce.

Metody pro definování jednorozměrných polí

Smyčky se používají pro vstup a výstup číselných hodnot pole.

Uvažujme procedury, které by vytvořily jednorozměrné pole dvěma způsoby

1) náhodně,

2) zadávání prvků z klávesnice Předpokládejme, že budeme pracovat s polem celých čísel. Nechť nám stačí mít maximální počet prvků rovný 50. Procedura bere parametr odkazem, pole Massiv daného typu a celočíselnou proměnnou n, který je zodpovědný za počet buněk pole, které mají být vyplněny. Budeme také potřebovat lokální proměnnou i

, který bude fungovat jako parametr smyčky a používá se k určení čísla, které určuje umístění prvku v poli., který je zodpovědný za počet buněk pole, které mají být vyplněny. Budeme také potřebovat lokální proměnnou 1. Náhodná tvorba jednorozměrného pole. Nastavme hodnotu každého prvku na výsledek náhodné funkce Random(10). Naplnění pole nastavíme pomocí cyklického operátoru for, v jehož těle je náhodné číslo vypočítáno funkcí Random(10), po které je tato hodnota přiřazena další

-tý prvek pole.

Procedure InsertMas1(Var massiv:mas; n:integer);

I: celé číslo;

Začít

Randomizovat;

Pro i:=1 až n do

Massiv[i] := Náhodně(10);

Konec;

2. Vytvoření jednorozměrného pole zadáním prvků z klávesnice.

Procedure InsertMas1(Var massiv:mas; n:integer);

I: celé číslo;

Randomizovat;

I: celé číslo;

Procedure InsertMas2(Var massiv:mas; n:integer); napište ("Enter", tj

,"tý prvek pole ");

readln(pole[i]);

readln(pole[i]);

Konec;

Pole se zobrazí na obrazovce následovně:

Procedure InsertMas1(Var massiv:mas; n:integer);

I: celé číslo;

Procedure PrintMas(massiv:mas; n:integer);

Pro i:=1 až n

Write(Massiv[i]:5);

Musíme mít na paměti, že ve všech třech případech se neobejdeme bez organizování cyklu.

Nalezení maximálního (minimálního) prvku pole.

Mějme jednorozměrné pole:

20,-2, 4, 10,7, 21,-12, 0, 4, 17.

Zamysleme se nad tím, jaké operace je třeba provést, pokud potřebujeme najít maximum prvku. Přirozeně srovnávací operace Nemyslíme na to, že vždy porovnáváme pár, „probíhající“ všemi prvky pole. Algoritmus pro nalezení maximálního (minimálního) prvku sestrojíme tak, abychom porovnali dvojici čísel, přičemž porovnávací akci zopakujeme tolikrát, kolikrát.

Musíme si tedy odpovědět na dvě otázky:

1) jaká čísla jsou zahrnuta v páru, který tvoří operaci vztahu;

2) kolikrát se musí operace porovnání opakovat. Představme si další proměnnou s názvem max. Bude to jedno z čísel, druhé číslo je dalším prvkem pole. Aby bylo možné provést první porovnávací operaci, je nutné přiřadit nějakou počáteční hodnotu proměnné max. Zde mohou být dvě možnosti:

1) přiřadit první prvek pole proměnné max;

2) přiřadit číslo, které je zjevně menší než všechny prvky pole.

Pole obsahuje informace o počtu studentů v každé skupině prvního ročníku. Určete skupinu s maximálním počtem studentů za předpokladu, že číslo skupiny odpovídá pořadovému číslu čísla v poli (předpokládáme, že taková skupina je pouze jedna).

Jinými slovy, musíme najít maximální prvek a jeho počet.

program max_num;

typ mas=array[ 1.. 10] bajtu;

var a: mas;

num, i: byte;

max: byte;

začít

(vyplnit blok)

pro i:=l až 7 do

readln(a[i]);

(hledejte maximum a jeho počet)

max:==0;

(zadejte nejmenší číslo pro toto pole)

pro i:=l až n dělat

pokud a[i]>max pak začněte

num:=i;

max:=a[i]

konec;

writeln("maximální počet studentů=",max);

writeln("číslo skupiny=",num);

konec.

3) Najděte minimální prvek mezi sudými prvky pole.

Vysvětlení: nemůžeme přiřadit proměnnou min prvnímu prvku pole, protože může to být liché. Proto musíme pro tento datový typ vybrat nějaké velmi velké číslo.

Pokud vyhlásíme prvky pole jsou tedy celá čísla takhle číslo bude +32767.

program min_sudý;

a:array of integer;

i:integer;

min:integer;

začít

pro i:=l až 10 do beein

writeln("zadejte další prvek pole");

readln(a[i]);

konec;

min:=32767;

pro i:=l až 10 do

pokud (a[i]

if min=32767 then writeln ("v poli nejsou žádné sudé prvky") else writein ("minimální prvek mezi sudými prvky pole=",min)

konec.

Pozor: je nutné zkontrolovat, zda se nezměnila hodnota proměnné min, protože nemusí tam být ani prvky.

Jednorozměrná pole. Vytvoření pole a zobrazení jeho prvků

Definice pojmu

Pole je kolekce dat stejného typu se společným názvem pro všechny prvky.

Prvky pole jsou očíslovány a ke každému z nich lze přistupovat pomocí čísla. Počty prvků pole se jinak nazývají indexy a samotné prvky pole se nazývají indexované proměnné.

Vektor (lineární Zadejte pole 5 prvků z klávesnice, najděte v něm dva maximální prvky a jejich čísla. jednorozměrné pole) je příklad pole, ve kterém jsou prvky číslovány jedním indexem.

• Jak čísla (index) prvek pole, obecně se používá výraz ordinální typ(nejčastěji se jedná o celočíselnou konstantu nebo proměnnou celočíselného typu: celé číslo, slovo, byte Zadejte pole 5 prvků z klávesnice, najděte v něm dva maximální prvky a jejich čísla. zkratka)
• Při přístupu k prvku pole je index uveden v hranatých závorkách. Například a, hmotnost.
• Prvky pole se zpracují, když se změní indexy prvků. Například při použití výrazu jsou následující proměnné užitečné pro procházení prvků pole:
  • a[i] - všechny prvky;
  • a - prvky umístěné na sudých místech;
  • a - prvky na lichých místech

Popis pole

• Definování proměnné jako pole bez předchozí deklarace typu pole

Poznámka

• • Popis pole je vyžadován kompilátorem pro alokaci paměti pro jeho prvky.
  • Proměnná je definována jako pole pomocí funkčního slova pole(pole). Rozsah je uveden v hranatých závorkách, tj. dolní a horní mez hodnoty indexu pole. Horní limitní hodnota nemůže být nižší než spodní limit.
  • Proměnné s a k jsou zde považovány za různé typy. Pro zajištění kompatibility je nutné používat deklarace proměnných prostřednictvím předběžné deklarace typu.
  • Pokud jsou typy polí shodné, lze v programu jedno pole přiřadit druhému. V tomto případě budou hodnoty všech proměnných v jednom poli přiřazeny odpovídajícím prvkům druhého pole.
  • Na polích nejsou definovány žádné relační operace. Můžete porovnávat pouze dvě pole prvek po prvku.
• Typ pole Předběžný popis

Poznámka

• • K prvkům pole bude přistupovat takto: a, a, a, a, a (tj. pole obsahuje pět prvků).
  • Pomocí konstant(v tomto příkladu n) při popisu pole je výhodnější, protože pokud se velikost pole změní, nebude potřeba provádět opravy v celém textu programu.
• Nastavení pole na typovanou konstantu

Poznámka

• • V tomto příkladu není pouze alokována paměť pro pole, ale buňky jsou také naplněny daty.
  • Prvky pole mohou být přeměna během programu (jako všechny typované konstanty).

Vyplnění pole daty

§ K vyplnění pole dat (a jejich výstup), nejčastěji se používá smyčka s parametrem pro

§ Chcete-li vyplnit pole náhodnými čísly, použijte funkci náhodný a postup randomizovat(inicializace generátoru náhodných čísel). Formát záznamu je: náhodně (B - A) + A, kde A a B jsou převzaty z intervalu :4);

Příklad programu pro vstup a výstup pole

Prohlášení o problému. Získejte součet prvků pole skládajícího se z 10 celočíselných prvků. Prvky pole se zadávají z klávesnice.

suma =

Prohlášení o problému.", součet)