स्थानीय चरम सीमाओं का पता लगाना

Question

एक फ़ंक्शन या प्रोग्राम लिखें जो सूची में लेता है और स्थानीय चरम सीमाओं की एक सूची तैयार करता है।

एक सूची में [x_0, x_1, x_2...]एक स्थानीय चरम एक x_iऐसा है जो x_(i-1) < x_iऔर x_(i+1) < x_iया x_(i-1) > x_iऔर x_(i+1) > x_i। ध्यान दें कि सूची का पहला और अंतिम तत्व कभी भी स्थानीय चरम सीमा नहीं हो सकता है।

तो कुछ उदाहरणों के लिए

local_extremes([1, 2, 1]) = [2]
local_extremes([0, 1, 0, 1, 0]) = [1, 0, 1]
local_extremems([]) = []

यह कोड गोल्फ है इसलिए सबसे छोटा कोड जीतता है!

Comments

यह सुनिश्चित करने के लिए कि मैं सही तरीके से समझता हूं: दोनों तरफ संख्याओं से अधिक संख्या?

— अंडरग्राउंडोरैल

@undergroundmonorail ग्रेटर या उससे कम। तो यह या तो एक स्थानीय न्यूनतम होना है, जहां यह पड़ोसी दोनों अधिक हैं, या एक अधिकतम जहां वे दोनों छोटे हैं

— डैनियल ग्रैज़र

ओह मैं समझा। मैंने इसे गलत तरीके से पढ़ाया

— भूमिगत

और अनुक्रम के बारे में क्या 1 2 2 1उन्हें 2भी चरम के रूप में नहीं माना जाना चाहिए ? - मुझे पता है, यह समाधान को और अधिक कठिन बना देगा ...

— VX

Answer 1

गणितज्ञ 66 58 51

वर्तमान समाधान

कैले द्वारा योगदान के लिए संक्षिप्त धन्यवाद।

