PHP Ստացեք նվազագույն և առավելագույն արժեքները երկչափ ասոցիատիվ զանգվածում: Min - Գտնում է ամենափոքր Php արժեքը զանգվածի նվազագույն արժեքների քանակը

(PHP 4, PHP 5, PHP 7)

րոպե — Գտնում է ամենափոքր արժեքը

Նկարագրություն

Եթե ​​փոխանցվի միայն մեկ արգումենտ՝ թվերի զանգված, րոպե ()վերադարձնում է դրանցից ամենափոքրը: Եթե ​​առաջին արգումենտը ամբողջ թիվ է կամ լողացող, ապա պետք է լինի առնվազն ևս մեկը: Այս դեպքում գործառույթը րոպե ()կվերադարձնի դրանցից ամենափոքրը:

Մեկնաբանություն:

Տարբեր տեսակների արժեքները համեմատվում են ստանդարտ համեմատության կանոնների միջոցով: Օրինակ՝ ոչ թվային տող ( լար) կհամեմատվի ամբողջ թվի հետ ( ամբողջ թիվ) ոնց որ հավասար լինի 0 , բայց մի քանի տող ( լար) կհամեմատվեն այբբենական կարգով: Վերադարձված արժեքը կպահպանի փոփոխականի սկզբնական տեսակը՝ առանց փոխակերպման։

Վերադարձի արժեքներ

Գործառույթ րոպե ()վերադարձնում է այն պարամետրի արժեքը, որը համարվում է «ամենափոքրը» ըստ ստանդարտ համեմատության կանոնների: Եթե ​​տարբեր տեսակի մի քանի արժեքներ հավասար են միմյանց (այսինքն. 0 Եվ «abc»), ապա առաջինը կվերադարձվի։

Օրինակներ

Օրինակ #1 Օգտագործման օրինակ րոպե ()

echo min (2, 3, 1, 6, 7); // 1
echo min (զանգված (2, 4, 5)); // 2

// «բարև» տողը, երբ համեմատվում է int-ի հետ, դիտվում է որպես 0
// Քանի որ երկու արժեքներն էլ հավասար են, պարամետրերի կարգը որոշում է արդյունքը
echo min (0, «բարև»); // 0
echo min («բարև», 0); // Բարեւ

// Այստեղ մենք համեմատում ենք -1< 0, поэтому -1 является наименьшим значением
echo min («բարև», - 1); // -1

// Տարբեր երկարությունների զանգվածները համեմատելիս min կվերադարձնի ավելի կարճը
$val = min (զանգված (2, 2, 2), զանգված (1, 1, 1, 1)); // զանգված (2, 2, 2)

// Նույն երկարությամբ բազմաթիվ զանգվածներ համեմատվում են ձախից աջ
// այս օրինակի համար՝ 2 == 2, բայց 4< 5
$val = min (զանգված (2, 4, 8), զանգված (2, 5, 1)); // զանգված (2, 4, 8)

// Եթե զանգվածը և ոչ զանգվածը համեմատվում են, զանգվածը երբեք չի վերադարձվի
// քանի որ զանգվածները համարվում են ավելի մեծ, քան մյուս բոլոր արժեքները
$val = min ("string", array(2, 5, 7), 42); // տող

// Եթե մի արգումենտ NULL կամ բուլյան է, այն կհամեմատվի մյուսների հետ
// օգտագործելով FALSE կանոնը< TRUE, учитывая остальные типы аргументов
// Տրված օրինակում -10-ը և 10-ը համարվում են ՃԻՇՏ
$val = min (- 10, FALSE, 10); // ՍՈՒՏ
$val = min (- 10, NULL, 10); // ԴԱՏԱՐԿ

// մյուս կողմից, 0-ը համարվում է FALSE, ուստի այն «պակաս» է, քան TRUE
$val = min(0, TRUE); // 0
?>

Զանգվածները տեղեկատվության պահպանման հարմար կառուցվածքային եղանակներից են: Նման զանգվածի յուրաքանչյուր տարր ունի իր տեղը, իր բանալին և արժեքը։ Զանգվածների բովանդակությունը կարող է տարբեր լինել, օրինակ՝ թվերի, անունների կամ պարզ թվային արժեքների տվյալների բազա։ Խոսելով թվերի մասին՝ մեզ կարող են բախվել տարբեր տեսակի առաջադրանքներ, օրինակ՝ հանել առավելագույն կամ նվազագույն արժեքը: Այսօր մենք կխոսենք այն մասին, թե ինչպես է դա լուծվում ծրագրավորման տարբեր լեզուներով։

PHP-ում միաչափ զանգվածի ամենամեծ և ամենափոքր արժեքը գտնելը

