Min — atrod mazāko vērtību. Min — atrod mazāko vērtību Minimālā vērtība php masīvā

18.07.2021 Spēļu konsoles

Masīvi ir viens no ērtiem strukturētiem informācijas glabāšanas veidiem. Katram šāda masīva elementam ir sava vieta, sava atslēga un vērtība. Masīvu saturs var būt atšķirīgs, piemēram, skaitļu bāze, nosaukumi vai vienkāršas skaitliskās vērtības. Runājot par skaitļiem, mēs varam saskarties ar dažāda veida uzdevumiem, piemēram, maksimālās vai minimālās vērtības atsecināšanu. Šodien mēs runāsim par to, kā tas tiek atrisināts dažādās programmēšanas valodās.

Vienas dimensijas masīva lielākās un mazākās vērtības atrašana PHP

Visi masīvi atšķiras pēc savas struktūras. Apsveriet divus vienkāršus viendimensijas masīvus, no kuriem vienā nav atslēgu:

$mans_masīvs = masīvs(22, 24, 37, 74, 23, 2, 10);

un viens identisks iepriekšējam, bet ar taustiņiem:

$mans_masīvs = masīvs(1 => 22, 2 => 24, 3 => 37, 4 => 74, 5 => 23, 6 => 2, 7 => 10);

Mēģināsim parādīt šī masīva maksimālās un minimālās vērtības. Lai to izdarītu, mēs izmantosim standarta funkcijas " maks"Un" min" attiecīgi:

Echo max($mans_masīvs); // Drukāt 74 echo min($my_array); // Drukāt 2

Ja aplūkojam otro masīvu sīkāk, tad rezultātā varam iegūt maksimālo vai minimālo vērtību atslēgu.

Kā piemēru izmantojot masīvu

$mans_masīvs = masīvs(1 => 22, 2 => 24, 3 => 37, 4 => 74, 5 => 23, 6 => 2, 7 => 10);

tas izskatīsies šādi:

$maks. = masīva_atslēgas($mans_masīvs, max($mans_masīvs)); $max = $max;// Maksimālās vērtības atslēga $min = masīva_atslēgas($mans_masīvs, min($mans_masīvs)); $min = $min; // Minimālās vērtības atslēga echo $max; // Drukājiet maksimālās vērtības rezultātu

Attiecīgi maksimālās vērtības atslēga ir “4” un minimālā vērtība ir “6”.

Daudzdimensiju masīva lielākās un mazākās vērtības atrašana PHP

Daudzdimensionālie masīvi atšķiras ar to ligzdošanu. Piemēram, divdimensiju masīvs bez taustiņiem izskatītos šādi:

$mans_masīvs = masīvs(masīvs(22, 24, 37), masīvs(74, 23, 2), masīvs(10));

Un attiecīgi ar noteiktiem taustiņiem:

$mans_masīvs = masīvs(masīvs(1 => 22, 2 => 24, 3 => 37), masīvs(4 => 74, 5 => 23, 6 => 2), masīvs(7 => 10));

Šajā gadījumā maksimālo un minimālo vērtību atrašana ir nedaudz sarežģīta, taču arī iespējama.

Pirmkārt, lai šeit atrastu maksimumu un minimumu, mēs pārveidojam masīvu par viendimensiju:

$out_masīvs = masīvs(); foreach($mans_masīvs kā $apakšmasīvs) ($out_masīvs = masīva_apvienošana($out_masīvs, $apakšmasīvs);)

Dizains darbojas abām iepriekš minētajām opcijām. Un pēc tam, ievērojot viendimensijas masīva piemēru, mēs parādīsim nepieciešamos datus:

Echo max($out_masīvs); // Drukāt 74 echo min($out_array); // Drukāt 2

Kā nelielu bonusu es sniegšu cita populāra divdimensiju masīva piemēru:

$my_masīvs = masīvs(masīvs("id" => "1", "datums" => "2018-03-19", "price" => "5",), masīvs ("id" => "2" , "datums" => "2018-03-19", "cena" => "50", masīvs ("id" => "3", "datums" => "2018-03-19", " cena" => "25"));

Ar popularitāti es nedomāju saturu, bet gan tā struktūras piemēru. Pieņemsim, ka šeit ir jāizvada tikai “cenas” taustiņu maksimālās un minimālās vērtības.

Pirmā lieta, kas jums šajā gadījumā ir nepieciešama, ir iegūt jauns masīvs tikai ar šiem datiem:

$skaitļi = masīva_kolonna($mans_masīvs, "cena");

Atbalss min($skaitļi); // Drukāt 5 echo max($numbers); // Drukāt 50

Tas pabeidz darbu ar masīviem PHP. Ja pēkšņi jūsu masīva struktūra ir atšķirīga un jūs nezināt, kā to apstrādāt, uzdodiet atbilstošo jautājumu komentāros, es centīšos jums palīdzēt.

Viendimensijas masīva lielākās un mazākās vērtības atrašana JavaScript

Atšķirībā no PHP, JavaScript masīvu veids ir daudz vienkāršāks, un vienkāršs viendimensijas masīvs izskatīsies šādi:

Var mans_masīvs = ;

Šeit nav norādīti indeksi. Lai šajā masīvā atrastu maksimālās un minimālās vērtības, mēs uzrakstīsim divas vienkāršas savas funkcijas:

Funkcija arrayMax(masīvs) ( return array.reduce(function(a, b) ( return Math.max(a, b); )); ) function arrayMin(masīvs) ( return array.reduce(function(a, b) ( atgriezties Math.min(a, b));

kuras tiek izmantotas, lai atrastu mums nepieciešamās vērtības. Lietošana ir arī vienkārša:

Alert(masīvsMax(mans_masīvs)); // Drukāt 74 alert(arrayMin(mans_masīvs)); // Drukāt 2

Šajā gadījumā skaitļi “2” un “74” tiks parādīti ekrānā kā masīva minimālā un maksimālā vērtība.

Daudzdimensiju masīva lielākās un mazākās vērtības atrašana JavaScript

JavaScript daudzdimensiju masīvi ir tikpat vienkārši, un tie izskatās šādi:

Var my_array = [ , , ];

Mēģināsim šeit atrast maksimumu un minimumu. Sākumā mēs uzrakstīsim funkciju, ar kuru saskaņā ar mums jau pazīstamo shēmu mēs attēlosim šo masīvu kā viendimensiju:

Var out_array = ; mans_masīvs.forEach(function(v) ( Array.prototype.push.apply(out_masīvs, v); ));

Un izmantojot objektu " Matemātika"Mēs iegūstam vajadzīgās vērtības:

Var min = Math.min.apply(null, out_array); // Iegūt 2 var max = Math.max.apply(null, out_array); // Saņemt 74 alert(max); // Drukājiet 74 uz ekrāna

Faktiski objekta vietā " Matemātika“Varat izmantot mūsu versijā izmantotās funkcijas ar viendimensionālu masīvu, bet, lai saprastu, ka jebkuru problēmu var atrisināt vairākos veidos – šeit esmu sniedzis nedaudz atšķirīgu risinājumu.

Nu, pēc tradīcijas – neliels bonuss. Apskatīsim citu daudzdimensiju masīvu ar šādu struktūru:

Var my_array = [["Viens", "2018-03-19", 5], ["Divi", "2018-03-19", 50], ["Trīs", "2018-03-19", 25 ], ];

Kā redzam, skaitliskās vērtības katrā masīvā ir trešajā vietā. Uzrakstīsim kodu un iegūsim atbilstošās vērtības tikai no šiem datiem:

Var min = +Bezgalība; var max = -Infinity; my_array.forEach(function(item) ( if(+item< min) { min =+ item; // Ищем минимальное значение } }); my_array.forEach(function(item) { if(+item >max) ( max =+ prece; // Meklējam maksimālo vērtību ) )); brīdinājums(min+" "+maks.); // Parādiet rezultātu ekrānā

Tas arī viss. Neaizmirstiet atbalstīt projektu. Jūs gaida daudz interesantu lietu!

saņemt atslēgu (9)

Man ir šāds masīvs:

Masīvs (0 => masīvs ("id" => "20110209172713", "Datums" => "2011-02-09", "Svars" => "200",), 1 => masīvs ("id" => "20110209172747", "Datums" => "2011-02-09", "Svars" => "180", 2 => masīvs ("id" => "20110209172827", "Datums" => "2011. 02-09", "Svars" => "175", 3 => masīvs ("id" => "20110211204433", "Datums" => "2011-02-11", "Svars" => "195" ",))

Man ir jāizņem minimālā un maksimālā svara vērtības. Šajā piemērā

$min_value = 175

$max_value = 200

Vai ir kāda palīdzība, kā to izdarīt? Paldies!

Atbildes

Cilvēkiem, kuri izmanto PHP 5.5+, to var izdarīt daudz vienkāršāk ar array_column. Nav vajadzīgi tie neglītie masīvi.

Kā iegūt maksimālo vērtību:

$lielākais_svars = max(masīvs_kolonna($detaļas, "Svars"));

Kā iegūt minimālo vērtību

$mazākais_svars = min(masīvs_kolonna($detaļas, "Svars"));

1. iespēja: vispirms salīdziniet masīvu, lai iegūtu šos skaitļus (nevis pilnu informāciju):

$skaitļi = masīva_kolonna($masīvs, "svars")

Tad jūs saņemat min un max:

$min = min($skaitļi); $maks. = max($skaitļi);

2. iespēja. (Tikai tad, ja jums nav PHP 5.5.) Tas pats, kas 1. iespēja, bet, lai iegūtu vērtības, izmantojiet ary_map:

$skaitļi = array_map(function($details) ( return $details["Svars"]; ), $masīvs);

3. iespēja.

4. iespēja: ja nepieciešama tikai minimālā VAI maksimālā vērtība, array_reduce() varētu būt ātrāks:

$min = masīvs_samazināt($masīvs, funkcija($min, $details) ( return min($min, $details["svars"]); ), PHP_INT_MAX);

Tas veic vairāk nekā min() s, taču tie ir ļoti ātri. PHP_INT_MAX ir jāsākas ar maksimumu un jāsamazina un jāsamazina. Jūs varat darīt to pašu ar $max , bet jūs sāksit ar 0 vai -PHP_INT_MAX .

masīvs ("id" => "20110209172713", "Datums" => "2011-02-09", "Svars" => "200", 1 => masīvs ("id" => "20110209172747", " Datums" => "2011-02-09", "Svars" => "180", 2 => masīvs ("id" => "20110209172827", "Datums" => "2011-02-09", "Svars" => "175", 3 => masīvs ("id" => "20110211204433", "Datums" => "2011-02-11", "Svars" => "195"),) ; foreach ($masīvs kā $key => $vērtība) ($result[$key] = $value["Svars"]; ) $min = min($rezultāts); $maks. = max($rezultāts); echo "Masīvs minimālajā skaitā:".$min."
"; echo " Masīvs maksimālajā skaitā: ".$max."
"; ?>

Foreach ($masīvs kā $k => $v) ( $tArray[$k] = $v["Svars"]; ) $min_value = min($tArray); $maksimālā_vērtība = max($tMasīvs);

ātri izdrukājiet piecus maksimālos un minimālos skaitļus no masīva, neizmantojot kārtošanas masīvu php:-

Septiņu augstāko temperatūru saraksts:-"; $m= max($masīvs); for($i=1; $i<7 ; $i++) { $m[$i]=max(array_diff($array,$m)); } foreach ($m as $key =>$value) ( echo " ".$value; ) echo "
Septiņu zemāko temperatūru saraksts: "; $mi= min($masīvs); for($i=1; $i<7 ; $i++) { $mi[$i]=min(array_diff($array,$mi)); } foreach ($mi as $key =>$value) ( echo " ".$value; ) ?>

Kā būtu, neizmantojot iepriekš definētu funkciju, piemēram, min vai max?

$arr = ; $val = $arr; $n = skaits($arr); for($i=1;$i<$n;$i++) { if($val<$arr[$i]) { $val = $val; } else { $val = $arr[$i]; } } print($val);

Interesanti atzīmēt, ka abi iepriekš minētie risinājumi izmanto papildu krātuvi masīvu veidā (vispirms viens no tiem un otrais viens masīvs), un pēc tam jūs atrodat min un max, izmantojot "papildu krātuves" masīvu. Lai gan tas varētu būt pieņemami reālajā programmēšanas pasaulē (kurš sniedz divus bitus par "papildu" krātuvi?), tas iegūtu "C" programmā Programming 101.

Minimālās un maksimālās atrašanas problēmu var viegli atrisināt, izmantojot tikai divus papildu atmiņas slotus

$pirmais = intval($input["Svars"]); $min = $vispirms ; $maks. = $vispirms ; foreach($input as $data) ( $weight = intval($data["Svars"]); if($weight<= $min) { $min = $weight ; } if($weight >$max) ( $max = $svars ; ) ) echo " min = $min un max = $max \n " ;

$num = masīvs (0 => masīvs ("id" => "20110209172713", "Datums" => "2011-02-09", "Svars" => "200"), 1 => masīvs ("id" => "20110209172747", "Datums" => "2011-02-09", "Svars" => "180", 2 => masīvs ("id" => "20110209172827", "Datums" => "2011. 02-09", "Svars" => "175"), 3 => masīvs ("id" => "20110211204433", "Datums" => "2011-02-11", "Svars" => "195" ));

foreach($num as $key => $val) ( $weight = $val["Svars"]; ) echo max($weight); atbalss min($svars); .

Šeit ir daži veidi noņemt elementu no masīva, izmantojot JavaScript Visas aprakstītās metodes

nemainiet sākotnējo masīvu

un tā vietā izveidojiet jaunu.

Ja zināt elementu indeksu

Pieņemsim, ka jums ir masīvs un vēlaties noņemt elementu pozīcijā i .

Viens veids ir izmantot slice() :

const vienumi = ["a", "b", "c", "d", "e", "f"] const i = 3 const filtrētiElementi = vienumi.slice(0, i-1).concat(items. slice(i, items.length)) console.log(filteredItems)

slice() izveido jaunu masīvu ar saņemtajiem indeksiem. Mēs vienkārši izveidojam jaunu masīvu — no sākuma līdz indeksam, kuru vēlamies dzēst, un savienojam citu masīvu no pirmās pozīcijas, kas seko tai, kuru mēs izdzēsām, līdz masīva beigām. Ja jūs zināt nozīmiŠajā gadījumā viena laba iespēja ir izmantot filtru (), kas piedāvā vairāk

deklaratīvs

pieeja:

const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter(prece => item !== valueToRemove) konsole.log(filtrētie vienumi)

Tas izmanto ES6 bultiņu funkcijas. Varat izmantot tradicionālās funkcijas, lai atbalstītu vecākas pārlūkprogrammas:

const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter(function(item) ( atgriešanās vienums != = valueToRemove )) console.log(filtrēti vienumi)

vai arī varat izmantot Babel un pārveidot ES6 kodu atpakaļ uz ES5, lai padarītu to lasāmāku vecākām pārlūkprogrammām, taču savā kodā ierakstiet modernu JavaScript.

Vairāku vienumu noņemšana

Ko darīt, ja viena elementa vietā vēlaties dzēst vairākus elementus?

Atradīsim vienkāršāko risinājumu.

const items = ["a", "b", "c", "d", "e", "f"] const removeItem = (preces, i) => items.slice(0, i-1).concat (items.slice(i, items.length)) ļaujiet filteredItems = removeItem(preces, 3) filteredItems = removeItem(filtrēti vienumi, 5) //["a", "b", "c", "d"] konsole. žurnāls (filtrēti vienumi)

Pēc vērtības

Varat meklēt iekļaušanu atzvanīšanas funkcijā:

const items = ["a", "b", "c", "d", "e", "f"] const vērtībasNoņemt = ["c", "d"] const filteredItems = vienumi.filter(item => !valuesToRemove.includes(item)) // ["a", "b", "e", "f"] console.log(filteredItems)

Izvairieties no sākotnējā masīva mutācijas

splice() (nejaukt ar slice()) mutē sākotnējo masīvu, un no tā ir jāizvairās.

Man ir šāds masīvs:

Man ir jāizņem minimālā un maksimālā svara vērtības. Šajā piemērā

$min_value = 175

$max_value = 200

Vai ir kāda palīdzība, kā to izdarīt? Paldies!

2018-05-01 03:06

Atbildes:

1. iespēja: vispirms salīdziniet masīvu, lai iegūtu šos skaitļus (nevis pilnu informāciju):

$skaitļi = masīva_kolonna($masīvs, "svars")

Tad jūs saņemat min un max:

$min = min($skaitļi); $maks. = max($skaitļi);

2. iespēja. (Tikai tad, ja jums nav PHP 5.5.) Tas pats, kas 1. iespēja, bet, lai iegūtu vērtības, izmantojiet ary_map:

$skaitļi = array_map(function($details) ( return $details["Svars"]; ), $masīvs);

3. iespēja.

4. iespēja: ja jums ir nepieciešama minimālā maksimālā vērtība, array_reduce() var būt ātrāks:

$min = masīvs_samazināt($masīvs, funkcija($min, $details) ( return min($min, $details["svars"]); ), PHP_INT_MAX);

2018-05-01 03:11

Foreach ($masīvs kā $k => $v) ( $tArray[$k] = $v["Svars"]; ) $min_value = min($tArray); $maksimālā_vērtība = max($tMasīvs);

2018-05-01 03:09

Cilvēkiem, kuri izmanto PHP 5.5+, to var izdarīt daudz vienkāršāk ar array_column Nav nepieciešami šie neglītie masīvi.

Kā iegūt maksimālo vērtību:

$lielākais_svars = max(masīvs_kolonna($detaļas, "Svars"));

Kā iegūt minimālo vērtību

$mazākais_svars = min(masīvs_kolonna($detaļas, "Svars"));

2018-01-24 11:04

Minimālās un maksimālās atrašanas problēmu var viegli atrisināt, izmantojot tikai divus papildu atmiņas slotus

2018-05-01 06:08

2018-01-10 06:44

2017-11-11 19:33

$Location_Category_array = masīvs(5,50,7,6,1,7,7,30,50,50,50,40,50,9,9,11,2,2,2,2,2,11,21 ,21,1,12,1,5); asort($Location_Category_masīvs); $count=array_count_values($Location_Category_array);//Saskaita vērtības masīvā, atgriež asociēto masīvu print_r($count);
$maksimālais izmērs = 0;
$maksimālā vērtība = 0;

foreach($count as $a=>$y)( echo "

".$a."=".$y; if($y>=$maksimālā vērtība)( $maksimālā vērtība = $y; if($a>$ maxsize)( $ maxsize = $a; ) ) ) echo " max = ".$maksimālais izmērs;

(PHP 4, PHP 5, PHP 7)

min — Atrod mazāko vērtību Apraksts Atrod mazāko vērtību Ja tiek nodots tikai viens arguments - skaitļu masīvs,

komentēt:
Dažādu veidu vērtības tiek salīdzinātas, izmantojot standarta salīdzināšanas noteikumus. Piemēram, virkne, kas nav ciparu ( stīga) tiks salīdzināts ar veselu skaitli ( vesels skaitlis), it kā tas būtu vienāds 0 , bet vairākas rindas ( stīga) tiks salīdzināti alfabētiskā secībā. Atgrieztā vērtība saglabās sākotnējo mainīgā veidu bez konvertēšanas.

Atgriešanās vērtības

Funkcija Atrod mazāko vērtību atgriež parametra vērtību, kas tiek uzskatīta par "mazāko" saskaņā ar standarta salīdzināšanas noteikumiem. Ja vairākas vērtības dažādi veidi ir vienādi viens ar otru (t.i. 0 Un "abc"), tad pirmais tiks atgriezts.

Piemēri

1. piemērs Lietošanas piemērs Atrod mazāko vērtību

atbalss min(2, 3, 1, 6, 7); // 1
echo min (masīvs(2 , 4 , 5 )); // 2

// Virkne "sveiki", salīdzinot ar int, tiek uzskatīta par 0
// Tā kā abas vērtības ir vienādas, parametru secība nosaka rezultātu
echo min(0, "sveiks"); // 0
atbalss min ("sveiks" , 0 ); // sveiks

// Šeit mēs salīdzinām -1< 0, поэтому -1 является наименьшим значением
atbalss min ("sveiks" , - 1 ); // -1

// Salīdzinot dažāda garuma masīvus, min atgriezīs īsāko
$val = min (masīvs(2 , 2 , 2 ), masīvs(1 , 1 , 1 , 1 )); // masīvs(2, 2, 2)

// Vairāki vienāda garuma masīvi tiek salīdzināti no kreisās puses uz labo
// šim piemēram: 2 == 2, bet 4< 5
$val = min (masīvs(2 , 4 , 8 ), masīvs(2 , 5 , 1 )); // masīvs(2, 4, 8)

// Ja tiek salīdzināts masīvs un masīvs, kas nav masīvs, masīvs nekad netiks atgriezts
// jo masīvi tiek uzskatīti par lielākiem par visām pārējām vērtībām
$val = min ("virkne" , masīvs(2 , 5 , 7 ), 42 ); //string

// Ja viens arguments ir NULL vai Būla vērtība, tas tiks salīdzināts ar citiem
// izmantojot kārtulu FALSE< TRUE, учитывая остальные типы аргументов
// Dotajā piemērā -10 un 10 tiek uzskatīti par TRUE
$val = min (- 10 , FALSE , 10 ); // FALSE
$val = min (- 10 , NULL , 10 ); // NULL

// no otras puses, 0 tiek uzskatīts par FALSE, tāpēc tas ir "mazāks" nekā TRUE
$val = min(0, TRUE); // 0
?>

Man ir masīvs šādā formātā:

Masīvs ( => Masīvs ( => 117 => Tīkls => 16) => Masīvs ( => 188 => FTP => 23) => Masīvs ( => 189 => Internets => 48))

Vai tur labs veids vai iegūt "skaita" minimālās un maksimālās vērtības? Es varētu to izdarīt, izmantojot vairākas cilpas, bet es domāju, ka varētu būt labāks veids.

Atšķirībā no citām, šai problēmai nevar izmantot funkcijas min () / max (), jo šīs funkcijas nesaprot tām nodoto datu masīvus (masīvus). Šīs funkcijas darbojas tikai skalārā masīva elementiem.

SĀKUMA ATTĒLS

Iemesls, kāpēc, izmantojot min () un max (), šķiet, ir pareiza atbilde, ir tāpēc, ka masīvi tiek veidoti uz veseliem skaitļiem, kas ir nenoteikta darbība:

Pārveidošanas uzvedība uz veselu skaitli citiem veidiem nav definēta. Nepaļaujieties uz novēroto uzvedību, jo tā var mainīties bez brīdinājuma.

Mans iepriekš minētais apgalvojums par tipa liešanu bija nepareizs. Faktiski min () un max () darbojas ar masīviem, bet ne tā, kā tie darbojas operētājsistēmā. Izmantojot min() un max() ar vairākiem masīviem vai masīva elementu masīvu, salīdziniet elementus pa elementiem no kreisās puses uz labo:

$val = min(masīvs(2, 4, 8), masīvs(2, 5, 1)); // masīvs(2, 4, 8) /* * pirmais elements salīdzinājumā ar pirmo elementu: 2 == 2 * otrais elements salīdzinājumā ar otro elementu: 4< 5 * first array is considered the min and is returned */

Pārtulkojot problēmu, OP parāda, kāpēc tieši min () un max () izmantošana dod pareizo rezultātu. Pirmie masīva elementi ir id , tāpēc min() un max() tos vispirms salīdzina, starp citu, novedot pie pareizā rezultāta, jo zemākais id ir tas, kuram ir vismazākais skaits, un augstākais id ir tas. kam ir vislielākais skaits.

BEIGAS EDIT

Pareizais veids ir izmantot cilpu.

$a = masīvs(masīvs("id" => 117, "nosaukums" => "Tīkls", "skaits" => 16), masīvs("id" => 188, "nosaukums" => "FTP", " skaits" => 23), masīvs("id" => 189, "nosaukums" => "Internets", "skaits" => 48)); $min = PHP_INT_MAX; $maks. = 0; foreach ($a kā $i) ($min = min($min, $i["count"]); $max = max($max, $i["count"]); )

Varat izmantot funkcijas max () un min ().

Ko jūs darījāt ar vairākām cilpām? Pietiek ar vienu :)

Iegūstiet pirmo elementu, saskaitot gan $min, gan max
atkārtojiet pārējo, salīdziniet skaitu ar katru $min un $max, ja mazāks/lielāks, piešķiriet jaunu skaitīšanas vērtību

Varat izmantot funkcijas max/min, jo tās atgriezīs masīvu, kas satur katra indeksa maksimālo/minimālo vērtību. Jūsu piemērā ir jāatgriež masīvs (189, "Tīkls", 48), ja maks. Pēc tam varat iegūt rezultātu no šī masīva.

Tā atjaunināšana nedarbojas, kā es izslēdzu. Man lapas piemērs ir maldinošs, un piemērs sniedz pareizo rezultātu, izmantojot max, taču tā ir tikai sakritība.

Šķiet, ka 2D masīvā nevar izmantot max(). Tas vienkārši atgriež lielāko masīvu, nevis katra indeksa max() (kā norādīts vairākās atbildēs).

$skaits = masīvs(); foreach($arr kā $_arr) ( $count = $_arr["count"]; ) var_dump(max($count), min($count));

Vai ir līdzvērtīgs iebūvēts funkcija šim? (pat bez iespējas testēšana)

/** * izgūst kolonnu no 2D masīva ar izvēles atlasi pār citu kolonnu * * @param $ aArray, lai izgūtu no * @param $ aColName izgūstamās kolonnas nosaukums, piem. "O_NAME" * @param $aColTest (neobligāti) kolonnas nosaukums, lai palaistu testu, piemēram, "O_ID" * @param $aTest (neobligāti) virkne testa piem. ">=10", "== "". $Toto. "" " * @return 1D masīvs ar izvilktu tikai kolonnu * @access public * / funkcija extractColFromArray ($aArray, $aColName, $aColTest = "", $ aTest = "") ( $mRes = array()); foreach ($aArray kā $rinda) ( if (($aColTest == "") || (eval("return". $row[$aColTest]. $ aTest ";"))) ( $ mRes = $ rinda [ $ aColName ]; ) ) return $ mRes ) // extractColFromArray

uptostart.ru Ziņas. Spēles. Norādījumi. Internets. Birojs.