लागू करें आलसी ड्रॉप सॉर्ट

26

यह चुनौती पहले से ही बूंदों का वर्णन करती है। हालाँकि, मैं थोड़े आलसी हूँ और मुझे वास्तव में केवल अपने सरणी को पहले की तुलना में थोड़ा अधिक क्रमबद्ध करने की आवश्यकता है, इसे सभी तरह से हल करने की आवश्यकता नहीं है ।

ड्रॉप सॉर्ट में, हम हर तत्व को किसी भी तत्व से कम से पहले गिरा देते हैं । आलसी ड्रॉप सॉर्ट में, हम हर तत्व को एक से कम सख्ती से छोड़ देते हैं ।

यहाँ एक उदाहरण है। निम्नलिखित सरणी पर विचार करें:

8 6 9 9 7 2 3 8 1 3

आइए प्रत्येक तत्व को पहले वाले से कम चिह्नित करें।

8 6 9 9 7 2 3 8 1 3
  ^     ^ ^     ^

ध्यान दें कि न तो कैसे 3चिह्नित किया गया था, न ही अंतिम 8। वे सभी उनमें से बाईं ओर के एकल तत्व से बड़े हैं।

एल्गोरिथ्म को पूरा करना, चिह्नित तत्वों को निकालना, हमें मिलता है:

8 9 9 3 8 3

यह मूल रूप से अधिक क्रमबद्ध दिखता है। किंडा। मैं आलसी हूँ।

आपका कार्य, जैसा कि आप पहले ही काट चुके हैं, इस एल्गोरिथम को लागू करना है।

इनपुट 1 और 9 के बीच कम से कम 1 सकारात्मक पूर्णांक का एक सरणी है, इसलिए आप अंकों का एक स्ट्रिंग भी ले सकते हैं।

यह कोड-गोल्फ , सबसे कम बाइट्स जीतता है!

अतिरिक्त परीक्षण मामले:

1
1

1 2 3
1 2 3

5 3 1
5

1 2 3 2 1
1 2 3

1 1 1 9 9 9 1 1 1 9 9 9 1 1 1
1 1 1 9 9 9 1 1 9 9 9 1 1

9 9
9 9

5 2 4 2 3
5 4 3
code-golf  array-manipulation  sorting 
— पावेल
स्रोत
क्या यह एक कार्य हो सकता है या यह एक पूर्ण कार्यक्रम होना चाहिए?
— rafa11111
@ rafa11111 या तो ठीक है
— पावेल
मामले में यह एक फ़ंक्शन है, क्या इनपुट सरणी को मुख्य कार्यक्रम में हार्डकोड किया जा सकता है? और सरणी की लंबाई फ़ंक्शन के इनपुट के रूप में पारित की जा सकती है?
— राफा 11111 1
@ rafa11111 इनपुट को फ़ंक्शन में हार्डकोड नहीं किया जा सकता है। इससे कोई फर्क नहीं पड़ता कि आपके परीक्षण कार्यक्रम में फ़ंक्शन को यह इनपुट कैसे मिलता है। आप सरणी की लंबाई केवल तभी ले सकते हैं जब आप C / C ++ या किसी अन्य भाषा का उपयोग कर रहे हों जहां किसी सरणी की लंबाई निर्धारित करने का एकमात्र तरीका हो।
— पावेल

जवाबों:

15

जावास्क्रिप्ट (ईएस 6), 28 25 बाइट्स

@ बस्ती के लिए 3 बाइट्स को सहेजा गया

a=>a.filter(n=>~-a<(a=n))

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

