PHP Szerezze meg a minimális és maximális értékeket egy kétdimenziós asszociatív tömbben. Min - Megkeresi a legkisebb Php értéket, a tömb minimális értékeinek számát

(PHP 4, PHP 5, PHP 7)

perc — Megkeresi a legkisebb értéket

Leírás

Ha csak egy argumentumot adunk át - egy számtömböt, min() közülük a legkisebbet adja vissza. Ha az első argumentum egész szám vagy lebegőpont, akkor még legalább egynek kell lennie. Ebben az esetben a függvény min() visszaadja közülük a legkisebbet.

Megjegyzés:

A különböző típusú értékek összehasonlítása szabványos összehasonlítási szabályokkal történik. Például egy nem numerikus karakterlánc ( húr) egy egész számmal lesz összehasonlítva ( egész szám), mintha egyenlő lenne 0 , de több sor ( húr) betűrendben lesz összehasonlítva. A visszatérési érték konverzió nélkül megtartja a változó eredeti típusát.

Visszatérési értékek

Funkció min() a szabványos összehasonlítási szabályok szerint „legkisebbnek” tekintett paraméter értékét adja vissza. Ha több különböző típusú érték egyenlő egymással (pl. 0 És "ABC"), akkor az elsőt visszaküldjük.

Példák

1. példa Használati példa min()

echo min(2, 3, 1, 6, 7); 1
echo min (array(2 , 4 , 5 )); 2

// A „hello” karakterláncot az int karakterlánccal összehasonlítva a rendszer 0-ként kezeli
// Mivel mindkét érték egyenlő, a paraméterek sorrendje határozza meg az eredményt
echo min(0, "hello"); // 0
echo min ("hello" , 0 ); // Helló

// Itt összehasonlítjuk a -1-et< 0, поэтому -1 является наименьшим значением
echo min ("hello" , - 1 ); // -1

// A különböző hosszúságú tömbök összehasonlításakor a min a rövidebbet adja vissza
$val = min (array(2 , 2 , 2 ), array(1 , 1 , 1 , 1 )); // array(2, 2, 2)

// Több azonos hosszúságú tömb összehasonlítása balról jobbra történik
// ennél a példánál: 2 == 2, de 4< 5
$val = min (array(2 , 4 , 8 ), array(2 , 5 , 1 )); // array(2, 4, 8)

// Ha egy tömböt és egy nem tömböt hasonlít össze, a tömb soha nem kerül visszaadásra
// mivel a tömböket minden más értéknél nagyobbnak tekintjük
$val = min ("karakterlánc" , array(2 , 5 , 7 ), 42 ); //húr

// Ha az egyik argumentum NULL vagy logikai érték, akkor a rendszer összehasonlítja a többivel
// a FALSE szabály használatával< TRUE, учитывая остальные типы аргументов
// A megadott példában a -10 és a 10 értéke IGAZ
$val = min (- 10 , HAMIS , 10 ); // HAMIS
$val = min (- 10 , NULL , 10 ); // NULLA

// másrészt a 0-t HAMIS-ként kezeli, tehát "kevesebb", mint IGAZ
$érték = min(0, IGAZ); // 0
?>

A tömbök az információ tárolásának egyik kényelmes strukturált módja. Egy ilyen tömb minden elemének megvan a maga helye, saját kulcsa és értéke. A tömbök tartalma eltérő lehet, például számokat, neveket vagy egyszerű numerikus értékeket tartalmazó adatbázis. Ha már a számokról beszélünk, akkor sokféle feladattal állhatunk szemben, például a maximális vagy minimális érték levezetésével. Ma arról fogunk beszélni, hogyan oldják meg ezt a különböző programozási nyelveken.

Egydimenziós tömb legnagyobb és legkisebb értékének megkeresése PHP-ben

Minden tömb szerkezetében különbözik. Vegyünk két egyszerű egydimenziós tömböt, amelyek közül az egyik nem tartalmaz kulcsokat:

$saját_tömb = tömb(22, 24, 37, 74, 23, 2, 10);

és egy azonos az előzővel, de kulcsokkal:

$saját_tömb = tömb(1 => 22, 2 => 24, 3 => 37, 4 => 74, 5 => 23, 6 => 2, 7 => 10);

Próbáljuk meg megjeleníteni ennek a tömbnek a maximális és minimális értékét. Ehhez a szabványos függvényeket fogjuk használni " max"És" min" rendre:

Echo max($my_array); // Nyomtatás 74 echo min($my_array); // Nyomtatás 2

Ha közelebbről megvizsgáljuk a második tömböt, akkor ennek eredményeként megkapjuk a maximális vagy minimális értékek kulcsát.

Egy tömb használata példaként

$saját_tömb = tömb(1 => 22, 2 => 24, 3 => 37, 4 => 74, 5 => 23, 6 => 2, 7 => 10);

így fog kinézni:

$max = tömb_kulcsok($saját_tömb, max($saját_tömb)); $max = $max;// Maximális érték kulcs $min = array_keys($my_array, min($my_array)); $perc = $perc; // Minimális érték kulcs echo $max; // Nyomtassa ki a maximális érték eredményét

Ennek megfelelően a maximális érték kulcsa „4”, a minimális érték pedig „6”.

Többdimenziós tömb legnagyobb és legkisebb értékének megkeresése PHP-ben

A többdimenziós tömböket egymásba ágyazásuk különbözteti meg. Például egy kétdimenziós tömb a kulcsok nélkül így nézne ki:

$saját_tömb = tömb(tömb(22, 24, 37), tömb(74, 23, 2), tömb(10));

És ennek megfelelően bizonyos kulcsokkal:

$saját_tömb = tömb(tömb(1 => 22, 2 => 24, 3 => 37), tömb(4 => 74, 5 => 23, 6 => 2), tömb(7 => 10));

Ebben az esetben a maximális és minimális értékek megtalálása kissé nehézkes, de lehetséges.

Először is, hogy itt megtaláljuk a maximumot és a minimumot, átalakítjuk a tömböt egydimenzióssá:

$out_tömb = array(); foreach($saját_tömb mint $al_tömb) ( $out_array = array_merge($out_array, $sub_array); )

A tervezés mindkét fenti opciónál működik. Ezután egy egydimenziós tömb példáját követve megjelenítjük a szükséges adatokat:

Echo max($out_array); // Nyomtatás 74 echo min($out_array); // Nyomtatás 2

Kis bónuszként adok egy példát egy másik népszerű kétdimenziós tömbre:

$my_array = array(array("id" => "1", "date" => "2018-03-19", "price" => "5",), array ("id" => "2" , "dátum" => "2018-03-19", "ár" => "50", tömb ("id" => "3", "dátum" => "2018-03-19", " ár" => "25"));

Népszerűség alatt nem a tartalmat értem, hanem annak felépítésének példáját. Tegyük fel, hogy itt csak az „ár” gombok maximális és minimális értékét kell kiadnia.

Az első dolog, amire ebben az esetben szüksége van, egy új tömb beszerzése csak ezekkel az adatokkal:

$számok = tömb_oszlop($saját_tömb, "ár");

Echo min($számok); // Nyomtatás 5 echo max($numbers); // Nyomtatás 50

Ezzel befejeződik a PHP tömbjeivel végzett munka. Ha hirtelen eltér a tömb szerkezete, és nem tudja, hogyan kell feldolgozni, tegye fel a megfelelő kérdést a megjegyzésekben, megpróbálok segíteni.

Egydimenziós tömb legnagyobb és legkisebb értékének megkeresése JavaScriptben

A PHP-vel ellentétben a JavaScript tömbjei sokkal egyszerűbbek, és egy egyszerű egydimenziós tömb így fog kinézni:

Var my_array = ;

Itt nincsenek indexek feltüntetve. Annak érdekében, hogy megtaláljuk a maximális és minimális értéket ebben a tömbben, két egyszerű saját függvényt írunk:

Függvény arrayMax(tömb) ( return array.reduce(function(a, b) ( return Math.max(a, b); )); ) function arrayMin(array) ( return array.reduce(function(a, b) ( vissza Math.min(a, b); )); )

amelyek segítségével megtaláljuk a számunkra szükséges értékeket. Használata is egyszerű:

Alert(arrayMax(my_array)); // Nyomtatás 74 alert(arrayMin(my_array)); // Nyomtatás 2

Ebben az esetben a „2” és „74” számok jelennek meg a képernyőn a tömb minimális és maximális értékeként.

Többdimenziós tömb legnagyobb és legkisebb értékének megkeresése JavaScriptben

A JavaScript többdimenziós tömbjei ugyanolyan egyszerűek, és így néznek ki:

Var my_array = [ , , ];

Próbáljuk meg itt megtalálni a maximumot és a minimumot. Először írunk egy függvényt, amellyel a már ismert séma szerint ezt a tömböt egydimenziósként ábrázoljuk:

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

És a tárgy használata " Math"megkapjuk a szükséges értékeket:

Var min = Math.min.apply(null, out_array); // Get 2 var max = Math.max.apply(null, out_array); // Get 74 alert(max); // Nyomtassa ki a 74-et a képernyőn

Valójában az objektum helyett " Math„A verzióban használt függvényeinket egydimenziós tömbbel is használhatja, de hogy megértse, hogy bármilyen probléma többféleképpen is megoldható – itt egy kicsit más megoldást adtam.

Nos, a hagyományoknak megfelelően - egy kis bónusz. Tekintsünk egy másik többdimenziós tömböt a következő szerkezettel:

Var my_array = [["Egy", "2018-03-19", 5], ["Kettő", "2018-03-19", 50], ["Három", "2018-03-19", 25 ], ];

Amint látjuk, az egyes tömbök számértékei a harmadik helyen állnak. Írjunk egy kódot, és kapjuk meg a megfelelő értékeket ebből az adatból:

Var min = +Végtelen; var max = -Végtelen; my_array.forEach(function(item) ( if(+elem< min) { min =+ item; // Ищем минимальное значение } }); my_array.forEach(function(item) { if(+item >max) ( max =+ elem; // A maximális érték keresése ) )); figyelmeztetés(min+" "+max); // Az eredmény megjelenítése a képernyőn

Ez minden. Ne felejtse el támogatni a projektet. Sok érdekes dolog vár rád!

Van egy tömböm ebben a formátumban:

Tömb ( => Tömb ( => 117 => Hálózat => 16) => Tömb ( => 188 => FTP => 23) => Tömb ( => 189 => Internet => 48))

Van valami jó módszer a "count" min és max értékeinek megszerzésére? Ezt több hurok használatával is megtehetném, de úgy gondoltam, hogy lehet jobb módszer is.

Másokkal ellentétben nem használhatja a min() / max() függvényeket erre a problémára, mivel ezek a függvények nem értik a nekik átadott adattömböket (tömböket). Ezek a függvények csak skaláris tömbelemeknél működnek.

KEZDŐ KÉP

A min() és max() használata azért tűnik a helyes válasznak, mert a tömbök egész számokra írnak, ami nem definiált viselkedés:

Az egész számmá való konverziós viselkedés más típusoknál nincs meghatározva. Ne hagyatkozzon semmilyen megfigyelt viselkedésre, mert az figyelmeztetés nélkül megváltozhat.

A fenti állításom a típusöntéssel kapcsolatban téves volt. Valójában a min() és max() működik tömbökkel, de nem úgy, ahogy az OP-nak szüksége van rájuk. Ha több tömbhöz vagy tömbelemek tömbjéhez használja a min() és max() függvényt, hasonlítsa össze az elemeket elemenként balról jobbra:

$val = min(tömb(2, 4, 8), tömb(2, 5, 1)); // array(2, 4, 8) /* * első elem az első elemhez képest: 2 == 2 * második elem a második elemhez képest: 4< 5 * first array is considered the min and is returned */

A feladatra lefordítva az OP megmutatja, hogy a min() és max() közvetlen használata miért adja a helyes eredményt. A tömb első elemei az id , így a min() és max() ezeket hasonlítja össze először, ami a helyes eredményhez vezet, mert a legalacsonyabb id az, amelyiknek a legkisebb a száma, a legmagasabb pedig az. amelynek a legmagasabb a száma.

SZERKESZTÉS VÉGE

A helyes módszer a hurok használata.

$a = array(array("id" => 117, "name" => "Networking", "count" => 16), array("id" => 188, "name" => "FTP", " count" => 23), array("id" => 189, "name" => "Internet", "count" => 48)); $perc = PHP_INT_MAX; $max = 0; foreach ($a mint $i) ( $min = min($min, $i["count"]); $max = max($max, $i["count"]); )

Használhatja a max() és min() függvényeket.

Mit csináltál több hurokkal? Egy elég :)

1. Szerezze meg az első elemet úgy, hogy megszámolja mind a $min, mind a max értékét
2. iteráld át a többit, hasonlítsd össze a számot minden $min és $max értékkel, ha kisebb/nagyobb adj hozzá új számértéket

Használhatja a max/min függvényeket, mivel ezek az egyes indexek maximumát/minimumát tartalmazó tömböt adnak vissza. A példának az array(189, "Networking", 48) értéket kell visszaadnia max. Ezután megragadhatja a pontszámot ebből a tömbből.

A frissítés nem működik, ahogy kizártam. A man page példa félrevezető, és a példa a helyes eredményt adja a max használatával, de ez csak véletlen.

Úgy tűnik, hogy nem használhatja a max()-t egy 2D tömbön. Csak a legnagyobb tömböt adja vissza az egyes indexek max() helyett (amint azt több válasz is tartalmazza).

$count = array(); foreach($arr mint $_arr) ( $count = $_arr["count"]; ) var_dump(max($count), min($count));

Van-e megfelelője beépített funkció ehhez? (lehetőség nélkül is tesztelés)

/** * lekér egy oszlopot egy 2D-s tömbből egy másik oszlop helyett választható kijelöléssel * * @param $ aArray to retrieve from * @param $ aColName a lekérni kívánt oszlop neve, pl. "O_NAME" * @param $aColTest (opcionális) oszlopnév a teszt futtatásához, pl. "O_ID" * @param $aTest (nem kötelező) karakterlánc a teszt pl. ">=10", "== "". $Toto. "" " * @return 1D tömb csak az oszlop kibontásával * @access public * / function extractColFromArray ($aArray, $aColName, $aColTest = "", $ aTest = "") ( $mRes = array()); foreach ($aArray mint $sor) ( if (($aColTest == "") || (eval("return". $row[$aColTest]. $ aTest. ";"))) ( $ mRes = $ row [ $ aColName]; ) ) return $ mRes; ) // extractColFromArray