Funkcie poľa a operácie poľa (2. časť)

Zlúčenie polí

Zlúčenie (reťazenie) polí je operácia vytvorenia poľa pozostávajúceho z prvkov niekoľkých ďalších polí. Zlučovanie polí je veľmi nebezpečná operácia, pretože výsledok zlučovania podlieha vlastnej logike, zabúdajúc na to, že môžete stratiť dáta. Zlučovanie polí sa realizuje pomocou operátora " + " alebo pomocou funkcie Zlúčenie je možné vykonať iba pomocou funkcie array_merge().

Predpokladajme, že máme dve polia:

$A = pole("1"=>"Prvé", "2"=>"Druhé");
$B = pole("3"=>"Tretí", "4"=>"Štvrtý");

Spojme tieto dve polia do jedného poľa $ C:

operátor" + "pre polia nie je komutatívna. To znamená, že $A + $B nerovná sa $ B + $ A.

V dôsledku uvažovaného príkladu dostaneme pole $ C nasledujúci formulár:

"1"=>"Prvý", "2"=>"Druhý", "3"=>"Tretí", "4"=>"Štvrtý"

A ako výsledok $ B + $ A dostaneme pole, ako je toto:

"3"=>"Tretí", "4"=>"Štvrtý", "1"=>"Prvý", "2"=>"Druhý"

Pri zlučovaní zoznamov táto metóda nefunguje. Vysvetlime si túto skutočnosť na príklade:

Povedzme, že máme dve polia:

$A = pole(10,11,12);
$B = pole(13,14,15);

V dôsledku zlúčenia zoznamov $A a $ B ($A + $B) dostaneme: 10,11,12. A to vôbec nie je výsledok, ktorý sme chceli získať... Je to spôsobené tým, že pri spájaní zoznamov s rovnakými indexmi zostáva výsledné pole prvkom prvého poľa a na rovnakom mieste. V tomto prípade musíme použiť funkciu

Príklad použitia funkcie počítať ():

$ arr = 5;
$ arr = 4;
$ arr = 8;
$ arr = 3;
$ arr = 8;
ozvena "

Počet prvkov poľa: ". počet($arr). "

" ;
// Výstupy: Počet prvkov poľa: 5
?>

Odstránenie poľa a jeho prvkov

Ak chcete odstrániť celé pole, použite funkciu unset().

Ak chcete odstrániť pár kľúč/hodnota, môžete tiež použiť funkciu unset(). Tu sú konkrétne príklady:

$arr = pole(5 => 1 , 12 => 2 );

$arr = 56 ; // V tomto bode skriptu je to toto
// ekvivalent $arr = 56;

$arr [ "x" ] = 42 ; // Toto pridá nový do poľa
// prvok s kľúčom "x"
Fórum portálu PHP. SU

miesto piate - šieste.

X[3]: =X[4];

X[4]: =X[5];

X[5]: =X[6];

Všetky prvky od tretieho po piaty sa teda musia posunúť o jeden doľava - namiesto i -tého prvku musíte napísať (i + 1) -tý. Bloková schéma algoritmu je znázornená na obr. 5.25.

Ryža. 5.25.

Ryža. 5.26.

Ryža. 5.27.

Teraz uvažujme o všeobecnejšom probléme: je potrebné odstrániť m -tý prvok z poľa X, ktoré pozostáva z n prvkov. Na to stačí napísať prvok (m + 1) -tý namiesto prvku s číslom m, (m + 2) -tý prvok - namiesto (m + 1) -tý atď., n - prvok - na mieste (n–1) tl. Proces odstránenia prvku z poľa je znázornený na obr. 5.26.

Algoritmus na vymazanie prvku s číslom m z poľa X rozmeru n je znázornený na obr. 5.27.

Po odstránení prvku 4 Ale v skutočnosti posunutie časti poľa o jeden prvok doľava z poľa sa zmení počet prvkov v poli (zníži sa o jeden) a zmení sa index niektorých prvkov. Ak je prvok odstránený, na jeho miesto príde ďalší a nie je potrebné sa k nemu presúvať (zvýšením indexu o jeden). Ďalší prvok sa po odstránení presunul doľava.