Բոլոր զանգվածները տարբերվում են իրենց կառուցվածքով։ Դիտարկենք երկու պարզ միաչափ զանգված, որոնցից մեկը չի պարունակում բանալիներ.

$my_array = զանգված (22, 24, 37, 74, 23, 2, 10);

և մեկը նույնական է նախորդին, բայց ստեղներով.

$my_array = զանգված (1 => 22, 2 => 24, 3 => 37, 4 => 74, 5 => 23, 6 => 2, 7 => 10);

Փորձենք ցուցադրել այս զանգվածի առավելագույն և նվազագույն արժեքները: Դա անելու համար մենք կօգտագործենք ստանդարտ գործառույթներ " առավելագույնը«Եվ» ր«համապատասխանաբար.

Echo max ($my_array); // Տպել 74 echo min ($my_array); // Տպել 2

Եթե ​​ավելի ուշադիր նայենք երկրորդ զանգվածին, ապա արդյունքում կարող ենք ստանալ առավելագույն կամ նվազագույն արժեքների բանալին։

Օգտագործելով զանգված որպես օրինակ

$my_array = զանգված (1 => 22, 2 => 24, 3 => 37, 4 => 74, 5 => 23, 6 => 2, 7 => 10);

այն կունենա հետևյալ տեսքը.

$max = array_keys ($my_array, max ($my_array)); $max = $max;// Առավելագույն արժեքի բանալի $min = array_keys($my_array, min($my_array)); $min = $min; // Նվազագույն արժեքի ստեղն echo $max; // Տպել առավելագույն արժեքի արդյունքը

Համապատասխանաբար, առավելագույն արժեքի բանալին «4» է, իսկ նվազագույն արժեքը «6»:

PHP-ում բազմաչափ զանգվածի ամենամեծ և ամենափոքր արժեքը գտնելը

Բազմաչափ զանգվածներն առանձնանում են իրենց բնադրմամբ։ Օրինակ, երկչափ զանգվածը կունենա հետևյալ տեսքն առանց ստեղների.

$my_array = զանգված (զանգված (22, 24, 37), զանգված (74, 23, 2), զանգված (10));

Եվ, համապատասխանաբար, որոշակի ստեղներով.

$my_array = զանգված (զանգված (1 => 22, 2 => 24, 3 => 37), զանգված (4 => 74, 5 => 23, 6 => 2), զանգված (7 => 10));

Այս դեպքում առավելագույն և նվազագույն արժեքները գտնելը մի փոքր դժվար է, բայց նաև հնարավոր է:

Նախ, այստեղ առավելագույնը և նվազագույնը գտնելու համար մենք զանգվածը վերածում ենք միաչափի.

$out_array = զանգված (); foreach ($my_array որպես $sub_array) ( $out_array = array_merge ($out_array, $sub_array);)

Դիզայնն աշխատում է վերը նշված երկու տարբերակների համար: Եվ հետո, հետևելով միաչափ զանգվածի օրինակին, մենք կցուցադրենք մեզ անհրաժեշտ տվյալները.

Echo max ($ out_array); // Տպել 74 echo min($out_array); // Տպել 2

Որպես փոքր բոնուս, ես կտամ մեկ այլ հայտնի երկչափ զանգվածի օրինակ.