— Arnauld
स्रोत
2
n=>p<=nबहुत बढ़िया लग रहा होगा ;-)
— ETHproductions
4
@ETHproductions +4 बाइट्स के लिए, (n=p)=>p<=(p=n)ठीक काम करता है;)
— अरनॉल्ड
यह उत्तर मेरे दिमाग को उड़ा रहा है, pपहली बार जब यह अभी तक परिभाषित नहीं किया गया है, तो एक्सेस करने की कोशिश करते समय यह विस्फोट क्यों नहीं होता है?
— ब्रायन एच।
1
@ झबरा जो सुरक्षित दिखता है। जब मैं कंप्यूटर के सामने वापस आऊंगा तो अपडेट करूंगा। धन्यवाद!
— अरनुलद
2
@ पवल aशुरू में इनपुट ऐरे पर सेट a-1होता है और NaNइसमें परिणाम होता है (जब तक कि इसमें एक पूर्णांक न हो, इस स्थिति में यह पूर्णांक के लिए बाध्य है)।
— Arnauld
6

MATL , 9 8 बाइट्स

Giuseppe के लिए एक बाइट धन्यवाद सहेजा गया।

0yd0<h~)

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

स्पष्टीकरण:

0                 % Push a zero
 y                % Implicitly grab the input and duplicate it.
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [8 6 9 9 7 2 3 8 1 3]
  d               % The difference between each number of the last element:
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [-2, 3, 0, -2, -5, 1, 5, -7, 2]
   0<             % Which are negative?
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [1 0 0 1 1 0 0 1 0]
     h            % Concatenate. Stack: [8 6 9 9 7 2 3 8 1 3], [0 1 0 0 1 1 0 0 1 0] 
      ~           % Negate. Stack: [8 6 9 9 7 2 3 8 1 3], [1 0 1 1 0 0 1 1 0 1]
       )          % Index. Stack: [8 9 9 3 8 3]
— स्टीवी ग्रिफिन
स्रोत
5

पर्ल 5 .10.0 + -nl, 16 बाइट्स

$f>$_||say;$f=$_

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

— wastl
स्रोत
1
पर्ल 6 का अनुवादperl6 -ne '$/>$_||.say;$/=$_'
— ब्रैड गिल्बर्ट b2gills
@ ब्रैड perl6 एक अलग भाषा है (यह भी पीछे की ओर संगत नहीं है) इसे पोस्ट करें!
— wastl
मैंने एक लिखा था जो अधिक मुहावरेदार पर्ल 6 था, लेकिन यह अधिक लंबा था। इसके अलावा मैं यहाँ पोस्ट करने के कारणों में से एक भाषा को दिखाने के लिए, और यह समझाने के लिए है। उस अनुवाद को पोस्ट करने से कुछ नहीं होता है, बल्कि यह दर्शाता है कि यह पर्ल का थोड़ा अधिक वर्बोज़ संस्करण है। मूल रूप से यह इस साइट पर पोस्ट करने के कारणों में से किसी को भी संतुष्ट नहीं करता है।
— ब्रैड गिल्बर्ट 15
4

स्टैक्स , 5 बाइट्स

âÿ╠╦░

इसे ऑनलाइन चलाएं और डीबग करें

कोड को अनपैक करना, अनगल करना और टिप्पणी करना, हमें यह मिलता है।

Z   Push a zero under the input
f   Use the rest of the program as a filter on the input.  Output passing elements.
>   Current element is greater than previous?
_~  Push current element to the input stack; when the main stack is empty, pops fall back to this
!   Logical not; applies to the result of the greater-than

इसको चलाओ

निर्देशों का क्रम अजीब है, लेकिन इसके लिए एक कारण है। Stax source कोड पैकिंग हमेशा एक ही आकार के इनपुट के लिए समान आकार आउटपुट नहीं देता है। मूल रूप से, आपके पास एक बाइट को बचाने का एक मौका है यदि स्रोत के अंतिम चरित्र में कम वर्ण कोड है। खैर, !सबसे कम कोडों में से एक है जिसे आप प्रिंट करने योग्य चरित्र के लिए प्राप्त कर सकते हैं। (33 विशेष रूप से) कई 6 बाइट ASCII स्टैक्स प्रोग्राम किसी भी छोटे पैक नहीं कर सकते। लेकिन अगर वे एक के साथ समाप्त होते हैं !, तो वे कर सकते हैं। इसलिए निर्देशों के इस विशेष आदेश का कारण यह सुनिश्चित करना है कि तार्किक कार्यक्रम के अंत में समाप्त न हो।

