Բազմությունների տեսություն. Ես գիտեմ, թե քանի մարդ է վախենում մաթեմատիկոսներից, բայց կոնկրետ բազմությունների տեսությունը (միամիտ) շատ պարզ է և հասկանալի։ Ավելին, մենք մշտապես օգտագործում ենք դրա տարրերը առօրյա կյանքում։ Իսկ ծրագրավորման մեջ դա տեղի է ունենում ամեն քայլափոխի։

Բազմությունների տեսության հիմնական հայեցակարգը, զարմանալիորեն, հետևյալն է մի փունջ. Կոմպլեկտը նշանակում է կամայական բնույթի օբյեկտների հավաքածու՝ դիտարկված որպես մեկ ամբողջություն: Ամենապարզ օրինակը թվերն են։ Արաբական թվերի հավաքածուն ներառում է 10 տարր և է եզրափակիչ. Վերջնականության հասկացությունը ինտուիտիվ է և նշանակում է, որ բազմությունն ունի վերջավոր թվով տարրեր:

Անսահման բազմության օրինակ են բնական թվերը: Իր հերթին բնական թվերի բազմությունը ամբողջ թվերի ենթաբազմություն է, որոնք իրենց հերթին ռացիոնալ թվերի ենթաբազմություն են և այլն։

«Ենթաբազմություն» նշանակում է, որ մի բազմության բոլոր տարրերը ներառված են նաև մեկ այլ բազմության մեջ, որը կոչվում է սուպերսեթ(ենթաբազմության համեմատ):

Կոմպլեկտները շրջանակներով ներկայացնելը բավականին հարմար է։ Դուք կարող եք արագ գնահատել, թե ինչպես են տարբեր հավաքածուները կապված միմյանց հետ:

Բայց մաթեմատիկական առարկաները, ինչպիսիք են թվերը, բազմությունների միակ հնարավոր օբյեկտները չեն: Կոմպլեկտ կարելի է անվանել մի խումբ մարդկանց, ովքեր կանգնած են կանգառում և սպասում են իրենց ավտոբուսին, կամ մեկ տան, քաղաքի կամ երկրի բնակարանների բնակիչներ: Ցանկացած օբյեկտի ցանկացած հավաքածու, որը մենք ցանկանում ենք դիտարկել որպես մեկ ամբողջություն:

Մեզ համար բազմությունների տեսության մեջ գլխավորը դրանց վրա կատարվող գործողություններն են: Դրանք ներառում են՝ հավելում, միացում, խաչմերուկ, տարբերություն, դեկարտյան արտադրանք և մի քանի այլ:

Պարզ օրինակ. Երբ դուք այցելում եք մեկ այլ մարդու էջ Facebook-ում, Facebook-ը ձեզ ցույց է տալիս բլոկ ընդհանուր ընկերների հետ: Եթե ​​ենթադրենք, որ ձեր ընկերները և ձեր ընկերոջ ընկերները երկու հավաքածու են, ապա փոխադարձ ընկերները այն հավաքածուն է, որը ստացվում է որպես ընկերների սկզբնական հավաքածուների հատում:

Անցնելով ծրագրավորմանը, դուք կնկատեք, որ զանգվածը շատ նման է բազմությանը, և այն իսկապես կարելի է ընկալել որպես այդպիսին: Ինչու է սա այդքան կարևոր: Հասկանալով որոշակի գործողությունների հիմքում ընկած սկզբունքները, դուք կարող եք դրանք իրականացնել ամենաարագ և ամենաարդյունավետ ձևով: Օրինակ, իմանալով, որ ձեզ անհրաժեշտ է php-ում սահմանված հատման գործողություն, կարող եք փորձել գտնել առաջադրանքը կատարող ֆունկցիա: Դա անելու համար պարզապես մուտքագրեք հարցումը Google-ում. php հավաքածուն հատվում է(հավաքածու - բազմություն, հատում - խաչմերուկ): Առաջին (գոնե ինձ համար) հղումը որոնման արդյունքներում տանում է դեպի ցանկալի array_intersect ֆունկցիան։ Նույնը սպասում է ձեզ այլ գործողությունների դեպքում: Սա մասնակի պատասխան է «ծրագրավորողներին մաթեմատիկա պե՞տք է» հարցին:

Ի դեպ, ոչ բոլոր լեզուներն ունեն հավաքածուների հետ աշխատելու ներկառուցված գործառույթներ: Որոշներում դրա համար անհրաժեշտ է տեղադրել լրացուցիչ գրադարաններ, իսկ որոշներում, օրինակ, Ruby-ում, բազմությունների հետ գործառնություններն իրականացվում են թվաբանական օպերատորների միջոցով (բազմությունների միություն՝ coll1 + coll2):

