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

// სტრიქონი "hello", 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 ("სტრიქონი" , მასივი(2, 5, 7), 42); //სტრიქონი

// თუ ერთი არგუმენტი არის NULL ან ლოგიკური, ის შედარდება დანარჩენებთან
// FALSE წესის გამოყენებით< TRUE, учитывая остальные типы аргументов
// მოცემულ მაგალითში -10 და 10 განიხილება როგორც TRUE
$val = min (- 10 , FALSE , 10 ); // მცდარი
$val = min (- 10 , NULL , 10 ); // NULL

// მეორეს მხრივ, 0 განიხილება როგორც FALSE, ამიტომ ის არის "ნაკლები" ვიდრე TRUE
$val = min(0, TRUE); // 0
?>

მასივები ინფორმაციის შესანახად ერთ-ერთი მოსახერხებელი სტრუქტურირებული გზაა. ასეთი მასივის თითოეულ ელემენტს აქვს თავისი ადგილი, თავისი გასაღები და მნიშვნელობა. მასივების შიგთავსი შეიძლება იყოს განსხვავებული, როგორიცაა, მაგალითად, რიცხვების, სახელების ან მარტივი რიცხვითი მნიშვნელობების მონაცემთა ბაზა. ციფრებზე საუბრისას, ჩვენ შეიძლება შეგვხვდეს სხვადასხვა სახის ამოცანები, მაგალითად, მაქსიმალური ან მინიმალური მნიშვნელობის გამოყვანა. დღეს ჩვენ ვისაუბრებთ იმაზე, თუ როგორ წყდება ეს პროგრამირების სხვადასხვა ენაზე.

PHP-ში ერთგანზომილებიანი მასივის უდიდესი და უმცირესი მნიშვნელობის პოვნა

ყველა მასივი განსხვავდება მათი სტრუქტურით. განვიხილოთ ორი მარტივი ერთგანზომილებიანი მასივი, რომელთაგან ერთი არ შეიცავს გასაღებებს:

$my_მასივი = მასივი(22, 24, 37, 74, 23, 2, 10);

და ერთი წინას იდენტური, მაგრამ გასაღებებით:

$my_მასივი = მასივი (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_მასივი = მასივი (1 => 22, 2 => 24, 3 => 37, 4 => 74, 5 => 23, 6 => 2, 7 => 10);

ეს ასე გამოიყურება:

$max = მასივის_გასაღები ($my_array, max($my_array)); $max = $max;// მაქსიმალური მნიშვნელობის გასაღები $min = array_keys($my_array, min($my_array)); $min = $min; // მინიმალური მნიშვნელობის გასაღები echo $max; // ამობეჭდეთ მაქსიმალური მნიშვნელობის შედეგი

შესაბამისად, მაქსიმალური მნიშვნელობის გასაღები არის "4", ხოლო მინიმალური მნიშვნელობა არის "6".

მრავალგანზომილებიანი მასივის უდიდესი და უმცირესი მნიშვნელობის პოვნა PHP-ში

მრავალგანზომილებიანი მასივები გამოირჩევიან ბუდეებით. მაგალითად, ორგანზომილებიანი მასივი ასე გამოიყურება კლავიშების გარეშე:

$my_მასივი = მასივი(მასივი(22, 24, 37), მასივი(74, 23, 2), მასივი(10));

და, შესაბამისად, გარკვეული გასაღებებით:

$my_მასივი = მასივი(მასივი(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", "ფასი" => "5",), მასივი ("id" => "2" , "თარიღი" => "2018-03-19", "ფასი" => "50",), მასივი ("id" => "3", "თარიღი" => "2018-03-19", " ფასი" => "25"));

პოპულარობაში არ ვგულისხმობ შინაარსს, არამედ მისი სტრუქტურის მაგალითს. ვთქვათ, რომ აქ თქვენ უნდა გამოიყვანოთ მხოლოდ "ფასის" გასაღებების მაქსიმალური და მინიმალური მნიშვნელობები.

პირველი, რაც ამ შემთხვევაში გჭირდებათ, არის ახალი მასივის მიღება მხოლოდ ამ მონაცემებით:

$numbers = array_column($my_array, "ფასი");

ექო მინ($ნომრები); // ამობეჭდვა 5 echo max($numbers); // ბეჭდვა 50

ეს ასრულებს მასივებს მუშაობას PHP-ში. თუ მოულოდნელად თქვენი მასივის სტრუქტურა განსხვავებულია და არ იცით მისი დამუშავება, დასვით შესაბამისი შეკითხვა კომენტარებში, ვეცდები დაგეხმაროთ.

JavaScript-ში ერთგანზომილებიანი მასივის უდიდესი და უმცირესი მნიშვნელობის პოვნა

PHP-სგან განსხვავებით, JavaScript-ში მასივების ტიპი გაცილებით მარტივია და მარტივი ერთგანზომილებიანი მასივი ასე გამოიყურება:

ვარ ჩემი_მასივი = ;

აქ ინდექსები არ არის მითითებული. იმისათვის, რომ ვიპოვოთ მაქსიმალური და მინიმალური მნიშვნელობები ამ მასივში, ჩვენ დავწერთ ორ მარტივ ფუნქციას:

ფუნქცია arrayMax(მასივი) ( return array.reduce(function(a, b) ( return Math.max(a, b); )); ) ფუნქცია arrayMin(მასივი) ( return array.reduce(function(a, b) ( დაბრუნება Math.min(a, b); ));)

რომლებიც გამოიყენება ჩვენთვის საჭირო მნიშვნელობების მოსაძებნად. გამოყენება ასევე მარტივია:

Alert(arrayMax(my_array)); // Print 74 alert(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 = -Infinity; my_array.forEach(function(item) (if(+item< min) { min =+ item; // Ищем минимальное значение } }); my_array.forEach(function(item) { if(+item >max) ( max =+ ელემენტი; // ვეძებთ მაქსიმალურ მნიშვნელობას ) )); alert(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)); // array(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 = მასივი(მასივი("id" => 117, "name" => "ქსელი", "count" => 16), მასივი ("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 ფუნქციები, რადგან ისინი დააბრუნებენ მასივს, რომელიც შეიცავს თითოეული ინდექსის მაქსიმუმს/მინიმუმს. თქვენმა მაგალითმა უნდა დააბრუნოს array (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 (არასავალდებულო) სტრიქონი ტესტისთვის ex. ">=10", "== "". $Toto. "" " * @return 1D მასივი ამოღებულია მხოლოდ სვეტით * @access public * / ფუნქცია extractColFromArray ($aArray, $aColName, $aColTest = "", $ aTest = "") ($mRes = მასივი()); foreach ($aArray როგორც $row) ( if (($aColTest == "") || (eval("return". $row[$aColTest]. $ aტესტი. ";"))) ($ mRes = $ row [ $ aColName]; ) ) დააბრუნეთ $ mRes;) // extractColFromArray