— पुनरावर्ती
स्रोत
4

जे, 12 बाइट्स

#~1,2&(<:/\)

स्पष्टीकरण:

#~1,2&(<:/\)    | Whole function, executed as a hook
       <:/      | Distribute <: (greater or equal) over an array
    2&(   \)    | Apply to each sub array of length 2
  1,            | Append a 1 to the front
#~              | Choose elements from the original array

उदाहरण:

    2&(<:/\) 8 6 9 9 7 2 3 8 1 3
0 1 1 0 0 1 1 0 1
    1,2&(<:/\) 8 6 9 9 7 2 3 8 1 3
1 0 1 1 0 0 1 1 0 1
    (1 0 1 1 0 0 1 1 0 1) # 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3
    f =: #~1,2&(<:/\)
    f 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

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

— बोलस बूसियर
स्रोत
अच्छा समाधान! मैंने आपके कोड के लिए एक TIO लिंक जोड़ा।
— गैलेन इवानोव
4

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

>Ɲ0;¬×

I / O स्ट्रिंग्स पर है।

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

— डेनिस
स्रोत
मैं उत्सुक हूं, स्ट्रिंग्स पर काम क्यों कर रहा हूं और एरेज क्यों नहीं? मुझे बताया गया कि जेली तार में खराब है।
— पावेल
2
यह है। ×चरित्र पुनरावृत्ति के लिए काम नहीं करना चाहिए, लेकिन यह करता है।
— डेनिस
4

जावा 8, 66 55 48 बाइट्स

l->{for(int i=0;;)if(i>(i=l.next()))l.remove();}

@ OlivierGrégoire से एक टिप के बाद -11 बाइट्स ।
-7 और बाइट्स @ OlivierGrégoire की बदौलत ।

स्पष्टीकरण:

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

l->{                     // Method with Integer-ListIterator parameter and no return-type
  for(int i=0;;)         //  Loop over all items
    if(i>(i=l.next()))   //   If the current item is larger than the next
      l.remove();}       //    Remove this next item
— केविन क्रूज़सेन
स्रोत
क्यों हर किसी का उपयोग शुरू होता है ~0, जब यह मूल रूप से है -1। व्यक्तिगत रूप से मैं अधिक सहज समाधान चुनूंगा यदि बाइट-काउंट एक ही लंबाई है ( while(...)बनाम को छोड़कर for(;...;), जिस स्थिति में मैं पसंद करता हूं for। हालांकि, एक और -7 बाइट्स के लिए धन्यवाद। हालांकि। :)
— केविन क्रूज़सेन
ऐसा इसलिए है क्योंकि मैं 2-पूरक के साथ बुरा हूं ... मैं बहुत बुरा हूं Integer.MIN_VALUEजिसका मैं मतलब करना चाहता था (जो तब है 1<<31, मुझे लगता है ...) ;-)
— ओलिवियर ग्राईगोइरे
4

ऑक्टेव , 21 बाइट्स

@(x)x(~[0,diff(x)<0])

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

स्पष्टीकरण:

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

फिर हम इनपुट वेक्टर से उन तत्वों का चयन करते हैं जिन्हें हम रखना चाहते हैं।

— स्टीवी ग्रिफिन
स्रोत
4

वी , 25 बाइट्स

òjälá k$yl+@"òç-/d
ç /dw

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

Hexdump:

00000000: f26a e46c e120 6b24 796c 2b40 2218 f2e7  .j.l. k$yl+@"...
00000010: 2d2f 640a e720 2f64 77                   -/d.. /dw

नौकरी के लिए सबसे खराब भाषा। लेकिन मैंने हिम्मत की ।

— DJMcMayhem
स्रोत
6
साइड नोट: ओजला उम्मीद के लिए स्पेनिश है ।
— डेनिस
2
@ डेनिस यह शांत है। k$yl+@"òç-/dस्पैनिश क्या है ?
— DJMcMayhem
7
k$yl+@"òç-/dओउच के रूप में उदारतापूर्वक अनुवाद किया जा सकता है , किसने उस अलमारी के दरवाजे को खुला छोड़ दिया?
— लुइस मेन्डो
3