$my_array = զանգված (զանգված («id» => «1», «ամսաթիվ» => «2018-03-19», «price» => «5»,), զանգված («id» => «2» , "date" => "2018-03-19", "price" => "50",), զանգված ("id" => "3", "date" => "2018-03-19", " գին» => «25»));

Հանրաճանաչություն ասելով նկատի ունեմ ոչ թե բովանդակությունը, այլ դրա կառուցվածքի օրինակը։ Եկեք ասենք, որ այստեղ դուք պետք է թողարկեք միայն «գին» ստեղների առավելագույն և նվազագույն արժեքները:

Առաջին բանը, որ ձեզ անհրաժեշտ է այս դեպքում, նոր զանգված ստանալն է միայն այս տվյալներով.

$numbers = array_column ($my_array, «գին»);

Echo min ($ numbers); // Տպել 5 echo max ($ numbers); // Տպել 50

Սա ավարտում է աշխատանքը զանգվածների հետ PHP-ում: Եթե ​​հանկարծ ձեր զանգվածի կառուցվածքը տարբերվի, և դուք չգիտեք, թե ինչպես մշակել այն, տվեք համապատասխան հարցը մեկնաբանություններում, ես կփորձեմ օգնել ձեզ:

JavaScript-ում միաչափ զանգվածի ամենամեծ և ամենափոքր արժեքը գտնելը

Ի տարբերություն PHP-ի, JavaScript-ում զանգվածների տեսակը շատ ավելի պարզ է, և պարզ միաչափ զանգվածը կունենա հետևյալ տեսքը.

Var my_array = ;

Այստեղ ոչ մի ինդեքս չի նշվում: Այս զանգվածում առավելագույն և նվազագույն արժեքները գտնելու համար մենք կգրենք մեր սեփական երկու պարզ գործառույթ.

Function arrayMax(array) ( return array.reduce(function(a, b) ( return Math.max(a, b); ));) ֆունկցիա arrayMin(array) ( return array.reduce(function(a, b) ( վերադարձնել Math.min(a, b); )); )

որոնք օգտագործվում են մեզ անհրաժեշտ արժեքները գտնելու համար: Օգտագործումը նույնպես պարզ է.

Զգուշացում (arrayMax (my_array)); // Տպել 74 զգուշացում (arrayMin(my_array)); // Տպել 2

Այս դեպքում «2» և «74» թվերը կցուցադրվեն էկրանին որպես զանգվածի նվազագույն և առավելագույն արժեքներ:

JavaScript-ում բազմաչափ զանգվածի ամենամեծ և ամենափոքր արժեքը գտնելը

JavaScript-ում բազմաչափ զանգվածները նույնքան պարզ են, և դրանք հետևյալն են.

Var my_array = [ , , ];

Փորձենք այստեղ գտնել առավելագույնն ու նվազագույնը։ Սկզբից մենք կգրենք մի ֆունկցիա, որին, ըստ մեզ արդեն ծանոթ սխեմայի, այս զանգվածը կներկայացնենք որպես միաչափ.

Var out_array = ; my_array.forEach(function(v) (Array.prototype.push.apply(out_array, v); ));

Եվ օգտագործելով օբյեկտը » Մաթեմատիկա«Մենք ստանում ենք մեզ անհրաժեշտ արժեքները.

Var min = Math.min.apply(null, out_array); // Ստացեք 2 var max = Math.max.apply(null, out_array); // Ստացեք 74 ահազանգ (առավելագույնը); // Տպել 74 էկրանին

Փաստորեն, օբյեկտի փոխարեն» Մաթեմատիկա«Դուք կարող եք օգտագործել տարբերակում օգտագործվող մեր գործառույթները միաչափ զանգվածով, բայց որպեսզի հասկանաք, որ ցանկացած խնդիր կարող է լուծվել մի քանի ձևով. այստեղ ես մի փոքր այլ լուծում եմ տվել:

Դե, ավանդույթի համաձայն՝ փոքր բոնուս: Դիտարկենք մեկ այլ բազմաչափ զանգված հետևյալ կառուցվածքով.

Var my_array = [["Մեկ", "2018-03-19", 5], ["Երկու", "2018-03-19", 50], ["Երեք", "2018-03-19", 25 ], ];

Ինչպես տեսնում ենք, յուրաքանչյուր զանգվածի թվային արժեքները երրորդ տեղում են։ Եկեք գրենք որոշ կոդ և ստանանք համապատասխան արժեքները հենց այս տվյալներից.

Var min = +Infinity; var max = -Անսահմանություն; my_array.forEach(function(item) (if(+item< min) { min =+ item; // Ищем минимальное значение } }); my_array.forEach(function(item) { if(+item >max) (max =+ տարր; // Փնտրում եմ առավելագույն արժեքը) )); զգուշացում (min+" "+max); // Ցուցադրել արդյունքը էկրանին

Այսքանը: Մի մոռացեք աջակցել նախագծին: Շատ հետաքրքիր բաներ են սպասում ձեզ առջևում:

Ես զանգված ունեմ այս ձևաչափով.

Զանգված ( => Զանգված ( => 117 => Ցանց => 16) => Զանգված ( => 188 => FTP => 23) => Զանգված ( => 189 => Ինտերնետ => 48))

Կա՞ լավ միջոց «հաշվի» նվազագույն և առավելագույն արժեքները ստանալու համար: Ես կարող էի դա անել՝ օգտագործելով բազմաթիվ օղակներ, բայց ես մտածեցի, որ կարող է ավելի լավ միջոց լինել:

Ի տարբերություն մյուսների, դուք չեք կարող օգտագործել min() / max() ֆունկցիաները այս խնդրի համար, քանի որ այս ֆունկցիաները չեն հասկանում իրենց փոխանցված տվյալների (զանգվածի) զանգվածները: Այս գործառույթներն աշխատում են միայն սկալյար զանգվածի տարրերի համար:

ՍԿՍԵԼ ՊԱՏԿԵՐԸ

Պատճառը, թե ինչու է min() և max() օգտագործումը տալիս է ճիշտ պատասխանը, այն է, որ զանգվածները տիպային փոխանցում են ամբողջ թվերին, ինչը չսահմանված վարքագիծ է.

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

Իմ վերը նշված արտահայտությունը տիպի ձուլման մասին սխալ էր: Իրականում min()-ը և max()-ն աշխատում են զանգվածների հետ, բայց ոչ այնպես, ինչպես OP-ին անհրաժեշտ են դրանք աշխատելու համար: Երբ օգտագործում եք min() և max() բազմաթիվ զանգվածներով կամ զանգվածի տարրերի զանգվածով, համեմատեք տարրերը տարր առ տարր ձախից աջ.

$val = min (զանգված (2, 4, 8), զանգված (2, 5, 1)); // զանգված(2, 4, 8) /* * առաջին տարրը՝ համեմատած առաջին տարրի հետ՝ 2 == 2 * երկրորդ տարրը՝ համեմատած երկրորդ տարրի հետ՝ 4< 5 * first array is considered the min and is returned */

Խնդրի մեջ թարգմանված՝ OP-ը ցույց է տալիս, թե ինչու ուղղակիորեն օգտագործելով min() և max()-ը ճիշտ արդյունք է տալիս: Զանգվածի առաջին տարրերը id-ն են, ուստի min()-ը և max()-ը նախ համեմատում են դրանք, ի դեպ, տանում է դեպի ճիշտ արդյունք, քանի որ ամենացածր id-ն այն է, որն ունի ամենացածր թիվը, իսկ ամենաբարձր id-ն այն է: որն ունի ամենաբարձր ցուցանիշը:

ՎԵՐՋ ԽՄԲԱԳՐԵԼ

Ճիշտ ճանապարհը օղակ օգտագործելն է:

$a = array(array("id" => 117, "name" => "Networking", "count" => 16), array("id" => 188, "name" => "FTP", " count" => 23), array ("id" => 189, "name" => "Ինտերնետ", "count" => 48)); $min = PHP_INT_MAX; $ max = 0; foreach ($a որպես $i) ( $min = min($min, $i["count"]); $max = max($max, $i["count"]);

Կարող եք օգտագործել max() և min() ֆունկցիաները:

Ի՞նչ արեցիք բազմաթիվ օղակների հետ: Մեկը բավական է :)

1. Ստացեք առաջին տարրը՝ հաշվելով $min-ի և max-ի քանակը
2. կրկնեք մնացածի վրա, համեմատեք հաշվարկը յուրաքանչյուր $min-ի և $max-ի հետ, եթե ավելի քիչ/մեծ է, նշանակեք հաշվարկի նոր արժեք

Դուք կարող եք օգտագործել max/min ֆունկցիաները, քանի որ դրանք կվերադարձնեն զանգված, որը պարունակում է յուրաքանչյուր ցուցանիշի առավելագույն/նվազագույնը: Ձեր օրինակը պետք է վերադարձնի զանգված (189, «Ցանցային կապ», 48) առավելագույնի համար: Դուք կարող եք այնուհետև վերցնել միավորը այս զանգվածից:

Թարմացնելը չի ​​աշխատում, քանի որ ես բացառել եմ: Տղամարդկանց էջի օրինակը ապակողմնորոշիչ է, և օրինակը տալիս է ճիշտ արդյունք՝ օգտագործելով max, բայց դա պարզապես պատահականություն է:

Կարծես թե դուք չեք կարող օգտագործել max() 2D զանգվածում: Այն պարզապես վերադարձնում է ամենամեծ զանգվածը, այլ ոչ թե max() յուրաքանչյուր ինդեքսի (ինչպես նշված է մի քանի պատասխաններում):

$count = զանգված (); foreach ($arr որպես $_arr) ($count = $_arr["count"];) var_dump(max($count), min($count));

Կա՞ համարժեք ներկառուցվածգործառույթը դրա համար? (նույնիսկ առանց հնարավորության փորձարկում)

/** * առբերում է սյունակ 2D զանգվածից մեկ այլ սյունակի վրա կամայական ընտրությամբ * * @param $ aArray՝ առբերելու * @param $ aColName սյունակի անունը, որը պետք է առբերվի, օրինակ. «O_NAME» * @param $aColTest (ըստ ցանկության) սյունակի անունը՝ թեստը գործարկելու համար, օրինակ. «O_ID» * @param $aTest (ըստ ցանկության) տող՝ փորձարկման համար, օրինակ. ">=10", "== "". $Toto. "" " * @return 1D զանգվածը միայն սյունակն է հանված * @access public * / ֆունկցիա extractColFromArray ($aArray, $aColName, $aColTest = "", $ aTest = "") ($mRes = array()); foreach ($aArray որպես $ տող) ( if (($aColTest == "") || (eval("return". $row[$aColTest]. $ aTest. ";"))) ( $ mRes = $ տող [ $ aColName]; ) ) վերադարձնել $ mRes;) // extractColFromArray