ደቂቃ - ትንሹን እሴት ያገኛል። ዝቅተኛ - ትንሹን እሴት በ php ድርድር ውስጥ ዝቅተኛ እሴት ያገኛል

18.07.2021 የጨዋታ መጫወቻዎች

አደራደር መረጃን ለማከማቸት አመቺ ከሆኑ የተዋቀሩ መንገዶች አንዱ ነው። የእንደዚህ አይነት ድርድር እያንዳንዱ አካል የራሱ ቦታ፣ የራሱ ቁልፍ እና እሴት አለው። የድርድር ይዘቱ የተለየ ሊሆን ይችላል፣ ለምሳሌ የቁጥሮች መሰረት፣ ስሞች ወይም ቀላል የቁጥር እሴቶች። ስለ ቁጥሮች ስንናገር፣ የተለያዩ አይነት ሥራዎችን ሊያጋጥመን ይችላል፣ ለምሳሌ፣ ከፍተኛውን ወይም ዝቅተኛውን እሴት በመቀነስ። ዛሬ ይህ በተለያዩ የፕሮግራሚንግ ቋንቋዎች እንዴት እንደሚፈታ እንነጋገራለን.

በ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 = $ከፍተኛ;// ከፍተኛው የእሴት ቁልፍ $min = array_keys($my_array፣ min($my_array)); $ደቂቃ = $ደቂቃ; // ዝቅተኛ እሴት ቁልፍ አስተጋባ $ 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", "ዋጋ" => "5", ድርድር ("id" => "2" , "ቀን" => "2018-03-19", "ዋጋ" => "50", ድርድር ("id" => "3", "ቀን" => "2018-03-19", " ዋጋ" => "25",));

ታዋቂነት ስል ይዘቱን ማለቴ ሳይሆን የአወቃቀሩ ምሳሌ ነው። እዚህ የ “ዋጋ” ቁልፎችን ብቻ ከፍተኛውን እና ዝቅተኛውን እሴት ማውጣት ያስፈልግዎታል እንበል።

በዚህ ጉዳይ ላይ የሚያስፈልግዎ የመጀመሪያው ነገር ማግኘት ነው አዲስ ድርድርበዚህ ውሂብ ብቻ፡-

$numbers = array_column($my_array፣ "ዋጋ");

ኢኮ ደቂቃ($ ቁጥሮች); // 5 echo max ($ ቁጥሮች) አትም; // አትም 50

ይህ በ PHP ውስጥ ካሉ ድርድሮች ጋር ስራውን ያጠናቅቃል። በድንገት የድርድርዎ መዋቅር የተለየ ከሆነ እና እንዴት እንደሚሰሩት ካላወቁ በአስተያየቶቹ ውስጥ ተገቢውን ጥያቄ ይጠይቁ, እርስዎን ለመርዳት እሞክራለሁ.

በጃቫስክሪፕት ውስጥ የአንድ-ልኬት ድርድር ትልቁን እና ትንሹን እሴት ማግኘት

እንደ ፒኤችፒ ሳይሆን፣ በጃቫ ስክሪፕት ያለው የድርድር አይነት በጣም ቀላል ነው፣ እና ቀላል ባለ አንድ-ልኬት ድርድር ይህን ይመስላል።

Var my_array =;

እዚህ ምንም ጠቋሚዎች አልተጠቆሙም። በዚህ ድርድር ውስጥ ከፍተኛውን እና አነስተኛ እሴቶችን ለማግኘት የራሳችንን ሁለት ቀላል ተግባራት እንጽፋለን-