त्रिकोणीयता , 71 बाइट्स

.....).....
....IEL....
...)rFD)...
..2+)IE)w..
.+h)2_stDO.
={M)IEm}...

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

यह काम किस प्रकार करता है?

) IEL) rFD) 2+) IE) w + h) 2_stDO = {M) IEm} - पूर्ण कार्यक्रम।
) IE - 0 इनपुट I प्राप्त करें और इसका मूल्यांकन करें।
   एल) आर - और सीमा को धक्का [0 ... आई की लंबाई)।
      F {- इस श्रेणी में पूर्णांकों को फ़िल्टर करें जो संतुष्ट करते हैं:
       D) 2+) IE) w + h) 2_stDO = - यह स्थिति है। प्रत्येक तत्व E को एक अलग पर चलाता है
                                    उन मानदंडों को ढेर करें और त्यागें जो मानदंडों को पूरा नहीं करते हैं।
       D) 2+ - डुप्लिकेट और 2 को दूसरी कॉपी में जोड़ें।
           ) IE - फिर से प्राप्त करें।
              ) - स्टैक पर 0 दबाएं।
               डब्ल्यू - एक सूची में 0 लपेटें। [0]
                + - मैं इसे प्रस्तुत करता हूं।
                 ज - प्रमुख। इंडेक्स E + 2 के बाद तत्वों को ट्रिम करें।
                  ) 2_ - शाब्दिक -2।
                     सेंट - पूंछ।
                       डीओ = - जांचें कि क्या परिणाम सॉर्टिंग पर अपरिवर्तनीय है।
                           M) IEm} - अंतिम भाग: इनपुट में अनुक्रमण।
                           M} - शर्तों को पूरा करने वाले प्रत्येक सूचकांक के लिए:
                            ) IEm - उस स्थिति में I के तत्व को पुनः प्राप्त करें।
— श्री एक्सकोडर
स्रोत
2
जिज्ञासा से बाहर (चूंकि आप त्रिकोणीयता के निर्माता हैं): हेक्सागोनी / क्यूबिकली के समान कुछ क्यों नहीं करते, जहां कोड का एक टुकड़ा स्वचालित रूप से नो-ऑप डॉट्स से भरा होता है? तो यह कार्यक्रम ऐसा होगा )IEL)rFD)2+)IE)w+h)2_stDO={M)IEm}जो आपके वर्तमान उत्तर का विस्तार करेगा?
— केविन क्रूज़सेन
@ केविनक्रूजसेन क्योंकि मैं वास्तव में त्रिकोणीयता को 2 डी एसोलंग बनाने की योजना बना रहा था, लेकिन मैंने इस विचार को छोड़ दिया, इसलिए मैं सिर्फ अपने पिछले टेम्पलेट से चिपका रहा। मुझे लगता है कि मैं जल्द ही कुछ बड़े बदलाव करूंगा, जब मैं त्रिकोणीयता v2 जारी करूंगा। (इसके अलावा यह अपने वर्तमान स्वरूप में गोल्फ के लिए थोड़े मज़ेदार है, क्योंकि 1-बाइट बचाने के लिए एक सरल बाइट इनलाइन आपको 20: D को बचा सकती है ... सामान को ठीक करते समय यह
— रेट्रो
ठीक है, भले ही आप इसे 2 डी एसोलैंग के रूप में जारी करने पर योजना बनाते हैं, मेरी टिप्पणी अभी भी (कुछ हद तक) खड़ी है। )IEL)rFD)2+)IE)w+h)2_stDO={M)IEm}आपका कोड होगा, यह आपके वर्तमान टेम्पलेट में विस्तारित होगा, और फिर उस विस्तारित टेम्पलेट पर 2 डी कमांड करेगा। संपादित करें: .....).....\n....IEL....\n...)rFD)...\n..2+)IE)w..\n.+h)2_stDO.\n={M)IEm}...और .....).........IEL.......)rFD).....2+)IE)w...+h)2_stDO.={M)IEm}...और )IEL)rFD)2+)IE)w+h)2_stDO={M)IEm}तीनों में ठीक उसी कार्यक्रम होगा।
— केविन क्रूज़सेन
3