Առանձին-առանձին, արժե ասել, որ հարաբերական տվյալների բազաները կառուցված են հարաբերական հանրահաշվի գաղափարների վրա, որոնցում կենտրոնական դեր է խաղում բազմությունների տեսությունը։ Տվյալների շտեմարանները վեբ մշակման անբաժանելի մասն են, և մենք ավելի ուշ կծանոթանանք դրանց հետ:

Դիտարկենք հիմնական գործողությունները.

Խաչմերուկ

Կոմպլեկտների խաչմերուկը մի շարք է, որը ներառում է տարրեր, որոնք միաժամանակ հայտնվում են բոլոր տրված բազմություններում:

[«վասյա», «պետյա»]

Այս ֆունկցիան ընդունում է զանգվածների ցանկացած քանակ։ Այսինքն, դուք կարող եք գտնել ցանկացած քանակի զանգվածների խաչմերուկը մեկ զանգով:

Ասոցիացիա

Բազմությունների միությունը այն բազմությունն է, որը պարունակում է բոլոր տրված բազմությունների տարրերը: PHP-ում Set Union-ը հնարավոր չէ կատարել մեկ զանգով, սակայն այն կարելի է մոդելավորել՝ միացնելով երկու ֆունկցիա.

[«վասյա», «կոլյա», «պետյա», «իգոր», «պետյա», «սերգեյ», «վասյա», «սաշա»]; // եզակի հեռացնում է կրկնօրինակները $sharedFriends = array_unique ($friends); // => [«վասյա», «կոլյա», «պետյա», «իգոր», «սերգեյ», «սաշա»]

Հավելում (տարբերություն)

Երկու հավաքածուների տարբերությունը մի շարք է, որը ներառում է առաջին հավաքածուի տարրեր, որոնք ներառված չեն երկրորդում: Ծրագրավորման մեջ այս գործողությունը հաճախ կոչվում է տարբերություն.

[«կոլյա»]

Բազմությանը պատկանող

Դուք կարող եք ստուգել, ​​թե արդյոք տարրը պատկանում է բազմությանը, օգտագործելով in_array ֆունկցիան.

Առաջադրանք
Գոյություն ունեն երկու զանգված, և դուք ցանկանում եք գտնել դրանց միությունը (բոլոր տարրերը, բայց եթե տարրը երկու զանգվածում է, այն հաշվվում է մեկ անգամ), խաչմերուկը (երկու զանգվածների տարրերը) կամ տարբերությունը (տարրեր մեկ զանգվածում, որոնք չկան): մյուսը).

Լուծում
Միություն սահմանելու համար.
$union = array_unique (array_merge ($a, $b));

Խաչմերուկը հաշվարկելու համար.
$ խաչմերուկ = զանգված_հատում ($a, $b);

Պարզ տարբերություն գտնելու համար.
$ տարբերություն = array_diff ($a, $b);

Իսկ սիմետրիկ տարբերությունը ստանալու համար (բացառիկ ԿԱՄ).

Քննարկում
Նման հաշվարկների համար անհրաժեշտ բաղադրիչներից շատերը ներկառուցված են PHP-ում, պարզապես անհրաժեշտ է դրանք համադրել համապատասխան հաջորդականությամբ:

Երբ միություն է ստացվում երկու զանգվածից, ստեղծվում է մեկ հսկա զանգված՝ սկզբնական զանգվածների բոլոր արժեքներով։ Բայց array_merge() ֆունկցիան թույլ է տալիս կրկնօրինակ արժեքներ երկու թվային զանգվածներ միացնելիս, այնպես որ դուք պետք է կանչեք array_unique() ֆունկցիան:
նման տարրերը զտելու համար:

Այնուամենայնիվ, դա կարող է հանգեցնել բացերի, քանի որ array_unique() ֆունկցիան չի սեղմում զանգվածը: Այնուամենայնիվ, սա խնդիր չէ, քանի որ և՛ foreach հայտարարությունը, և՛ every() ֆունկցիան առանց միջամտության մշակում են սակավ բնակեցված զանգվածները:

Խաչմերուկը հաշվարկելու ֆունկցիան պարզապես կոչվում է array_intersection() և լրացուցիչ ջանք չի պահանջում։

Array_diff() ֆունկցիան վերադարձնում է զանգված, որը պարունակում է $old զանգվածի բոլոր եզակի տարրերը, որոնք չկան $new զանգվածում։ Սա կոչվում է պարզ տարբերություն.


$difference = array_diff ($ հին, $նոր);
Զանգված
=> ոչ
=> դեպի
)

Ստացված $difference զանգվածը պարունակում է «not» և «to», քանի որ array_diff()-ը մեծատառերի զգայուն է: Այն չի ներառում «whatever» տարրը, քանի որ այն $old զանգվածում չէ:

Հակադարձ տարբերությունը ստանալու համար կամ, այլ կերպ ասած, գտնելու $new զանգվածի եզակի տարրերը, որոնք բացակայում են $old զանգվածում, դուք պետք է փոխեք արգումենտները.
$old = զանգված ("To", "be", "կամ", "not", "to", "be");
$new = array ("To", "be", "or", "whatever");
$reverse_diff = array_diff ($նոր, $հին);
Զանգված
=> ինչ էլ որ լինի
)

$reverse_diff զանգվածը պարունակում է միայն «whatever» տարրը։

Եթե ​​Ձեզ անհրաժեշտ է կիրառել ֆունկցիա կամ այլ զտիչ array_diff() ֆունկցիայի մեջ, տեղադրեք ձեր սեփական տարբերությունների (հանման) ալգորիթմը.

// կիրառել մեծատառերի անզգայուն հանման ալգորիթմ; տարբերություն -i
$seen = զանգված();
foreach ($նոր որպես $n) (
$seen++;
}
foreach ($ հին որպես $o) (
$o = strtolower($o);
եթե (!$seen[$o]) ( $diff[$o] = $o;)
}

Առաջին foreach հայտարարությունը ստեղծում է ասոցիատիվ զանգված հետագա որոնման համար:

Այնուհետև այն անցնում է $old զանգվածի միջով և, եթե որոնման ընթացքում տարրը չի գտնվել, այն ավելացվում է $diff զանգվածին։

Այս գործընթացը կարելի է արագացնել՝ համատեղելով array_diff() և array_map() ֆունկցիաները.

$diff = array_diff(array_map("strtolower", $old),
array_map ("strtolower", $new));

Սիմետրիկ տարբերությունն այն է, ինչ կա $a-ում, բայց ոչ $b-ում, գումարած այն, ինչ կա $b-ում, բայց ոչ $a-ում:

$ տարբերություն = array_merge (array_diff ($a, $b), array_diff ($b, $a));

Հաստատվելուց հետո ալգորիթմը առաջ է շարժվում: Array_diff() ֆունկցիան կանչվում է երկու անգամ և որոշում է երկու տարբերություն։ Այնուհետև դրանք միավորվում են մեկ զանգվածի մեջ: Array_unique()-ը կանչելու կարիք չկա, քանի որ այս զանգվածները հատուկ նախագծված են ընդհանուր տարրեր չունենալու համար:

Այս գործառույթները թույլ են տալիս կառավարել զանգվածները տարբեր ձևերով: Զանգվածները իդեալական են փոփոխականների խմբերի հետ պահելու, փոփոխելու և աշխատելու համար:

Աջակցվում են միակողմանի և բազմաչափ զանգվածներ, որոնք ստեղծվել են օգտագործողի կողմից և վերադարձվել են ինչ-որ ֆունկցիայի արդյունքում: Տվյալների բազաների հետ աշխատելու համար կան հատուկ գործառույթներ, որոնք հեշտացնում են հարցումների կատարման արդյունքում վերադարձված տվյալների զանգվածների հետ աշխատանքը. Կան նաև գործառույթներ, որոնք զանգվածները վերադարձնում են որպես արդյունք։

Ավելի մանրամասն իմանալու համար, թե ինչպես են զանգվածները ստեղծվում և օգտագործվում PHP-ում, տե՛ս այս ձեռնարկի Զանգվածներ գլուխը:

Տեղադրում

Այս հնարավորություններն օգտագործելու համար տեղադրում չի պահանջվում, քանի որ դրանք PHP միջուկի մի մասն են:

Նախապես սահմանված հաստատուններ

Ստորև թվարկված հաստատունները միշտ հասանելի են որպես PHP միջուկի մաս:

CASE_LOWER(ամբողջ թիվ)

CASE_LOWERօգտագործվում է ֆունկցիայի հետ array_change_key_case()ցույց տալու, թե արդյոք զանգվածի ստեղները պետք է վերածվեն փոքրատառերի: Կանխադրված գործառույթ array_change_key_case()Այս հաստատունն օգտագործվում է.

CASE_UPPER(ամբողջ թիվ)

CASE_UPPERօգտագործվում է ֆունկցիայի հետ array_change_key_case()ցույց տալու համար, թե արդյոք զանգվածի ստեղները պետք է վերածվեն մեծատառերի:

array_change_key_case - Վերադարձրեք մի զանգված, որի նիշերի ստեղները փոխարկվում են մեծ կամ փոքրատառ նիշերի array_chunk - Զանգվածը բաժանեք մասերի array_combine - Ստեղծեք նոր զանգված՝ օգտագործելով մեկ զանգված՝ որպես բանալին, իսկ մյուսը՝ որպես համապատասխան արժեքներ array_count_values ​​- - Հաշվել բոլոր արժեքների քանակը array_diff_assoc - Հաշվել զանգվածների շեղումը լրացուցիչ ինդեքսի ստուգմամբ array_diff_key - Հաշվել զանգվածների շեղումը՝ համեմատելով ստեղները array_diff_uassoc - Հաշվել զանգվածի շեղումը լրացուցիչ ինդեքսի ստուգմամբ, որն իրականացվում է օգտագործողի կողմից սահմանված divergkey array_diff-ի միջոցով: բանալու համեմատական ​​զանգ array_diff -- Հաշվել զանգվածների տարբերությունը array_fill -- Լրացնել զանգվածը որոշակի արժեքով array_filter -- Կիրառել զտիչ զանգվածի վրա՝ օգտագործելով array_flip հետ կանչը -- Փոխել զանգվածի արժեքները Array_intersect_assoc -- Հաշվել զանգվածի կոնվերգենցիան լրացուցիչ ինդեքսի ստուգման array_intersect_key -- Հաշվել զանգվածների խաչմերուկը` համեմատելով ստեղները array_intersect_uassoc -- Հաշվել զանգվածի խաչմերուկը լրացուցիչ ինդեքսի ստուգմամբ, որն արվել է օգտատիրոջ կողմից սահմանված array_intersect_ukey ֆունկցիայի միջոցով -- Հաշվել զանգվածի խաչմերուկը օգտագործելով բանալիների համեմատության հետ կանչել array_intersect -- Հաշվել զանգվածի կոնվերգենցիան array_key_specified -- Ստուգել, ​​թե արդյոք ստեղնը նշված է առկա է զանգվածի array_keys -- Ընտրել բոլոր ստեղները զանգվածի array_map -- Կիրառել հետ կանչելու ֆունկցիա նշված զանգվածների բոլոր տարրերին array_merge_recursive -- Ռեկուրսիվորեն միաձուլել երկու կամ ավելի զանգված array_merge -- Միավորել երկու կամ ավելի զանգված array_multisort -- Տեսակավորել բազմակի զանգվածներ կամ բազմաչափ զանգվածներ array_pad -- Մեծացնել զանգվածի չափը մինչև տրված արժեք array_pop -- Առբերել զանգվածի վերջին տարրը array_product -- Հաշվարկել զանգվածի արժեքների արտադրյալը Array_push -- Ավելացնել մեկ կամ մի քանի տարր վերջում զանգված array_rand - Ընտրեք մեկ կամ մի քանի պատահական արժեքներ array_reduce-ից - Կրկնվող զանգվածը կրճատեք մեկ արժեքի, օգտագործելով հետ կանչելու ֆունկցիան array_reverse - Վերադարձնում է զանգվածը հակադարձ կարգով array_search - որոնում է զանգվածը տվյալ արժեքի համար: և վերադարձնում է համապատասխան ստեղնը, եթե հաջողվի array_shift - Առբերեք զանգվածի առաջին տարրը array_slice - - Ընտրեք զանգվածի մի հատված array_splice - Հեռացրեք զանգվածի տարրերի հաջորդականությունը և փոխարինեք այն մեկ այլ հաջորդականությամբ array_sum - Հաշվեք զանգվածի արժեքների գումարը array_udiff_assoc - Հաշվել դիվերգենցիան զանգվածներում լրացուցիչ ինդեքսի ստուգմամբ, օգտագործելով հետ կանչի ֆունկցիան array_udiff_uassoc՝ արժեքները համեմատելու համար. զանգվածների շեղումը համեմատության համար օգտագործելով array_uintersect_assoc հետ կանչի ֆունկցիան - Հաշվել զանգվածի խաչմերուկը լրացուցիչ ինդեքսի ստուգմամբ, օգտագործելով array_uintersect_uassoc հետ կանչի ֆունկցիան՝ արժեքները համեմատելու համար. - Հաշվեք զանգվածների խաչմերուկը, օգտագործելով array_unique callback արժեքները համեմատելու համար -- Հեռացրեք կրկնօրինակ արժեքները զանգվածից array_unshift -- Ավելացնել մեկ կամ մի քանի տարրեր զանգվածի սկզբում array_values ​​-- Ընտրեք բոլոր արժեքները զանգված array_walk_recursive -- Ռեկուրսիվորեն կիրառել հատուկ ֆունկցիա զանգվածի յուրաքանչյուր տարրի վրա array_walk -- Կիրառել հատուկ գործառույթ զանգվածի յուրաքանչյուր տարրի վրա -- Ստեղծել զանգվածի arsort -- Տեսակավորել զանգվածը հակառակ հերթականությամբ՝ պահպանելով ստեղները asort - - Տեսակավորել զանգվածը՝ պահպանելով ստեղները կոմպակտ - Ստեղծել զանգված, որը պարունակում է փոփոխականների անուններ և դրանց արժեքները