Ak sa spracováva pole, v ktorom sú niektoré prvky odstránené, potom po odstránení prvku nie je potrebné prechádzať na ďalší (v tomto prípade sa počet prvkov znižuje). Ako príklad zvážte nasledujúci problém.

ÚLOHA 5.1. Odstráňte negatívne prvky z poľa.

Algoritmus na riešenie problému je pomerne jednoduchý: prechádzame všetkými prvkami poľa, ak je prvok záporný, potom ho vymažeme posunutím všetkých nasledujúcich o jeden doľava. Jediná vec, ktorá stojí za zapamätanie, je, že po odstránení prvku sa nemusíte presúvať na ďalší na ďalšie spracovanie, sám sa presunie na miesto aktuálneho prvku. Bloková schéma riešenia úlohy 5.1 je na obr. 5.28.

Nižšie je uvedený text programu s komentármi.

program upor_array; var i, n, j: byte; X: pole [ 1.. 100 ] skutočných; begin writeln('zadajte veľkosť poľa'); readln(n); (Zadanie poľa.) for i:=1 až n do begin write ('X[ ', i, ' ]= '); readln(X[i]); koniec; writeln('pole X'); pre i:=1 až n napíšte (x [ i ] : 5: 2, ’ ’); writeln; i:=1; kým<=n) do {Если очередной элемент массива X[i] отрицателен, то} if x [ i ]<0 then begin {удаляем элемент массива с номером i.} for j:= i to n_1 do x [ j ] : = x [ j + 1 ]; {Уменьшаем размер массива.} {Не надо переходить к следующему элементу массива.} n:=n -1; end else {Если элемент не удалялся, то переходим к следующему элементу массива.} i:= i +1; writeln (’Изменённый массив ’); for i:=1 to n do {Вывод преобразованного массива.} write (X[ i ] : 5: 2, ’ ’); writeln; end.

Ryža. 5.28.

Výsledky programu sú znázornené na obr. 5.29.

Ryža. 5.29.

5.9 Vloženie prvku do poľa

Zvážte jednoduchú úlohu: vložiť číslo b do poľa X(10) , medzi tretí a štvrtý prvok.

Na vyriešenie tohto problému je potrebné posunúť všetky prvky poľa, počnúc štvrtým, doprava o jeden prvok. Potom by sa b (X:=b;) malo zapísať do štvrtého prvku poľa. Aby ste však nestratili susednú hodnotu, musíte posunúť o jeden doprava najskôr desiaty prvok, potom deviaty, ôsmy a tak ďalej až do štvrtého. Bloková schéma algoritmu vkladania je znázornená na obr. 5.30.

Ryža. 5.30.

Vo všeobecnom prípade je bloková schéma vkladania čísla b do poľa X(N) medzi prvky s číslami m a m+1 znázornená na obr. 5.31.

Ryža. 5.31.

Nižšie je uvedený fragment programu, ktorý implementuje tento algoritmus 5 Pri popise poľa je potrebné poskytnúť dostatočnú veľkosť na vloženie jedného prvku. .

var i, n, m: byte; X: pole [ 1.. 100 ] skutočných; b: skutočný; begin writeln('N='); readln(n); for i:=1 to n do begin write ('X[ ', i, ' ]= '); readln(X[i]); koniec; writeln('Pole X'); pre i:=1 až n napíšte (x [ i ] : 5: 2, ’ ’); writeln; writeln('m='); readln(m); writeln('b='); readln(b); pre i:=n až po m+1 do x [ i +1]:=x [ i ]; x:=b; n:=n+1; writeln('Zmenené pole'); pre i:=1 až n napíšte (X[ i ] : 5: 2, ’ ’); writeln; koniec.

5.10 Používanie podprogramov poľa

Zvážte, ako môžete odovzdať polia podprogramu. Ako viete (pozri kapitolu 4), ak chcete deklarovať premenné v zozname formálnych parametrov podprogramu, musíte zadať ich názvy a typy. Typ ľubovoľného parametra v zozname však môže byť iba štandardný alebo predtým deklarovaný typ. Preto, aby ste mohli odovzdať pole podprogramu, musíte najskôr opísať jeho typ 6 Dátový typ poľa, deklarácia poľa pozri 2.4.9. Práca s poliami je podrobne popísaná v tejto kapitole. a potom deklaruj postup:

typ_pola = pole[ zoznam_indexov ] z Typ;

postup

názov_procedúry (názov_poľa: typ_poľa);

Napríklad:

typ vector=array [ 1.. 10 ] bajtu; matica=pole [ 1.. 3, 1.. 3 ] reálneho; procedura proc(A: matica; b: vektor; var x: vektor);

Je jasné, že odovzdanie reťazca formulára

názov_premennej: reťazec[ dĺžka_reťazca ];

čo je vlastne pole 7 Dátový typ "string", deklarácia reťazca pozri 2.4.9, by sa malo vykonať rovnakým spôsobom:

string_type = reťazec[ dĺžka_reťazca ];

postup

názov_procedúry(názov_reťazca: typ_reťazca);

Napríklad:

zadajte reťazec_5=reťazec [ 5 ]; string_10=retazec [ 1 0 ]; funkcia fun (S t r: stroka_5) : stroka_10;

Polia môžu byť odovzdané podprogramu pomocou konceptu otvoreného poľa. Otvorené pole je pole 8 Dátový typ "pole", deklarácia poľa, prístup do poľa, pozri časť 2.4.9., ktorého popis špecifikuje typ prvkov, z ktorých pozostáva, ale nedefinuje hranice zmeny indexov:

open_array_name: rad radov... Typ;

Napríklad:

var pole_1: pole skutočných; pole_2: pole pole znakov; pole_3: pole poľa poľa bajtov;

Pridelenie pamäte a špecifikovanie hraníc indexu

35 odpovedí

Existujú rôzne spôsoby, ako odstrániť prvok poľa, niektoré sú pre niektoré špecifické úlohy užitočnejšie ako iné.

Odstráňte jeden prvok poľa

Ak chcete odstrániť iba jeden prvok poľa, môžete použiť \unset() alebo alternatívne \array_splice() .

Tiež, ak máte hodnotu a nepoznáte kľúč na odstránenie prvku, môžete použiť \array_search() na získanie kľúča.

metóda \unset().

Všimnite si, že keď použijete \unset(), kľúče poľa sa nezmenia/preindexujú. Ak chcete reindexovať kľúče, môžete použiť \array_values() po \unset(), čím sa všetky kľúče skonvertujú na číselné číslované kľúče začínajúce od 0.

$pole = pole(0, 1, 2, 3); unset($array); $pole = array_values($pole); var_dump($pole); /* pole(3) ( => int(0) => int(1) => int(3) ) */

// Naše pole počiatočné $arr = array("modrá", "zelená", "červená", "žltá", "zelená", "oranžová", "žltá", "indigová", "červená"); print_r($arr); // Odstráňte prvky, ktorých hodnoty sú žlté alebo červené $arr = array_diff($arr, array("yellow", "red")); print_r($arr);

Toto je výstup z kódu vyššie:

Pole ( => modrá => zelená => červená => žltá => zelená => oranžová => žltá => indigová => červená) Pole ( => modrá => zelená => zelená => oranžová => indigová)

Teraz array_values() preindexuje číselné pole, ale z poľa odstráni všetky kľúčové reťazce a nahradí ich číslami. Ak potrebujete zachovať názvy kľúčov (reťazce) alebo reindexovať pole, ak sú všetky kľúče číselné, použite array_merge():

$pole = pole_zlúčenie(pole_diff($pole, pole("žltá", "červená"))); print_r($arr);

Pole ( => modrá => zelená => zelená => oranžová => indigová)

Ak máte číselné indexované pole, kde sú všetky hodnoty jedinečné (alebo nie sú jedinečné, ale chcete odstrániť všetky inštancie konkrétnej hodnoty), môžete jednoducho použiť array_diff() na odstránenie zodpovedajúceho prvku, napr.

$my_array = array_diff($my_array, array("Hodnota_na_odstránenie"));

Napríklad:

$my_array = array("Andy", "Bertha", "Charles", "Diana"); echo sizeof($my_array) . "\n"; $my_array = array_diff($my_array, array("Charles")); echo sizeof($my_array);

Zobrazí sa nasledovné:

V tomto príklade je prvok s hodnotou "Charles" odstránený, čo je možné overiť volaniami sizeof(), ktoré hlásia veľkosť 4 pre pôvodné pole a 3 po odstránení.

Zničte jeden prvok poľa

unset()

$pole1 = pole("A", "B", "C", "D", "E"); unset($pole1); // Vymazanie známej hodnoty indexu(2) z poľa var_dump($array1);

Výstupom bude:

Pole(4) ( => string(1) "A" => string(1) "B" => string(1) "D" => string(1) "E" )

Ak potrebujete preindexovať pole:

$pole1 = pole_hodnoty($pole1); var_dump($pole1);

Potom bude výstup:

Pole(4) ( => string(1) "A" => string(1) "B" => string(1) "D" => string(1) "E" )

Odstráňte prvok z konca poľa- vrátiť hodnotu odstraňovaného prvku

zmiešané pole_pop(pole &$pole)

$stack = array("pomaranč", "banán", "jablko", "malina"); $posledne_ovocie = array_pop($stack); print_r($stack); print_r("Posledne ovocie:".$posledne_ovocie); // Posledný prvok poľa

Výstup bude

Array ( => pomaranč => banán => jablko) Posledné ovocie: malina

Odstráňte prvý prvok (červený) z poľa, - vráti hodnotu prvku, ktorý sa má odstrániť

zmiešaný array_shift (pole & $pole)

$color = array("a" => "červená", "b" => "zelená" , "c" => "modrá"); $first_color = array_shift($color); print_r($farba); print_r("Prva farba: ".$prva_farba);

Výstupom bude:

Pole ([b] => zelená [c] => modrá) Prvá farba: červená

unset() zničí zadané premenné.

Správanie unset() vo funkcii sa môže líšiť v závislosti od typu premennej, ktorú sa pokúšate zničiť.

Ak globalizovaná premenná nie je v rámci funkcie nastavená (), zničí sa iba lokálna premenná. Premenná vo volajúcom prostredí si zachová rovnakú hodnotu ako pred volaním funkcie unset() .

Odpoveď vyššie uvedeného kódu bude bar.

Ak chcete zrušiť nastavenie () globálnej premennej vo funkcii:

Pre použitie v asociatívnych poliach odstaviť :

$arr = pole("a" => 1, "b" => 2, "c" => 3); unset($arr["b"]); // VÝSLEDOK: array("a" => 1, "c" => 3)

Číselné polia

Pre číselné polia použite pole_splice :

$arr = pole(1, 2, 3); array_splice($pole, 1, 1); // VÝSLEDOK: pole(0 => 1, 1 => 3)

Poznámka

Ak potrebujete vymazať viacero hodnôt v poli a položky v tomto poli sú objekty alebo štruktúrované dáta, je to najlepšie. Tie záznamy, ktoré vrátia hodnotu true z funkcie spätného volania, sa uložia.

$array = [ ["x"=>1,"y"=>2,"z"=>3], ["x"=>2,"y"=>4,"z"=>6], ["x"=>3,"y"=>6,"z"=>9] ]; $results = array_filter($pole, funkcia($hodnota) (​vráti $hodnota["x"] > 2; )); //=> [["x"=>3,"y"=>6,z=>"9"]]

Ak potrebujete odstrániť viacero prvkov z asociatívneho poľa, môžete použiť array_diff_key() (tu sa používa pole_flip()):

$my_array = array("key1" => "value 1", "key2" => "value 2", "key3" => "value 3", "key4" => "value 4", "key5" => "hodnota 5"); $to_remove = array("key2", "key4"); $vysledok = array_diff_key($my_array, array_flip($to_remove)); print_r($vysledok);

Pole ( => hodnota 1 => hodnota 3 => hodnota 5)

Povedzme, že máte nasledujúce pole:

Pole ( => 193 => 5)

Ak chcete odstrániť ukladací priestor , spustite:

unset($attributes["úložisko"]); $atribúty = filter_pola($atribúty);

A dostanete:

pole ( => 193)

Chcel by som len povedať, že som mal určitý objekt, ktorý mal premenné atribúty (v podstate to bolo mapovanie tabuľky a menil som stĺpce v tabuľke, takže sa mohli zmeniť aj atribúty v objekte, ktorý odráža tabuľku):