पायथन , 40 बाइट्स

f=lambda h,*t:t and h+f(*t)[h>t[0]:]or h

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

वर्णों के ट्यूल के रूप में इनपुट।

पायथन 3 , 41 बाइट्स

p=''
for x in input():x<p or print(x);p=x

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

स्ट्रिंग इनपुट।

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

for x in input():
 if x>=id:print x
 id=x

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

स्ट्रिंग इनपुट, सिर्फ इसलिए कि तार अधिक से अधिक हैं idलेकिन संख्या छोटी है।

— XNOR
स्रोत
3

वोल्फ्राम भाषा (गणितज्ञ) , 33 बाइट्स

Pick[#,Arg[#-{0}~Join~Most@#],0]&

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

यह काम किस प्रकार करता है

कोड # - {0}~Join~Most@#एक सरणी {a,b,c,d,e,f}में बदल जाता है {a,b-a,c-b,d-c,e-d,f-e}। इसके लिए आवेदन Argकरने से नकारात्मक संख्याएँ Piऔर गैर-संवेदी संख्याएँ निर्धारित होती हैं 0।

Pick[#, ..., 0]&हमारे मामले में #जहां : ...a की प्रविष्टियों को बाहर निकालता है 0, ठीक उसी तरह से जब आप पिछले तत्व को घटाते हैं तो एक नॉनजेक्टिव नंबर प्राप्त करते हैं। दूसरे शब्दों में, ये ठीक वैसी प्रविष्टियाँ हैं, जिन्हें हम lazydropsorting के दौरान रखना चाहते हैं।

— मिशा लावरोव
स्रोत
3

आश्चर्य है , 27 बाइट्स

-> ':1.!> 'sS#<=.cns2.++[0]

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

(-> ':1.!> 'sS#<=.cns2.++[0])[8 6 9 9 7 2 3 8 1 3]

व्याख्या

Ungolfed संस्करण:

(map get 1).(fltr sS <=).(cns 2).(++ [0])

प्रेपेंड करें 0, लगातार जोड़े की सूची प्राप्त करें , सूची आइटम रखें जहां पहला नंबर <= दूसरा नंबर, प्रत्येक जोड़ी का दूसरा नंबर प्राप्त करें।

— मामा फन रोल
स्रोत
3

वोल्फ्राम भाषा (गणितज्ञ) , 20 बाइट्स

#&@@@Split[#,##>0&]&
(* or *)
Max/@Split[#,##>0&]&

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

व्याख्या

Input = {8, 6, 9, 9, 7, 2, 3, 8, 1, 3}

Split[#,##>0&]

समूह लगातार तत्वों कि सख्ती से decresasing कर रहे हैं: {{8, 6}, {9}, {9, 7, 2}, {3}, {8, 1}, {3}}

#&@@@

प्रत्येक का पहला तत्व लें: {8, 9, 9, 3, 8, 3}

— जंगहवान मिन
स्रोत
##>0फैंसी और सब कुछ है, लेकिन यह वास्तव में #>#2यहाँ पर कुछ भी नहीं बचाता है;) (जो आपके कार्यक्रम को मनमाने ढंग से पूर्णांक के साथ काम करेगा, ऐसा नहीं है कि हालांकि इसकी आवश्यकता है)।
— मार्टिन एंडर
3

एसडब्ल्यूआई-प्रोलॉग, 44 बाइट्स

[A,B|C]-[A|E]:-B<A,[B|C]-[B|E];[B|C]-E. L-L.

उपयोग: कॉल " सूची -X" जहां सूची एक ब्रैकेट-संलग्न, अल्पविराम से अलग की गई सूची है जैसे [1,4,5,1,11,6,7]।

— ashtraypettingzoo
स्रोत
1
साइट पर आपका स्वागत है! :)
— DJMcMayhem
2

एपीएल + विन, 14 बाइट्स

पूर्णांक के एक वेक्टर के स्क्रीन इनपुट के लिए संकेत।

(1,1>2-/v)/v←⎕
— ग्राहम
स्रोत
2

कोटलिन , 39 बाइट्स

a->a.filterIndexed{i,v->i<1||v>=a[i-1]}

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

फ़िल्टर आइटम जो या तो पहला आइटम है (इंडेक्स == 0, या उससे भी छोटा इंडेक्स <1) या वर्तमान मूल्य पिछले आइटम ([[i-१]) से अधिक या बराबर है।

— Makotosan
स्रोत
2

एपीएल (डायलॉग यूनिकोड) , 11 बाइट्स

{⍵⌿⍨1⍪2≤⌿⍵}

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

यह वास्तव में ग्राहम के उत्तर के समान सुंदर है, लेकिन Dyalog में, और स्वतंत्र रूप से विकसित किया गया है। इसके अलावा, अधिक सममित।

— आउटग्रॉफर को एरिक करें
स्रोत
2

K4 , 10 बाइट्स

समाधान:

x_/|&<':x:

उदाहरण:

q)k)x_/|&<':x:8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

स्पष्टीकरण:

ऐसे सूचकांक ढूंढें जहां तत्व पूर्ववर्ती से कम है, इन सूचकांकों को इनपुट से हटा दें

x_/|&<':x: / the solution
        x: / store input as x
     <':   / less-than each-previous
    &      / indices where true
   |       / reverse
 _/        / drop-over
x          / the input
— streetster
स्रोत
2

अटैची , 24 बाइट्स

{Mask[1'(Delta!_>=0),_]}

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

व्याख्या

Maskअपने दूसरे तर्क से सभी तत्वों का चयन करता है जो अपने पहले तर्क में सत्य तत्वों से मेल खाता है। 1'(Delta!_>=0)उन सूचकांकों की गणना करता है जो उन तत्वों के अनुरूप होते हैं जिन्हें अंतिम सरणी में होना चाहिए।

अन्य प्रयास

28 बाइट्स (पॉइंटफ्री): ~Mask#(1&`'##Delta#`>=#C[0])

32 बाइट्स: {Mask[1'(&`<= =>Slices[_,2]),_]}

— कोनोर ओ ब्रायन
स्रोत
2

C # (.NET Core) , 33 + 18 = 51bytes

x=>x.Where((a,n)=>n<1||x[n-1]<=a)

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

मूल रूप से कथन यह है कि x कहाँ सरणी में पहला इंट है, या पिछली संख्या से अधिक या बराबर है, इसे रखें। इसे छोड़ दो।

— Dennis.Verweij
स्रोत
1
आप एक वापसी कर सकते हैं IEnumerable। कोई ToArray()जरूरत नहीं ।
— पावेल
@Pavel को मुझे एक अतिरिक्त संदर्भ जोड़ना होगा System.Collections, और इसे हटाने के लिए सहेजे गए सभी बाइट्स को नकार देगा ToArray()।
— डेनिस.वीरवीज
नहीं, क्योंकि आप IEnumerableउत्तर में संदर्भित नहीं होंगे , बस इसे रिटर्न प्रकार के रूप में उपयोग कर रहे हैं।
— पावेल
@ पावेल ओके थैंक्स, कभी-कभी मैं थोड़ा अनिश्चित हो जाता हूं जब बाइट्स को गिनना है या नहीं ... सॉरी
— डेनिस.विरवाइज
1

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

0;>ƝżµḢÐṂ

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

यह बहुत बुरा लगता है, अगर कोई बेहतर तरीका है तो वह आश्चर्यचकित नहीं होगा।

0;>ƝżµḢÐṂ
   Ɲ       For each adjacent pair in the input...
  >        ...is the first element greater than the second? (yields a list of 0/1)
0;         prepend a zero to this list (always keep the first element)
    ż      zip with the input
     µ     new monadic link
       ÐṂ  keep elements of the list with minimal value of... (Ðḟ would have worked here and been slightly more clear but I'll leave it as it is)
      Ḣ    ...their first element
— dylnan
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.