ተግባር arrayMax (ድርድር) (መመለስ array. ቅነሳ (ተግባር (a, b) (Math.max (a, b) መመለስ); ተመላሽ Math.min (a, b));

የምንፈልጋቸውን እሴቶች ለማግኘት ጥቅም ላይ የሚውሉ. አጠቃቀሙም ቀላል ነው፡-

ማንቂያ(arrayMax(my_array)); // አትም 74 ማንቂያ (arrayMin (my_array)); // ማተም 2

በዚህ አጋጣሚ "2" እና "74" ቁጥሮች በስክሪኑ ላይ እንደ ዝቅተኛው እና ከፍተኛው የድርድር ዋጋዎች ይታያሉ.

በጃቫስክሪፕት ውስጥ ባለ ብዙ ልኬት ድርድር ትልቁን እና ትንሹን እሴት ማግኘት

በጃቫስክሪፕት ውስጥ ያሉ ባለብዙ ልኬት ድርድሮች እንዲሁ ቀላል ናቸው፣ እና እነሱም ይህን ይመስላል።

Var my_array = [,,];

ከፍተኛውን እና ዝቅተኛውን እዚህ ለማግኘት እንሞክር። ለመጀመር ፣ አስቀድመን ባወቅነው እቅድ መሠረት ይህንን ድርድር እንደ አንድ-ልኬት የምንወክልበትን ተግባር እንጽፋለን-

Var out_array =; my_array.forEach (ተግባር (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 በስክሪኑ ላይ ያትሙ

በእውነቱ ፣ በእቃው ፋንታ ” ሒሳብ"በስሪት ውስጥ ጥቅም ላይ የዋሉ ተግባሮቻችንን ከአንድ-ልኬት ድርድር ጋር መጠቀም ይችላሉ ፣ ግን ማንኛውም ችግር በብዙ መንገዶች ሊፈታ እንደሚችል እንዲረዱ - እዚህ ትንሽ የተለየ መፍትሄ ሰጥቻለሁ።

ደህና, እንደ ባህል - ትንሽ ጉርሻ. ከሚከተለው መዋቅር ጋር ሌላ ባለብዙ-ልኬት አደራደርን እንመልከት።

ቫር my_array = [["አንድ"፣ "2018-03-19"፣ 5]፣ ["ሁለት"፣ "2018-03-19"፣ 50]፣ ["ሶስት"፣ "2018-03-19", 25 ],];

እንደምናየው፣ በእያንዳንዱ ድርድር ውስጥ ያሉት የቁጥር እሴቶች በሦስተኛ ደረጃ ላይ ይገኛሉ። አንዳንድ ኮድ እንጽፍ እና ከዚህ ውሂብ ብቻ ተዛማጅ እሴቶችን ያግኙ።

Var min = +Infinity; var max = -Infinity; my_array.ለእያንዳንዱ(ተግባር(ንጥል) (ከሆነ(+እቃ)< min) { min =+ item; // Ищем минимальное значение } }); my_array.forEach(function(item) { if(+item >ከፍተኛ) (ከፍተኛ =+ ንጥል; // ከፍተኛውን ዋጋ በመፈለግ ላይ))); ማንቂያ (ደቂቃ +"+ ከፍተኛ); // ውጤቱን በስክሪኑ ላይ አሳይ

ይኼው ነው። ፕሮጀክቱን መደገፍዎን አይርሱ. ብዙ አስደሳች ነገሮች ወደፊት ይጠብቁዎታል!

ቁልፍ አግኝ (9)

ይህ ድርድር አለኝ፡-

አደራደር (0 => አደራደር ("id" => "20110209172713", "ቀን" => "2011-02-09", "ክብደት" => "200", 1 => አደራደር ("id" => "20110209172747", "ቀን" => "2011-02-09", "ክብደት" => "180", 2 => አደራደር ("id" => "20110209172827", "ቀን" => "2011- 02-09", "ክብደት" => "175", 3 => አደራደር ("id" => "20110211204433", "ቀን" => "2011-02-11", "ክብደት" => "195 ",))

ዝቅተኛውን እና ከፍተኛውን የክብደት እሴቶችን ማውጣት አለብኝ. በዚህ ምሳሌ

$min_value = 175

$max_value = 200

ይህንን እንዴት ማድረግ እንደሚቻል ላይ ምንም እገዛ አለ? አመሰግናለሁ!

መልሶች

ፒኤችፒ 5.5+ ለሚጠቀሙ ሰዎች ይህ በarray_column በጣም ቀላል ሊሆን ይችላል። ለእነዚያ አስቀያሚ ድርድሮች አያስፈልጉም።

ከፍተኛውን ዋጋ እንዴት ማግኘት እንደሚቻል፡-

$highest_weight = ከፍተኛ(array_column ($ ዝርዝሮች፣ "ክብደት"));

ዝቅተኛውን እሴት እንዴት ማግኘት እንደሚቻል

$lowest_weight = ደቂቃ(array_column ($ ዝርዝሮች፣ "ክብደት"));

አማራጭ 1፡ በመጀመሪያ እነዛን ቁጥሮች ለማግኘት ድርድርን ሰብስብ (ሙሉ መረጃ አይደለም)፡

$numbers = array_column($array, "weight")

ከዚያ ደቂቃ እና ከፍተኛ ያገኛሉ፡-

$ ደቂቃ = ደቂቃ ($ ቁጥሮች); $ max = ከፍተኛ ($ ቁጥሮች);

አማራጭ 2. (PHP 5.5 ከሌለዎት ብቻ) ልክ እንደ አማራጭ 1 አይነት ነገር ግን እሴቶቹን ለመንጠቅ array_map ይጠቀሙ፡-

$numbers = array_map(ተግባር($ዝርዝሮች)($ ዝርዝሮችን መመለስ["ክብደት"]፤)፣$array);

አማራጭ 3.

አማራጭ 4፡ ደቂቃ ወይም ከፍተኛ ብቻ የሚያስፈልግዎ ከሆነ፣ array_reduce() ፈጣን ሊሆን ይችላል፡

$min = array_reduce($ ድርድር፣ ተግባር($ደቂቃ፣ $ዝርዝሮች) (ደቂቃ ተመለስ($ደቂቃ፣ $ ዝርዝሮች["ክብደት"]));፣ PHP_INT_MAX);

ይህ ከደቂቃ () ሰከንድ በላይ ይሰራል፣ ግን በጣም ፈጣን ናቸው። PHP_INT_MAX ቢበዛ ይጀምር እና ዝቅ እና ዝቅ ማለት አለበት። በ$ max ተመሳሳይ ነገር ማድረግ ይችላሉ፣ ግን በ0 ወይም -PHP_INT_MAX ይጀምራሉ።

አደራደር ("id" => "20110209172713", "ቀን" => "2011-02-09", "ክብደት" => "200", 1 => አደራደር ("id" => "20110209172747", " ቀን" => "2011-02-09", "ክብደት" => "180", 2 => ድርድር ("id" => "20110209172827", "ቀን" => "2011-02-09", "ክብደት" => "175", 3 => አደራደር ("id" => "20110211204433", "ቀን" => "2011-02-11", "ክብደት" => "195",)) ; foreach ($ ድርድር እንደ $ key => $ እሴት) ($ውጤት[$key] = $ ዋጋ["ክብደት"]፤ ) $ደቂቃ = ደቂቃ($ውጤት); $ max = ከፍተኛ ($ ውጤት); ማሚቶ "በሚነኑም ቁጥር ያለው ድርድር፡"$ ደቂቃ።
"; echo" ድርድር በከፍተኛ ቁጥር፡ ".$max"
"; ?>

Foreach ($ ድርድር እንደ $k => $ v) ( $tArray[$k] = $v["ክብደት"]; ) $min_value = ደቂቃ($tArray); $max_value = ከፍተኛ($tAray);

በ php ውስጥ መደርደር ሳይጠቀሙ አምስት ከፍተኛ እና ደቂቃ ቁጥሮችን ከአንድ ድርድር በፍጥነት ያትሙ፡-

የሰባት ከፍተኛ የሙቀት መጠኖች ዝርዝር፡-"፤ $m=ከፍተኛ($array)፤ ለ($i=1፤ $i<7 ; $i++) { $m[$i]=max(array_diff($array,$m)); } foreach ($m as $key =>$value) (" ".$value;) echo"
የሰባት ዝቅተኛ የሙቀት መጠኖች ዝርዝር፡ "$mi= ደቂቃ($array); ለ($i=1; $i<7 ; $i++) { $mi[$i]=min(array_diff($array,$mi)); } foreach ($mi as $key =>$value) ( አስተጋባ " ".$ እሴት; ) ?>

እንደ ደቂቃ ወይም ከፍተኛ ያለ አስቀድሞ የተገለጸ ተግባር ሳይጠቀምስ?

$arr =; $val = $arr; $n = ቆጠራ($arr); ለ($i=1;$i<$n;$i++) { if($val<$arr[$i]) { $val = $val; } else { $val = $arr[$i]; } } print($val);

የሚገርመው ከላይ ያሉት ሁለቱም መፍትሄዎች ተጨማሪ ማከማቻን በድርድር መልክ መጠቀማቸው (የመጀመሪያው አንደኛው እና ሁለተኛው አንድ ድርድር) እና በመቀጠል "ተጨማሪ ማከማቻ" ድርድርን በመጠቀም ደቂቃ እና ከፍተኛውን ያገኛሉ። ይህ በገሃዱ የፕሮግራሚንግ አለም ተቀባይነት ቢኖረውም (ስለ "ተጨማሪ" ማከማቻ ሁለት ቢትስ የሚሰጠው?) በፕሮግራሚንግ 101 ውስጥ "C" ያገኝልዎታል።

ደቂቃ እና ከፍተኛ የማግኘት ችግር በሁለት ተጨማሪ የማህደረ ትውስታ ቦታዎች በቀላሉ ሊፈታ ይችላል።

$first = intval ($ ግብዓት ["ክብደት")); $min = $መጀመሪያ; $ max = $ መጀመሪያ; foreach($ እንደ $ ውሂብ ግቤት) ($weight = intval($data["ክብደት")))፤ ከሆነ($ክብደት<= $min) { $min = $weight ; } if($weight >$max) ( $max = $weight; ) ) አስተጋባ" ደቂቃ = $ደቂቃ እና ከፍተኛ = $max \n ";

$num = ድርድር (0 => ድርድር ("id" => "20110209172713", "ቀን" => "2011-02-09", "ክብደት" => "200"), 1 => አደራደር ("መታወቂያ" => "20110209172747", "ቀን" => "2011-02-09", "ክብደት" => "180", 2 => አደራደር ("id" => "20110209172827", "ቀን" => "2011 - 02-09", "ክብደት" => "175"), 3 => አደራደር ("id" => "20110211204433", "ቀን" => "2011-02-11", "ክብደት" => "195 " ));

foreach($num እንደ $ key => $val) ($weight = $val["ክብደት"]፤) echo max($weight); echo min ($ ክብደት); .

አንዳንድ መንገዶች እነኚሁና። ጃቫ ስክሪፕትን በመጠቀም ኤለመንቱን ከድርድር ያስወግዱሁሉም የተገለጹ ዘዴዎች

ዋናውን ድርድር አይቀይሩ

እና በምትኩ አዲስ ይፍጠሩ.

የኤለመንቱን መረጃ ጠቋሚ ካወቁ

ድርድር አለህ እንበል እና ኤለመንቱን በቦታ i ላይ ማስወገድ ትፈልጋለህ።

አንዱ መንገድ ቁራጭ () መጠቀም ነው:

const ንጥሎች = ["a", "b", "c", "d", "e", "f"] const i = 3 const filteredItems = ንጥሎች.slice (0, i-1) .concat (ዕቃዎች. ቁራጭ (i, ንጥሎች. ርዝመት)) console.log (የተጣሩ እቃዎች)

ቁራጭ () ከሚቀበለው ኢንዴክሶች ጋር አዲስ ድርድር ይፈጥራል። በቀላሉ አዲስ ድርድር እንፈጥራለን - ከመጀመሪያው እስከ መረጃ ጠቋሚው መሰረዝ እንፈልጋለን ፣ እና የሰረዝነውን እስከ ድርድር መጨረሻ ድረስ ከመጀመሪያው ቦታ ሌላ ድርድር እናገናኛለን። ትርጉሙን ካወቅህበዚህ አጋጣሚ አንድ ጥሩ አማራጭ ተጨማሪ የሚያቀርበውን ማጣሪያ () መጠቀም ነው።

ገላጭ

አቀራረብ፡-

const ንጥሎች = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter(ንጥል => ንጥል !== valueToRemove) console.log (የተጣራ እቃዎች)

ይህ የES6 የቀስት ተግባራትን ይጠቀማል። የቆዩ አሳሾችን ለመደገፍ ባህላዊ ተግባራትን መጠቀም ትችላለህ፡-

const ንጥሎች = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "ሐ" const filteredItems = ንጥሎች. ማጣሪያ (ተግባር (ንጥል) (ንጥል መመለስ! = = valueTo Remove )) console.log(የተጣራ እቃዎች)

ወይም ባቤልን ተጠቅመህ የES6 ኮድን ወደ ES5 በመቀየር ለአሮጌ አሳሾች የበለጠ ሊነበብ ይችላል፣ነገር ግን ዘመናዊ ጃቫስክሪፕት በኮድህ ላይ ጻፍ።

ብዙ እቃዎችን በማስወገድ ላይ

ከአንድ ኤለመንት ይልቅ ብዙ አባሎችን መሰረዝ ቢፈልጉስ?

ቀላሉን መፍትሄ እንፈልግ።

const ንጥሎች = ["a", "b", "c", "d", "e", "f"] const removeItem = (ዕቃዎች, i) => ንጥሎች.slice (0, i-1) .concat (items.slice(i, items.length)) filteredItems = removeItem(ንጥሎች, 3) filteredItems = removeItem(filteredItems, 5) //["a", "b", "c", "d"] console. ሎግ (የተጣራ እቃዎች)

በዋጋ

በመልሶ መደወል ተግባር ውስጥ ማካተት መፈለግ ይችላሉ፡-

const ንጥሎች = ["a", "b", "c", "d", "e", "f"] const valuesToRemove = ["c", "d"] const filteredItems = ንጥሎች.filter(ንጥል => ለማስወገድ እሴቶች

የመጀመሪያውን ድርድር ከመቀየር ተቆጠብ

splice () (ከክፍል () ጋር መምታታት የለበትም) ዋናውን ድርድር ይለውጣል እና መወገድ አለበት።

ይህ ድርድር አለኝ፡-

ዝቅተኛውን እና ከፍተኛውን የክብደት እሴቶችን ማውጣት አለብኝ. በዚህ ምሳሌ

$min_value = 175

$max_value = 200

ይህንን እንዴት ማድረግ እንደሚቻል ላይ ምንም እገዛ አለ? አመሰግናለሁ!

2018-05-01 03:06

መልሶች፡-

አማራጭ 1፡ በመጀመሪያ እነዛን ቁጥሮች ለማግኘት ድርድርን ሰብስብ (ሙሉ መረጃ አይደለም)፡

$numbers = array_column($array, "weight")

ከዚያ ደቂቃ እና ከፍተኛ ያገኛሉ፡-

$ ደቂቃ = ደቂቃ ($ ቁጥሮች); $ max = ከፍተኛ ($ ቁጥሮች);

አማራጭ 2. (PHP 5.5 ከሌለዎት ብቻ) ልክ እንደ አማራጭ 1 አይነት ነገር ግን እሴቶቹን ለመንጠቅ array_map ይጠቀሙ፡-

$numbers = array_map(ተግባር($ዝርዝሮች)($ ዝርዝሮችን መመለስ["ክብደት"]፤)፣$array);

አማራጭ 3.

አማራጭ 4፡ በትንሹ ከፍተኛ ከፈለጉ፣ array_reduce() ፈጣን ሊሆን ይችላል።

$min = array_reduce($ ድርድር፣ ተግባር($ደቂቃ፣ $ዝርዝሮች) (ደቂቃ ተመለስ($ደቂቃ፣ $ ዝርዝሮች["ክብደት"]));፣ PHP_INT_MAX);

ይህ ከደቂቃ () ሰከንድ በላይ ይሰራል፣ ግን በጣም ፈጣን ናቸው። PHP_INT_MAX ቢበዛ ይጀምር እና ዝቅ እና ዝቅ ማለት አለበት። በ$ max ተመሳሳይ ነገር ማድረግ ይችላሉ፣ ነገር ግን በ0 ወይም -PHP_INT_MAX ይጀምራሉ።

2018-05-01 03:11

Foreach ($ ድርድር እንደ $k => $ v) ( $tArray[$k] = $v["ክብደት"]; ) $min_value = ደቂቃ($tArray); $max_value = ከፍተኛ($tAray);

2018-05-01 03:09

ፒኤችፒ 5.5+ ለሚጠቀሙ ሰዎች ይህ በ array_column በጣም ቀላል ሊሆን ይችላል ለእነዚያ አስቀያሚ ድርድሮች አያስፈልግም።

ከፍተኛውን ዋጋ እንዴት ማግኘት እንደሚቻል፡-

$highest_weight = ከፍተኛ(array_column($ዝርዝሮች፣"ክብደት"));

ዝቅተኛውን እሴት እንዴት ማግኘት እንደሚቻል

$lowest_weight = ደቂቃ(array_column ($ ዝርዝሮች፣ "ክብደት"));

2018-01-24 11:04

ደቂቃ እና ከፍተኛ የማግኘት ችግር በሁለት ተጨማሪ የማህደረ ትውስታ ቦታዎች በቀላሉ ሊፈታ ይችላል።

$first = ኢንትቫል($ ግብዓት["ክብደት"]); $min = $መጀመሪያ; $ max = $ መጀመሪያ; foreach($ እንደ $ ውሂብ ግቤት) ($weight = intval($data["ክብደት")))፤ ከሆነ($ክብደት<= $min) { $min = $weight ; } if($weight >$max) ( $max = $weight; ) ) አስተጋባ" ደቂቃ = $ደቂቃ እና ከፍተኛ = $max \n ";

2018-05-01 06:08

2018-01-10 06:44

2017-11-11 19:33

$Location_Category_array = ድርድር(5,50,7,6,1,7,7,30,50,50,50,40,50,9,9,11,2,2,2,2,2,2,11,21 ,21,1,12,1,5); የተለየ($Location_Category_array); $count=array_count_values($Location_Category_array);//በድርድር ውስጥ ያሉትን እሴቶች ይቆጥራል፣የተጓዳኝ አደራደር print_r($count) ይመልሳል፤
$ ከፍተኛ መጠን = 0;
$maxvalue = 0;

foreach($መቁጠር እንደ $a=>$y)( አስተጋባ "

".$a."=".$y; ከሆነ($y>=$ከፍተኛ እሴት)($maxvalue = $y; ከሆነ($a>$ከፍተኛ)( $maxsize = $a; ) )) አስተጋባ" ከፍተኛ = ".$maxsize;

(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

// የተለያየ ርዝመት ያላቸውን ድርድሮች ሲያወዳድሩ ደቂቃ አጭሩን ይመልሳል
$ ቫል = ደቂቃ (ድርድር (2, 2, 2), ድርድር (1, 1, 1, 1)); // ድርድር (2, 2, 2)

// ተመሳሳይ ርዝመት ያላቸው በርካታ ድርድሮች ከግራ ወደ ቀኝ ይነጻጸራሉ
// ለዚህ ምሳሌ፡- 2 == 2፣ ግን 4< 5
$ ቫል = ደቂቃ (ድርድር (2, 4, 8), ድርድር (2, 5, 1)); // ድርድር (2, 4, 8)

// ድርድር እና ያልሆነ ድርድር ቢነፃፀሩ ድርድር በጭራሽ አይመለስም።
// አደራደሮች ከሁሉም እሴቶች እንደሚበልጡ ስለሚቆጠሩ
$val = ደቂቃ ("ሕብረቁምፊ", ድርድር (2, 5, 7), 42); //ሕብረቁምፊ

// አንዱ ነጋሪ እሴት NULL ወይም ቡሊያን ከሆነ ከሌሎቹ ጋር ይነጻጸራል።
// የFALSE ህግን በመጠቀም< TRUE, учитывая остальные типы аргументов
// በተሰጠው ምሳሌ, -10 እና 10 እንደ እውነት ይቆጠራሉ
$ ቫል = ደቂቃ (- 10, FALSE, 10); // ውሸት
$ ቫል = ደቂቃ (- 10, NULL, 10); // ባዶ

// በሌላ በኩል፣ 0 እንደ ሐሰት ነው የሚወሰደው፣ ስለዚህ ከእውነተኛው "ያነሰ" ነው።
$val = ደቂቃ(0, TRUE); // 0
?>

በዚህ ቅርጸት ድርድር አለኝ፡-

አደራደር (=> አደራደር ( => 117 => አውታረ መረብ => 16) => አደራደር ( => 188 => ኤፍቲፒ => 23) => አደራደር ( => 189 => ኢንተርኔት => 48))

አለ? ጥሩ መንገድአነስተኛ እና ከፍተኛ የ"ቆጠራ" እሴቶችን ያግኙ? ብዙ loops በመጠቀም ይህን ማድረግ እችል ነበር፣ ግን የተሻለ መንገድ ሊኖር ይችላል ብዬ አስቤ ነበር።

ከሌሎች በተለየ መልኩ፣ እነዚህ ተግባራት ወደ እነርሱ የተላለፉትን የውሂብ (ድርድር) ድርድር ስለማይረዱ፣ ለዚህ ችግር ደቂቃ()/max() ተግባራትን መጠቀም አይችሉም። እነዚህ ተግባራት የሚሠሩት ለካላር ድርድር አባሎች ብቻ ነው።

ምስል ጀምር

min() እና max()ን መጠቀም ትክክለኛ መልስ የሚሰጥ መስሎ የታየበት ምክንያት ድርድሮች ወደ ኢንቲጀር መተየብ በመሆናቸው ያልተገለፀ ባህሪ ስለሆነ ነው።

ወደ ኢንቲጀር የመቀየር ባህሪ ለሌሎች አይነቶች አልተገለጸም። ያለ ማስጠንቀቂያ ሊለወጥ ስለሚችል በማንኛውም የታየ ባህሪ ላይ አይተማመኑ።

ስለ ዓይነት-መውሰድ በተመለከተ የሰጠሁት መግለጫ የተሳሳተ ነበር። በእውነቱ min() እና max() የሚሰሩት ከድርድር ጋር ነው፣ነገር ግን OP እንዲሰራ በሚፈልገው መንገድ አይደለም። min() እና max()ን ከበርካታ ድርድሮች ወይም የድርድር አባሎች ጋር ሲጠቀሙ ከግራ ወደ ቀኝ ኤለመንቱን በንጥል ያወዳድሩ፡

$ ቫል = ደቂቃ (ድርድር (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() መጠቀሙ ትክክለኛውን ውጤት እንደሚሰጥ ያሳያል። የድርድር የመጀመሪያዎቹ አካላት መታወቂያ ናቸው፣ስለዚህ min() እና max() መጀመሪያ ያወዳድሯቸዋል፣ በነገራችን ላይ ወደ ትክክለኛው ውጤት ይመራሉ፣ ምክንያቱም ዝቅተኛው መታወቂያ ዝቅተኛው ቆጠራ ያለው እና ከፍተኛው መታወቂያ ያለው ነው። ከፍተኛ ቁጥር ያለው.

አርትዕን ጨርስ

ትክክለኛው መንገድ ሉፕ መጠቀም ነው።

$a = ድርድር (ድርድር ("id" => 117፣ "ስም" => "አውታረመረብ", "መቁጠር" => 16)፣ አደራደር("id" => 188፣ "ስም" => "ኤፍቲፒ", " ቆጠራ" => 23)፣ አደራደር ("መታወቂያ" => 189፣ "ስም" => "ኢንተርኔት", "መቁጠር" => 48)); $ ደቂቃ = PHP_INT_MAX; $ ከፍተኛ = 0; foreach ($a እንደ $i) ($ደቂቃ = ደቂቃ($ደቂቃ፣ $i["መቁጠር"])፤ $ከፍተኛ = ከፍተኛ($ከፍተኛ፣ $i["መቁጠር"]);)

ከፍተኛ () እና ደቂቃ () ተግባራትን መጠቀም ይችላሉ።

በበርካታ loops ምን አደረግክ? አንዱ በቂ ነው :)

የሁለቱም $min እና ከፍተኛ ብዛት በመቁጠር የመጀመሪያውን ኤለመንት ያግኙ
በቀሪው ላይ ይድገሙት፣ ቆጠራውን ከእያንዳንዱ $ደቂቃ እና ከፍተኛው ዶላር ጋር ያወዳድሩ፣ ያነሰ/ትልቅ ከሆነ አዲስ የቁጥር እሴት ይመድቡ

የእያንዳንዱ ኢንዴክስ ከፍተኛ/ዝቅተኛውን የያዘ ድርድር ስለሚመልሱ ከፍተኛ/ደቂቃ ተግባራትን መጠቀም ትችላለህ። የእርስዎ ምሳሌ ቢበዛ ድርድር (189፣ "Networking", 48) መመለስ አለበት። ከዚያ ውጤቱን ከዚህ ድርድር መውሰድ ይችላሉ።

እኔ እንደገለጽኩት ይህንን ማዘመን አይሰራም። የወንዶች ገጽ ምሳሌ አሳሳች ነው እና ምሳሌው ከፍተኛውን በመጠቀም ትክክለኛውን ውጤት ይሰጣል ፣ ግን ያ በአጋጣሚ ነው።

በ2D ድርድር ላይ max() መጠቀም የማይችሉ ይመስላል። የእያንዳንዱ ኢንዴክስ ከፍተኛ () ሳይሆን (በብዙ መልሶች ላይ እንደተገለጸው) በቀላሉ ትልቁን ድርድር ይመልሳል።

$count = ድርድር (); foreach ($ arr እንደ $ _arr) ($count = $_arr ["ቆጠራ"];) var_dump (ከፍተኛ ($ ቆጠራ)፣ ደቂቃ($count));

ተመጣጣኝ አለ? አብሮ የተሰራለዚህ ተግባር? (ያለ ዕድል እንኳን ሙከራ)

/** * ከ 2D ድርድር አንድ አምድ ከሌላ አምድ ላይ ከአማራጭ ምርጫ ጋር ሰርስሮ ያወጣል * * @param $ aarray ከ * @param $ ለማምጣት የአምዱ ስም ፣ ለምሳሌ። "O_NAME" * @param $aColTest (አማራጭ) ፈተናውን ለማሄድ የአምድ ስም፣ ለምሳሌ "O_ID" * @param $aTest (አማራጭ) ለሙከራ የቀድሞ. ">=10"፣ "== ""$ ቶቶ።""" * @መመለስ 1D ድርድር ከተወጣው አምድ ብቻ * @መዳረሻ ይፋዊ * / ተግባር ማውጣትColFromArray ($aArray, $aColName, $aColTest = "", $ aTest = "") ( $mRes = ድርድር ()); foreach ($aArray እንደ $ ረድፍ) (($aColTest == ") ከሆነ || (eval("መመለስ") $ ረድፍ[$aColTest]። $ ሙከራ ";"))) ( $ mRes = $ ረድፍ [$ aColName]; )) መመለስ $ mRes ) // extractColFromArray

uptostart.ru ዜና. ጨዋታዎች መመሪያዎች. ኢንተርኔት. ቢሮ.