Class obj ( protected $fields = array("field1","field2"); protected $field1 = array(); protected $field2 = array(); protected loadfields()() // Toto načíta polia $field1 a $ pole2 s riadkami údajov pre stĺpec, ktorý popisujú chránenú funkciu clearFields($num)( foreach($fields as $field) ( unset($this->$field[$num]); // V riadku nižšie to nefungovalo working unset($this->($field)[$num]); // Najprv musíte vyriešiť $field pomocou () ) ) )

Celý účel $fields bol jednoduchý, takže nemusím hľadať nikde v kóde, keď sa zmenia, stačí sa pozrieť na začiatok triedy a zmeniť zoznam atribútov a obsah poľa $ polia odrážať nové atribúty.

Postupujte podľa predvolených funkcií

$Array = pole("test1","test2","test3","test3"); unset($Array);

$Array = pole("test1","test2","test3","test3"); array_pop($Array);

$Array = pole("test1","test2","test3","test3"); array_splice($Array,1,2);

$Array = pole("test1","test2","test3","test3"); array_shift($Array);

Hoci unset() tu bolo spomenuté niekoľkokrát, stále je potrebné spomenúť, že unset() akceptuje viacero premenných, čo uľahčuje odstránenie viacerých nesúvislých prvkov z poľa v jednej operácii:

// Vymazanie viacerých, nesúvislých prvkov z poľa $array = [ "foo", "bar", "baz", "quz" ]; unset($pole, $pole); print_r($pole); // Výstup: [ "foo", "bar" ]

unset() dynamicky

unset() neprijíma pole kľúčov na odstránenie, takže nižšie uvedený kód zlyhá (hoci by bolo o niečo jednoduchšie použiť unset() dynamicky).

$pole = rozsah(0,5); $odstráni = ; $pole = unset($remove); // ZLYHÁ: "neočakávané "nenastavené"" print_r($pole);

Namiesto toho možno funkciu unset() použiť dynamicky v slučke foreach:

$pole = rozsah(0,5); $odstráni = ; foreach ($odstrániť ako $k=>$v) ( unset($pole[$v]); ) print_r($pole); // Výstup: [ 0, 3, 4, 5 ]

Odstráňte kľúče poľa skopírovaním poľa

Existuje aj ďalšia prax, ktorá ešte nebola spomenutá. Niekedy je najjednoduchším spôsobom, ako sa zbaviť určitých kľúčov poľa, jednoducho skopírovať $array1 do $array2.

$pole1 = rozsah(1,10); foreach ($pole1 ako $v) ( // Odstránenie všetkých párnych celých čísel z poľa if($v % 2) ( $pole2 = $v; ) ) print_r($pole2); // Výstup: [ 1, 3, 5, 7, 9 ];

Je zrejmé, že rovnaký postup platí pre textové reťazce:

$array1 = [ "foo", "_bar", "baz" ]; foreach ($pole1 ako $v) ( // Odstráňte všetky reťazce začínajúce podčiarkovníkom if(strpos($v,"_")===false) ( $pole2 = $v; ) ) print_r($pole2); // Výstup: [ "foo", "baz" ]

Riešenia:

1. Ak chcete odstrániť jeden prvok, použite unset() :

unset($array); unset($array["foo"]);

1. Ak chcete odstrániť viacero nesúvislých prvkov, použite aj funkciu unset() :

unset($pole, $pole); unset($array["foo"], $array["bar"]);

1. Ak chcete odstrániť viacero susediacich prvkov, použite array_splice() :

array_splice($pole, $posun, $dĺžka);

Ďalšie vysvetlenie:

$pole = $pole["foo"] = "";

Okrem syntaxe existuje logický rozdiel medzi použitím unset() a priradením prvku. Prvý hovorí, že toto už neexistuje a druhý hovorí, že toto stále existuje, ale jeho hodnota je prázdny reťazec.

Ak máte čo do činenia s číslami, je lepšie zvoliť 0. Ak teda spoločnosť zastaví výrobu ozubeného kolesa XL1000, aktualizuje svoje zásoby:

Unset($products["XL1000"]);

Ak sa mu však dočasne minuli ozubené kolesá XL1000, ale bolo naplánované prijatie novej série z továrne koncom tohto týždňa, je to lepšie:

$products["XL1000"] = 0; $zvieratá = array_values($animals);

Odstráňte prvok poľa na základe kľúča:

Použite funkciu zrušenia nastavenia, ako je uvedené nižšie:

$a = pole("salam", "10", 1); unset($a); print_r($a); /* Výstup: Pole ( => salám => 1) */

Odstráňte prvok poľa na základe hodnoty:

Použite funkciu array_search na získanie kľúča prvku a použite vyššie uvedený spôsob na odstránenie prvku poľa, ako je uvedené nižšie:

$a = pole("salam", "10", 1); $key = array_search(10, $a); if($key !== false) ( unset($a[ $key ]); ) print_r($a); /* Výstup: Pole ( => salám => 1) */

Vytvorte si pole v premennej $array a potom tam, kde som dal "prvok, ktorý chcete odstrániť", vložte niečo ako: "a". A ak chcete odstrániť niekoľko, potom: "a", "b".

Pole je jednou z najužitočnejších a bežne používaných dátových štruktúr v akomkoľvek programovacom jazyku. Schopnosť spravovať polia a ich prvky je veľmi dôležitá a užitočná. V tomto článku sa pozrieme na to, ako môžete odstrániť jednotlivé prvky poľa v PHP.

Táto úloha môže byť implementovaná rôznymi spôsobmi v závislosti od toho, čo vieme o odstraňovanom prvku – či je známy kľúč (číslo alebo identifikátor prvku v poli) alebo len jeho hodnota.

Odstránenie prvku v poli pomocou jeho kľúča

Ak je známy kľúč prvku, potom je úloha veľmi jednoduchá. Funkcia unset() umožňuje vymazať prvok poľa alebo akúkoľvek premennú (vymaže sa aj pamäť počítača použitá pre premennú).

Napríklad máme pole:

$myArr = pole(1,2,3,4,5);

Na odstránenie prvku s hodnotou "3" použite kód:

unset($myArr);

Upozorňujeme, že nie je špecifikovaná hodnota (3), ale kľúč prvku (2), začínajúci v tomto prípade od 0. Ak teda potrebujete odstrániť prvý prvok poľa, zadajte nulu prvok:

unset($myArr);

Tiež stojí za zváženie, že po našich dvoch vymazaniach pole teraz obsahuje tri prvky:

pole
=> 2
=> 4
=> 5
)

Všetky kľúče zostávajúcich prvkov sú zachované. Preto, ak je teraz potrebné vymazať prvý prvok, bude potrebné zadať jeden ako kľúč. Preto a tiež preto, že nie vždy poznáme číslo prvku v poli, ale iba jeho hodnotu, nemusí byť táto možnosť vhodná.

Odstránenie prvku poľa podľa jeho hodnoty

Ak kľúč prvku nie je známy, ale je známa iba hodnota poľa, budete musieť prejsť cez všetky prvky poľa a odstrániť ten, ktorý hľadáte. Napríklad odstránime prvok s hodnotou "3":

$myArr = pole(1,2,3,4,5);
foreach ($myArr ako $key => $item)(
if ($item == 3)(
unset($myArr[$key]);
}
}

* Upozorňujeme, že hodnota poľa sa kontroluje v podmienke dostupnej v slučke v premennej $item a pri odstraňovaní sa špecifikuje kľúč prvku (premenná $key).

Tento algoritmus je tiež vhodný, ak potrebujete odstrániť skupinu prvkov naraz. Koniec koncov, existuje podmienka, ktorá určuje, ktoré prvky sa majú odstrániť.

Odstránenie prekrývajúcich sa prvkov poľa

Jednou zo šikovných funkcií PHP je možnosť získať pole prvkov, ktoré sa neprekrývajú s prvkami iných polí. Ak to chcete urobiť, použite funkciu array_diff(). Berie polia ako parametre a vracia nové pole. Napríklad existuje počiatočné pole $myArr, z ktorého potrebujeme iba prvky, ktoré nie sú zahrnuté v poli $myArr2:

$myArr = pole(1,2,3,4,5);
$myArr2 = pole(3,4);

Aplikovaním funkcie array_diff(), dostaneme nové pole obsahujúce iba potrebné prvky:

$resArr = array_diff($myArr, myArr2);

V dôsledku toho bude $resArr obsahovať:

pole
=> 1
=> 2
=> 5
)

* Tu by ste mali venovať pozornosť skutočnosti, že kľúče sa ukladajú pri vytváraní nového poľa. Okrem toho stojí za to vedieť, že výber pochádza iba z prvého poľa. Takže, ak sú v $myArr2 ďalšie jedinečné prvky, napríklad "6" alebo "7", potom to nijako neovplyvní výsledok - nebudú pridané do nového poľa.

Tento problém sa dá vyriešiť niekoľkými spôsobmi.

Metóda 1. Skopírujte iba nepárne prvky do iného poľa.

const N = 20; var a, b: pole [ 1 .. N ] celého čísla ; i, m: bajty; začať randomizovať; pre i: = 1 až N do begin a[ i] : = náhodný(40) + 10 ; napíš (a[ i] : 3 ); koniec ; writeln ; m:=0; pre i: = 1 až N urob, ak a[ i] mod 2<>0 potom začína m : = m + 1; b[m] := a[i]; koniec ; for i: = 1 to m do begin write (b[ i] : 3 ) ; koniec ; writeln ; koniec.

Toto je najjednoduchší spôsob, ako odstrániť prvky poľa (v tomto prípade párne čísla), pretože nemusíte komprimovať pôvodné pole. Pri riešení vyššie uvedenej úlohy premenná m ukladá počet nájdených nepárnych prvkov a zároveň pri napĺňaní druhého poľa ide o meniaci sa index prvkov.

Metóda 2. Odstráňte párne prvky v aktuálnom poli a prepíšte ich nepárnymi vpravo.

const N = 10; var a: pole [ 1 .. N ] celého čísla ; i, k, m: bajty; začať randomizovať; pre i: = 1 až N do begin a[ i] : = náhodný(40) + 10 ; napis (a[ i] : 3 ) koniec ; writeln ; i:=1; m:=N; kým<= m do if a[ i] mod 2 = 0 then begin m : = m- 1 ; for k: = i to m do a[ k] : = a[ k+ 1 ] ; end else i : = i+ 1 ; for i: = 1 to m do write (a[ i] : 3 ) ; writeln ; end .

Tento spôsob riešenia problému je náročnejší. Ak sa tu nájde párny prvok, celý zvyšok poľa sa posunie dopredu o jednu bunku. V tomto prípade sa nájdený párny prvok prepíše. Premenná m sa znižuje, keď sa počet prvkov poľa zmenšuje.

Táto metóda by sa mala považovať za najracionálnejšiu (avšak otvorené polia sa nesmú študovať v školskom kurze). V predchádzajúcich verziách v skutočnosti polia neboli zmenšené, na obrazovke bola zobrazená iba časť poľa. Vo všeobecnosti by bolo možné jednoducho iterovať pôvodné pole, nič s ním nerobiť a na obrazovke zobraziť iba nepárne prvky.

Otvorené pole vám umožňuje zmeniť jeho dĺžku. Pri riešení nižšie uvedeného problému sa po posunutí nepárnych prvkov a „vymazaní nepárnych prvkov“ zmení dĺžka poľa (pomocou procedúry setlength). Nastavuje novú dĺžku poľa. Funkciou otvorených polí v Pascale je, že ich indexovanie začína od nuly.

const N = 10; var a: pole integer ; i, j, m: byte; začať randomizovať; SetLength(a, N) ; pre i: = 0 až N-1 začína a[i]: = náhodný(40) + 10; napíš (a[ i] : 3 ); koniec ; writeln ; i:=0; // index prvého prvku m:= n-1; // index posledného kým<= m do if a[ i] mod 2 = 0 then begin for j : = i to m- 1 do a[ j] : = a[ j+ 1 ] ; m : = m - 1 end else i : = i + 1 ; SetLength(a, m+ 1 ) ; // posledný prvok má index m, ale m+1 prvkov for i: = 0 až m do píšte (a[ i] : 3 ) ; writeln ; koniec.

Príklad spustenia programového kódu.