Cases[Partition[#,3,1],{a_,b_,c_}/;(a-b) (b-c)<0⧴b]&

Partition[#,3,1] तीनों को ढूंढता है।

(a-b) (b-c)<0सच यदि और केवल यदि है bनीचे है a, cया इसके बाद के संस्करण a, c। और अंतर के संकेतों को देखता है। एक स्थानीय चरम {-1,1}या तो वापस आ जाएगी {1,-1}।

---

उदाहरण

Cases[Partition[#, 3, 1], {a_, b_, c_} /; (a - b) (b - c) < 0 :> b] &[{1, 2, 1}]
Cases[Partition[#, 3, 1], {a_, b_, c_} /; (a - b) (b - c) < 0 :> b] &[{0, 1, 0, 1, 0}]
Cases[Partition[#, 3, 1], {a_, b_, c_} /; (a - b) (b - c) < 0 :> b] &[{}]
Cases[Partition[#, 3, 1], {a_, b_, c_} /; (a - b) (b - c) < 0 :> b] &[{9, 10, 7, 6, 9, 0, 3, 3, 1, 10}]

{२}
{१, ०, १}
{}
{१०, ६, ९, ०, १}

---

इससे पहले समाधान

यह उदाहरण सभी त्रिगुणों (उदाहरणों से उत्पन्न Partition) को दर्शाता है और यह निर्धारित करता है कि मध्य तत्व दोनों चरम सीमाओं से कम है या चरम सीमा से अधिक है।

Cases[Partition[#,3,1],{a_,b_,c_}/;(b<a∧b<c)∨(b>a∧b>c)⧴b]& ;

---

पहला उपाय

यह त्रिगुणों को ढूँढता है, और अंतरों के संकेतों को देखता है। एक स्थानीय चरम {-1,1}या तो वापस आ जाएगी {1,-1}।

Cases[Partition[#,3,1],x_/;Sort@Sign@Differences@x=={-1,1}⧴x[[2]]]&

उदाहरण

Cases[Partition[#,3,1],x_/;Sort@Sign@Differences@x=={-1,1}:>x[[2]]]&[{9, 10, 7, 6, 9, 0, 3, 3, 1, 10}]

{१०, ६, ९, ०, १}

---

विश्लेषण :

Partition[{9, 10, 7, 6, 9, 0, 3, 3, 1, 10}]

{{9, 10, 7}, {10, 7, 6}, {7, 6, 9}, {6, 9, 0}, {9, 0, 3}, {0, 3, 3}, { 3, 3, 1}, {3, 1, 10}}

% संबंधित पूर्ववर्ती रेखा से परिणाम को संदर्भित करता है।

Differences/@ %

{{1, -3}, {-3, -1}, {-1, 3}, {3, -9}, {-9, 3}, {3, 0}, {0, -2}, {-2, 9}}

Sort@Sign@Differences@x=={-1,1}{{9, 10, 7}, {10, 7, 6}, {7, 6, 9}, {6, 9, 0}, {9, 0, 3}, {0, 3, से त्रिगुणों की पहचान करता है। 3}, {3, 3, 1}, {3, 1, 10}} जैसे कि मतभेदों के संकेत (-, 0, +) में a -1और a होते हैं 1। वर्तमान मामले में वे हैं:

{{9, 10, 7}, {7, 6, 9}, {6, 9, 0}, {9, 0, 3}, {3, 1, 10}}

इनमें से प्रत्येक मामले के लिए, x, x[[2]]दूसरे शब्द को संदर्भित करता है। वे सभी स्थानीय मैक्सिमा और मिनीमा के होंगे।

{१०, ६, ९, ०, १}

Comments

आपकी गणित की शैली मेरी तुलना में अधिक संक्षिप्त है। हम इसे "वुल्फराम भाषा" कब कहना शुरू करते हैं?

— माइकल स्टर्न

मैंने यह देखा ! गणितज्ञ ग्राफिक्स

— डॉ। बेलिसरियस

माइकल स्टर्न, मुझे संदेह है कि वुल्फराम भाषा केवल संस्करण 10 में आधिकारिक हो जाएगी, जिसका कुछ रूप रास्पबेरी पाई पर पहले से ही उपलब्ध है।

— डेविड एफएक्स

BTW, किसी ने कोड की एक पंक्ति सम्मिलित की, जो मैटल एमएल को ग्राफिक्स में परिवर्तित करता है। मुझे यकीन नहीं है कि क्यों।

— डेविड एफसी

मुझे यकीन नहीं है कि उसने ऐसा क्यों किया। मैं "संशोधित" कोड में कोई अंतर नहीं देख सकता

— डॉ। बेलिसियस

Answer 2

जे - 19 चार

यह मदद नहीं कर सकता;)

(}:#~0,0>2*/\2-/\])

स्पष्टीकरण इस प्रकार है:

• 2-/\] - तर्क में तत्वों की प्रत्येक जोड़ी पर (प्रत्येक 2-आइटम लंबा इन्फिक्स), अंतर लें।
• 2*/\ - अब नई सूची के प्रत्येक जोड़े पर, उत्पाद लें।
• 0> - परीक्षण करें कि क्या प्रत्येक परिणाम 0. से कम है। यह केवल तब होता है जब गुणकों में प्रत्यावर्ती संकेत होते हैं, अर्थात ऐसा नहीं होता है यदि उनके पास एक ही संकेत था या या तो शून्य था।
• 0, - घोषणा करें कि पहला तत्व एक चरम तत्व नहीं है।
• }: - अंतिम तत्व को काट दें, क्योंकि यह संभवतः एक चरम भी नहीं हो सकता है।
• #~ - बाईं ओर की सूची से आइटम लेने के लिए दाईं ओर सही मान का उपयोग करें।

उपयोग:

   (}:#~0,0>2*/\2-/\]) 1 2 1
2
   (}:#~0,0>2*/\2-/\]) 0 1 0 1 0
1 0 1
   (}:#~0,0>2*/\2-/\]) i.0   NB. i.0 is the empty list (empty result also)

   (}:#~0,0>2*/\2-/\]) 3 4 4 4 2 5
2

Comments

उम्म, यह काम नहीं कर सकता है अगर इनपुट है, तो कहें, 3, 4, 4, 4, 4, 4, 5, यानी आपको "0 =" चरण में एक शून्य मिल सकता है यदि 0 को 0 में जोड़ा जाता है

— लॉर्ड सोथ

इसके अलावा, मैं इस भाषा के बारे में नहीं जानता, लेकिन, पहले चरण में साइनम लेने के बजाय, आप अंतर को छोड़ सकते हैं जैसा कि यह है। फिर, दूसरे चरण में, इसके बजाय तत्वों को गुणा करें, और तीसरे में आप जांच सकते हैं कि उत्पाद नकारात्मक है (यह भी 0 समस्या से बचा जाता है)। शायद यह एक छोटे से कोड में परिणाम हो सकता है।

— लॉर्ड सोथ

अच्छी पकड़, और हाँ, यह दो पात्रों को बचाता है। अद्यतन कर रहा है।

— एल्गोरिथमशार्क

Answer 3

जावास्क्रिप्ट - 62 45 वर्ण

f=a=>a.filter((x,i)=>i&&i<a.length-1&&(a[i-1]-x)*(a[i+1]-x)>0)

संपादित करें

f=a=>a.filter((x,i)=>(a[i-1]-x)*(a[i+1]-x)>0)

Answer 4

रूबी, 83 70 60 55 49 वर्ण

f=->a{a.each_cons(3){|x,y,z|p y if(x-y)*(z-y)>0}}

सभी स्थानीय छोरों को STDOUT तक प्रिंट करता है।

<=>"स्पेसशिप" ऑपरेटर का उपयोग करता है , जो मुझे वास्तव में पसंद है। (यह 1 लौटाता है यदि पहली चीज़ दूसरी से अधिक है, -1 यदि यह कम है, और 0 यदि समान है। इसलिए, यदि वे -2 या 2 में जोड़ते हैं, तो इसका मतलब है कि मध्य एक चरम है।)

अब और नहीं, जैसा कि @daniero ने बताया कि "स्पष्ट" रास्ता वास्तव में छोटा है!

फिर भी बदल गया! अब यह MT0 के उत्तर में मिले भयानक एल्गोरिथ्म का उपयोग करता है (+1 उसे!)।

इसके अलावा, मुझे पसंद है each_consजो nएक सरणी में लगातार तत्वों के प्रत्येक समूह का चयन करता है । और अनुगामी ifभी दिलचस्प है।

कुल मिलाकर, मुझे यह पसंद है कि यह कितना सुंदर दिखता है।

कुछ नमूना चलता है:

irb(main):044:0> f[[1,2,1]]
2
=> nil
irb(main):045:0> f[[1,0,1,0,1]]
0
1
0
=> nil
irb(main):046:0> f[[]]
=> nil
irb(main):047:0> f[[1,2,3,4,5,4,3,2,1]]
5
=> nil
irb(main):048:0> f[[1,1,1,1,1]]
=> nil
irb(main):049:0> f[[10,0,999,-45,3,4]]
0
999
-45
=> nil

Comments

यह x को 3 चर में अनपैक करने के लिए छोटा है:f=->a{a.each_cons(3){|x,y,z|p y if((x<=>y)+(z<=>y)).abs==2}}

— daniero

@daniero धन्यवाद; मुझे पता भी नहीं था कि आप ऐसा कर सकते हैं! संपादित

— दरवाज़े

सच में ? : D Btw, अब जब कि प्रत्येक शब्द 3 वर्ण छोटा है, यह समग्र रूप से सस्ता है x>y&&y<z||x<y&&y>z(यहाँ तक कि स्पेसशिप ऑपरेटर भी बहुत सुंदर है);)

— daniero

यह भी ... !((x..z)===y)हालांकि कम चालाक

— नहीं है

@Charles जब विफल हो जाता है x < z।

— दरवाज़े

Answer 5

सी ++ - 208 वर्ण

सबसे लंबा समाधान फिर से:

#include<iostream>
#include<deque>
using namespace std;
int main(){deque<int>v;int i;while(cin){cin>>i;v.push_back(i);}for(i=0;i<v.size()-2;)if(v[++i]>v[i-1]&v[i]>v[i+1]|v[i]<v[i-1]&v[i]<v[i+1])cout<<v[i]<<' ';}

उपयोग करने के लिए, अपने पूर्णांक दर्ज करें, फिर कोई भी वर्ण जो इनपुट स्ट्रीम को क्रैश करेगा - किसी भी गैर-संख्या वर्ण को काम करना चाहिए।

इनपुट: 0 1 0 x

आउटपुट: 1

Comments

आप 2 वर्ण प्राप्त करने के dequeबजाय एक का उपयोग कर सकते हैं vector।

— मोरवीन

इसके अलावा, उपयोग करने के बजाय iऔर j, आप int i;संग्रह के बाद सही घोषणा कर सकते हैं और दो चर घोषित करने के बजाय दो छोरों में उपयोग कर सकते हैं ।

— मोरवेन

अंत में, आप संभवतः i++लूप के लिए अपने वेतन वृद्धि से छुटकारा पा सकते हैं और if(v[++i]>[i-1]...फिर से एक पात्र प्राप्त करने के लिए अपनी स्थिति शुरू कर सकते हैं ।

— मोरवेन

Answer 6

मतलाब - 45 बाइट्स

x=input('');y=diff(x);x(find([0 y].*[y 0]<0))

Answer 7

पायथन 2.7 - 73 बाइट्स

e=lambda l:[l[i]for i in range(1,len(l)-1)if(l[i]-l[i-1])*(l[i]-l[i+1])]

बहुत प्रभावशाली नहीं (पहले और अंतिम को छोड़कर सूची के प्रत्येक तत्व को देखें, देखें कि क्या वह अपने पड़ोसियों से बड़ा या छोटा है)। मैं ज्यादातर इसे केवल इसलिए पोस्ट कर रहा हूं क्योंकि हर कोई नहीं जानता कि आप यह कर सकते हैं x<y>zऔर यह काम कर सकता है । मुझे लगता है कि यह साफ-सुथरा है।

हां, x<y>zअजगर की एक शांत विशेषता है, लेकिन यह वास्तव में इस मामले में इष्टतम नहीं है। गुणन चाल के लिए VX के लिए धन्यवाद, जो मुझे बिल्कुल नहीं हुआ। Wrzlprmft ने मुझे याद दिलाया कि एक अनाम फ़ंक्शन की घोषणा करना कीस्ट्रोक्स की तुलना में कम है def x(y):।

Comments

if(l[i]-l[i-1])*(l[i]-l[i+1])>0कोड को 11 वर्णों से कम करेगा ...

— VX

@ राइट अह, आप सही कह रहे हैं। मुझे इस तथ्य से फेंक दिया गया था कि def e(l):\n वर्णों की समान संख्या है e=lambda l:, लेकिन मैं भूल गया कि आपको returnकीवर्ड का उपयोग करने की आवश्यकता नहीं है । धन्यवाद!

— अंडरग्राउंडोरेल

@vx ओह, मुझे वह बहुत पसंद है। धन्यवाद :) संपादित करें: वास्तव में आप इससे अधिक बचा सकते हैं! के बाद से (l[i]-l[i-1])*(l[i]-l[i+1])है 1, तो l[i]एक स्थानीय चरम है और 0नहीं तो, मैं का उपयोग करने की जरूरत नहीं है >0। मैं बस अजगर को एक बूल के रूप में व्याख्या करने दे सकता हूं। :)

— भूमिगत

@wrz मैं समझ नहीं पा रहा हूं कि एक टिप्पणी को कैसे संपादित किया जाए जो पहले से ही संपादित की गई है (पेंसिल आइकन संपादन बटन को बदलने के लिए लगता है। यह डिजाइन के अनुसार है?)। मैं सिर्फ यह जोड़ना चाहता था, अगर मैं स्मार्ट था, तो मुझे एहसास हुआ कि मेरे एक-लाइन फ़ंक्शन \n को घोषणा में बिल्कुल भी ज़रूरत नहीं थी ! इससे दो वर्णों को बचाया जा सकता था, लेकिन returnअभी भी शामिल किए जाने के लायक नहीं है।

— अंडरग्राउंडोरेल

Answer 8

हास्केल 50

f a=[x|(p,x,n)<-zip3 a(tail a)(drop 2 a),x>p&&x>n]

Comments

मिनीमम जोड़ने के लिए यह केवल स्थानीय अधिकतम जाँच करें || x <min pn

— karakfa

x>p&&x>nएक कम चरित्र है x>max p n:-)

— yatima2975

अंतरिक्ष के बाद ,आवश्यक नहीं है।

— कारकाफा

परिवर्तन x>p&&x>nके लिए (x>p)==(x>n)स्थानीय न्यूनतम के लिए भी, 4 अधिक वर्ण कहते हैं।

— कारकाफा

Answer 9

जेली , 8 बाइट्स

IṠIỊ¬T‘ị

इसे ऑनलाइन आज़माएं!

व्याख्या

IṠIỊ¬T‘ị
I          Differences between adjacent elements {of the input}
 Ṡ         Take the sign of each difference
  I        Differences between adjacent difference signs
   Ị       Mark the elements that are     in the range -1..1 inclusive
    ¬                                 not
     T     Take the indexes of the marked elements
      ‘      with an offset of 1
       ị   Index back into the original list

एक तत्व केवल एक स्थानीय चरम है यदि इसके बाएं पड़ोसी के साथ इसका अंतर इसके सही पड़ोसी के साथ अपने अंतर के विपरीत संकेत है, अर्थात अंतर के संकेत 2 या -2 से भिन्न होते हैं। जेली में "कुछ गुणों के साथ तत्वों को खोजने" (विशेष रूप से, हम एक सूची में कुछ गुणों के साथ तत्वों को खोज सकते हैं और एक अलग सूची से तत्वों को निकालने के लिए उपयोग कर सकते हैं) के लिए कई उपयोगी आदिम हैं, जिसका अर्थ है कि हम वापस अनुवाद कर सकते हैं मूल सूची अधिक या कम सीधे (हमें सिर्फ 1 से ऑफसेट करने की आवश्यकता है क्योंकि मूल सूची के पहले और आखिरी तत्व अंतर-लेने में खो गए)।

Answer 10

नेम्पी के साथ अजगर - 81 74 67 बाइट्स ( लाइन के बिना 61 54 import)

import numpy
e=lambda a:a[1:-1][(a[2:]-a[1:-1])*(a[1:-1]-a[:-2])<0]

इनपुट के लिए एक Numpy सरणी होना चाहिए।

Answer 11

सी, 83

x,y,z;main(){y=z=0;while(scanf("%d",&x)){(y-z)*(y-x)>0?printf("%d ",y):1;z=y,y=x;}}

Answer 12

awk - 32 वर्ण

{c=b;b=a;a=$0;$0=b}(b-c)*(a-b)<0

संक्षिप्तता पर जम्मू या एपीएल जैसी भाषा की पिटाई की कोई उम्मीद नहीं है, लेकिन मैंने सोचा कि मैं अपनी टोपी वैसे भी रिंग में फेंक दूंगा। स्पष्टीकरण:

• किसी भी समय, a, b, और cपकड़ x_i, x_(i-1)औरx_(i-2)
• b-cऔर a-bपहले और बाद के व्युत्पन्न को अनुमानित करेंx_(i-1)
• यदि उनका उत्पाद ऋणात्मक है, तो एक ऋणात्मक है और दूसरा धनात्मक है, x_(i-1)इसके अतिरिक्त एक स्थानीय अति है, इसलिए प्रिंट करें

Answer 13

ब्रेकीलॉग , 17 बाइट्स

s₃{b≠h.&k≠&{⌉|⌋}}

इसे ऑनलाइन आज़माएं!

इनपुट चर के माध्यम से इनपुट लेता है और आउटपुट चर के माध्यम से आउटपुट उत्पन्न करता है।

s₃{             }    For a length-3 substring of the input:
  {b                 its last two elements
    ≠                are distinct,
     h               and the first of those elements is
      .              the output variable;
       &k            its first two elements
         ≠           are also distinct;
          &{⌉| }     either its largest element
          &{ |⌋}     or its smallest element
                }    is also the output variable.

यदि मानों के रन को अनुपस्थित रहने की गारंटी दी जा सकती है, s₃{{⌉|⌋}.&bh}तो चार बाइट बचाएगी।

Answer 14

पर्ल 5 -p , 49 बाइट्स

s/\d+ (?=(\d+) (\d+))/say$1if($1-$&)*($1-$2)>0/ge

इसे ऑनलाइन आज़माएं!

Answer 15

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 43 42 बाइट्स

#~Pick~ArrayFilter[#[[2]]!=Median@#&,#,1]&

इसे ऑनलाइन आज़माएं!

मुझे लगता Nothingहै कि बहुत लंबा है ...

#~Pick~                                  &  (* select elements of the input where, *)
       ArrayFilter[                 ,#,1]   (*  when considering the block of length 1 *)
                                            (*    on either side of that element, *)
                   #[[2]]!=Median@#&        (*  its median is not that element *)

Answer 16

05AB1E , 11 10 बाइट्स

¥.±¥Ä2Q0šÏ

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

¥           # Get the forward differences (deltas) of the (implicit) input-list
            #  i.e. [9,10,7,6,9,0,3,3,1,10] → [1,-3,-1,3,-9,3,0,-2,9]
 .±         # Get the signum of each delta (-1 if neg.; 0 if 0; 1 if pos.)
            #  → [1,-1,-1,1,-1,1,0,-1,1]
   ¥        # Get the forward differences of that list again
            #  → [-2,0,2,-2,2,-1,-1,2]
    Ä       # Convert each integer to its absolute value
            #  → [2,0,2,2,2,1,1,2]
     2Q     # And now check which ones are equal to 2 (1 if truthy; 0 if falsey)
            #  → [1,0,1,1,1,0,0,1]
       0š   # Prepend a 0
            #  → [0,1,0,1,1,1,0,0,1]
         Ï  # And only leave the values in the (implicit) input-list at the truthy indices
            #  → [10,6,9,0,1]
            # (after which the result is output implicitly)

Answer 17

PHP, 116 114 113

function _($a){for(;$a[++$i+1];)if(($b=$a[$i])<($c=$a[$i-1])&$b<($d=$a[$i+1])or$b>$c&$b>$d)$r[]=$a[$i];return$r;}

उदाहरण का उपयोग:

print_r(_(array(2, 1, 2, 3, 4, 3, 2, 3, 4)));

Array
(
    [0] => 1
    [1] => 4
    [2] => 2
)

Answer 18

हास्केल, 70 सी

गोल्फ संस्करण

e(a:b:c:r)
 |a<b&&b>c||a>b&&b<c=b:s
 |True=s
 where s=e(b:c:r)
e _=[]

अनप्लग्ड संस्करण

-- if it's possible to get three elements from the list, take this one
extrema (a:b:c:rest)
    | a<b && b>c = b:rec
    | a>b && b<c = b:rec
    | otherwise = rec
    where rec = extrema (b:c:rest)
-- if there are fewer than three elements in the list, there are no extrema
extrema _ = []

Answer 19

जावास्क्रिप्ट: 102 वर्ण

function h(a){for(u=i=[];++i<a.length-1;)if(x=a[i-1],y=a[i],z=a[i+1],(x-y)*(y-z)<0)u.push(y);return u}

Answer 20

एपीएल, 19 बाइट्स

{⍵/⍨0,⍨0,0>2×/2-/⍵}

मैंने 20 चार जे संस्करण को एपीएल में परिवर्तित किया। लेकिन मैं पहले और आखिरी अंक को हटाने के बजाय शुरुआत और अंत में एक शून्य जोड़ता हूं। अन्यथा यह जे संस्करण की तरह ही काम करता है।

⍵- औपचारिक पैरामीटर ओमेगा। यह फ़ंक्शन के लिए इनपुट है।

Comments

जब हम उस पर होते हैं, मेरे पास एक K संस्करण होता है, वह भी, 22 अक्षरों में {x@1+&0>2_*':-':0 0,x}:। इनमें से 6 अक्षर ( 2_और 0 0,) एक लम्बाई त्रुटि से बचाव में बिताए जाते हैं यदि तर्क दो वस्तुओं से कम है, तो यदि उस समस्या के लिए नहीं तो यह 16 हो जाएगा ... कार्रवाई भी थोड़ी अलग है - हमें पलटना होगा बूलियन सूची के साथ सूचकांक की सूची में 1+&और xफिर से अनुक्रमित करने के लिए उपयोग करें - लेकिन यह छोटा है और यह करने के लिए एक बहुत ही के-ईश बात भी है।

— एल्गोरिथमशार्क

आपका K संस्करण तब मेरे APL संस्करण को हरा देगा। मेरे कोड को कम से कम दो नंबर चाहिए।

— user10639

Answer 21

पायथन 2 , 59 बाइट्स

f=lambda l=0,c=0,*r:r and(c,)*(l<c>r[0]or l>c<r[0])+f(c,*r)

इसे ऑनलाइन आज़माएं!

यह फ़ंक्शन सूची के तत्वों को तर्क के रूप में लेने के बजाय सूची के स्वयं के महंगा व्यापार से बचा जाता है। जबकि सूची में एक से अधिक तत्व बचे हुए हैं, हम पुनरावर्ती रूप से सूची बनाते हैं, प्रत्येक चरण में अधिकतम के लिए जाँच करते हैं।