चुनौती

पूर्णांक के गैर-खाली सरणी को देखते हुए, उदाहरण के लिए:

[5, 2, 7, 6, 4, 1, 3]

पहले इसे उन सरणियों में बदल दें जहां कोई भी वस्तु पिछले (यानी गैर-आरोही सरणियों) से बड़ी नहीं है:

[5, 2] [7, 6, 4, 1] [3]

अगला, प्रत्येक सरणी को उल्टा करें:

[2, 5] [1, 4, 6, 7] [3]

अंत में, उन सभी को एक साथ सम्मिलित करें:

[2, 5, 1, 4, 6, 7, 3]

यह वही होना चाहिए जो आपका प्रोग्राम आउटपुट / फ़ंक्शन रिटर्न देता है। इस प्रक्रिया को पर्याप्त बार दोहराएं और सरणी पूरी तरह से हल हो जाएगी।

नियम

इनपुट और आउटपुट किसी भी मानक तरीकों के माध्यम से दिए जा सकते हैं, और किसी भी उचित सरणी प्रारूप में हो सकते हैं।
इनपुट सरणी कभी खाली नहीं होगी, लेकिन इसमें नकारात्मक और / या डुप्लिकेट हो सकते हैं।
प्रत्येक पूर्णांक का पूर्ण मान हमेशा 2 ³¹ से कम होगा ।

परीक्षण के मामलों

उम्मीद है कि इन सभी मामलों को कवर किया जाएगा:

[1] -> [1]
[1, 1] -> [1, 1]
[1, 2] -> [1, 2]
[2, 1] -> [1, 2]
[2, 3, 1] -> [2, 1, 3]
[2, 1, 3] -> [1, 2, 3]
[2, 1, 2] -> [1, 2, 2]
[2, 1, 1] -> [1, 1, 2]
[3, 1, 1, 2] -> [1, 1, 3, 2]
[3, 2, 1, 2] -> [1, 2, 3, 2]
[3, 1, 2, 2] -> [1, 3, 2, 2]
[1, 3, 2, 2] -> [1, 2, 2, 3]
[1, 0, 5, -234] -> [0, 1, -234, 5]
[1, 0, 1, 0, 1] -> [0, 1, 0, 1, 1]
[1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]
[5, 4, 3, 2, 1] -> [1, 2, 3, 4, 5]
[2, 1, 5, 4, 3] -> [1, 2, 3, 4, 5]
[2, 3, 1, 5, 4] -> [2, 1, 3, 4, 5]
[5, 1, 4, 2, 3] -> [1, 5, 2, 4, 3]
[5, 2, 7, 6, 4, 1, 3] -> [2, 5, 1, 4, 6, 7, 3]
[-5, -2, -7, -6, -4, -1, -3] -> [-5, -7, -2, -6, -4, -3, -1]
[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9] -> [3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf array-manipulation sorting

— ETHproductions
स्रोत

4

इस छँटाई विधि का बड़ा-ओ क्या है?

— mbomb007

1

@ mbomb007 मैं बड़े-ओ नोटेशन को अच्छी तरह से नहीं समझता, लेकिन मुझे लगता है कि एक एकल पुनरावृत्ति हे (n)। गुणा करें कि सबसे खराब स्थिति एन पुनरावृत्तियों द्वारा और आपको ओ (एन ^ 2) मिलता है (सबसे खराब स्थिति; सर्वश्रेष्ठ मामला ओ) (एन) होगा, मुझे लगता है, एक एकल पुनरावृत्ति के लिए)।

— ETHproductions

1

यही कारण है कि मेरे लिए सही लगता है, लेकिन यह की उनका कहना है कि एक सरणी पीछे एक बहुत ही कुशल संचालन, नहीं है तो यह एक धीमी है लायकO(n^2)

— DJMcMayhem

2

@WheatWizard एक सरणी को उलटने के लिए सरणी की एक प्रति के लिए कमरे की आवश्यकता नहीं है, केवल एक ही तत्व के लिए कमरा है। और है O(n)। पहले और आखिरी तत्वों की अदला-बदली करें और फिर बीच के पड़ाव पर पहुंचने पर दूसरे और दूसरे आखिरी तत्वों आदि को स्वैप करें।

— जैसें

O(n)रिवर्स करना है , लेकिन रिवर्स को एल्गोरिथ्म में बनाया जा सकता है (यही मेरा जेएस उत्तर करता है); चूंकि प्रत्येक पुनरावृति सरणी में प्रत्येक आइटम पर एक बार लूप करता है, एक एकल पुनरावृत्ति है O(n)। (मुझे लगता है ...)

— ETHproductions

19

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

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

पुनरावर्तन FTW! यहां उपयोग में आने वाला मूल एल्गोरिदम एक सरणी में वर्तमान गैर-आरोही रन का ट्रैक रखने के लिए है, जब भी कोई आरोही तत्व पाया जाता है, तो इसे "वापस" करना होगा। जब तक हम वस्तुओं से बाहर नहीं निकलते हैं, हम परिणामों को लगातार बदलते रहते हैं। प्रत्येक रन को रिवर्स ( [n,...z]इसके बजाय [...z,n]) बनाकर , हम .reverse()बिना किसी लागत के लंबे समय तक बच सकते हैं ।

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

g=a=>console.log("Input:",`[${a}]`,"Output:",`[${f(a)}]`)

g([1])
g([1,1])
g([1,2])
g([2,1])
g([3,2,1])
g([3,1,2])
g([3,1,1,2])
g([5,2,7,6,4,1,3])

<input id=I value="5, 2, 7, 6, 4, 1, 3">
<button onclick="g((I.value.match(/\d+/g)||[]).map(Number))">Run</button>

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

क्या आप बता सकते हैं कि आपका सरणी आपके पहले पैरामीटर में कैसे पार हो जाता है [n,...a]। क्या है n? क्या यह आपके सरणी में पहला आइटम है?

— ओलिवर

1

@obarakon सही। nसरणी में पहला आइटम है, और aबाकी सरणी है। आप अधिक जानकारी यहाँ पा सकते हैं ।

— ETHproductions

धन्यवाद। यह बहुत मददगार था। चूँकि आपका पहला पैरामीटर एक सरणी है, इसलिए आपको इसे शामिल करने की आवश्यकता क्यों है ...a? क्या ऐसा है ताकि आप इसका लाभ उठा सकें n? एक और बात, जब आप कॉल करते हैं f(a,q), qतो पैरामीटर पर सेट हो जाता है z?

— ओलिवर

1

@obarakon खैर, f=([n])=>...केवल पहले तत्व f=([n,a])=>...पर कब्जा करेगा , और केवल पहले में nऔर दूसरे में कब्जा करेगा a। एक और तरीका है जो f=([n,...a])=>,,,करता है f=a=>(n=a.unshift(),...।

— ETHproductions

1

और चूंकि zफ़ंक्शन में दूसरा पैरामीटर है, जब f(a,q)बुलाया जाता है, तो fइसे इस रूप में देखता है z। उम्मीद है की यह मदद करेगा!

— ETHproductions

14

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

f=lambda x,*p:x[:1]>p>()and p+f(x)or x and f(x[1:],x[0],*p)or p

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

— डेनिस
स्रोत

11

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

Ṁ;<œṗ³UF

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

स्पष्टीकरण:

Ṁ;         Prepend the list [a1, a2… an] with its maximum.
  <        Elementwise compare this with the original list:
           [max(a) < a1, a1 < a2, …, a(n-1) < an, an]
           The first element is always 0.
   œṗ³     Partition the original list (³) at the indices
           of the non-zero values in the working list.
           (The spurious `an` at the end of the left argument,
           resulting from comparing lists of different sizes,
           is ignored by this operation, thankfully.)
      U    Reverse each part.
       F   Flatten.

— लिन
स्रोत

1

जब मैंने आपका उत्तर देखा तो सेव एडिट मारने की कगार पर था ... शाबाश।

— डेनिस

@ डेनिस हेह, इसलिए आपने डायलॉग विभाजन संलग्न को जोड़ा, लेकिन एपीएल 2 विभाजन के बारे में क्या?

— Adám

11

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

ज़रूर, यह पहले से ही ETHproductions के जवाब से पिट गया है , लेकिन यह सबसे अच्छा है जो मैं अब तक पुनरावृत्ति का उपयोग किए बिना आ सकता हूं।

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

नोट: दोनों के साथ rऔर oसटीक एक ही वस्तु के साथ r = o = []एक खतरनाक विचार जैसा लग सकता है। लेकिन यहां ऐसा करना सुरक्षित है क्योंकि rइसके aसाथ पहली यात्रा पर तुरंत अपना उदाहरण (पहले तत्व वाला ) सौंपा गया है r = [n, ...r]।

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

console.log(JSON.stringify(f([1])));
console.log(JSON.stringify(f([1, 1])));
console.log(JSON.stringify(f([1, 2])));
console.log(JSON.stringify(f([2, 1])));
console.log(JSON.stringify(f([2, 3, 1])));
console.log(JSON.stringify(f([2, 1, 3])));
console.log(JSON.stringify(f([2, 1, 2])));
console.log(JSON.stringify(f([2, 1, 1])));
console.log(JSON.stringify(f([3, 1, 1, 2])));
console.log(JSON.stringify(f([3, 2, 1, 2])));
console.log(JSON.stringify(f([3, 1, 2, 2])));
console.log(JSON.stringify(f([1, 3, 2, 2])));
console.log(JSON.stringify(f([1, 0, 5, -234])));
console.log(JSON.stringify(f([1, 0, 1, 0, 1])));
console.log(JSON.stringify(f([1, 2, 3, 4, 5])));
console.log(JSON.stringify(f([5, 4, 3, 2, 1])));
console.log(JSON.stringify(f([2, 1, 5, 4, 3])));
console.log(JSON.stringify(f([2, 3, 1, 5, 4])));
console.log(JSON.stringify(f([5, 1, 4, 2, 3])));
console.log(JSON.stringify(f([5, 2, 7, 6, 4, 1, 3])));
console.log(JSON.stringify(f([-5, -2, -7, -6, -4, -1, -3])));
console.log(JSON.stringify(f([14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9])));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

2

कोई चिंता नहीं, मुझे अलग-अलग तरीकों से देखना पसंद है। और एक अक्सर गोल्फिंग के बाद दूसरे से छोटा होता जा रहा है :-)

— ETHproductions

8

MATL , 15 बाइट्स

lidO>vYsGhXSOZ)

इनपुट एक कॉलम वेक्टर है, प्रारूप के साथ [5; 2; 7; 6; 4; 1; 3](अर्धविराम पंक्ति विभाजक है)।

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

[5; 2; 7; 6; 4; 1; 3]उदाहरण के रूप में इनपुट लें ।

व्याख्या

l     % Push 1
      % STACK: 1
i     % Push input
      % STACK: 1, [5; 2; 7; 6; 4; 1; 3]
d     % Consecutive differences
      % STACK: 1, [-3; 5; -1; -2; -3; 2]
O>    % Test if greater than 0, element-wise
      % STACK: 1, [0; 1; 0; 0; 0; 1]
v     % Concatenate vertically
      % STACK: [1; 0; 1; 0; 0; 0; 1]
Ys    % Cumulative sum
      % STACK: [1; 1; 2; 2; 2; 2; 3]
G     % Push input again
      % STACK: [1; 1; 2; 2; 2; 2; 3], [5; 2; 7; 6; 4; 1; 3]
h     % Concatenate horizontally
      % STACK: [1 5; 1 2; 2 7; 2 6; 2 4; 2 1; 3 3]
XS    % Sort rows in lexicographical order
      % STACK: [1 2; 1 5; 2 1; 2 4; 2 6; 2 7; 3 3]
OZ)   % Get last column. Implicitly display
      % STACK: [2; 5; 1; 4; 6; 7; 3]

— लुइस मेंडो
स्रोत

मैंने आपके उत्तर का अनुवाद किया ऑक्टेव ने मुझे 31 बाइट्स से बचाया

— rahnema1

7

गणितज्ञ, 30 27 बाइट्स

^{@ बर्टिन एंडर के कारण 3 बाइट्स बच गए ।}

Join@@Sort/@Split[#,#>#2&]&

अनाम फ़ंक्शन। इनपुट के रूप में संख्याओं की एक सूची लेता है और आउटपुट के रूप में संख्याओं की एक सूची देता है।

— LegionMammal978
स्रोत

मुझे इससे हराएं! :)

— ग्रेग मार्टिन

5

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

वास्तव में भयानक गोल्फ, लेकिन मैं अपना समाधान पोस्ट करना चाहता था (एक नहीं बस डगलस डेनिस) ...

d=input();L=[];x=0;d+=-~d[-1],
for i in range(1,len(d)):
 if d[i]>d[i-1]:L+=d[x:i][::-1];x=i
print L

Repl.it पर टेस्ट करें!

इनपुट को पायथन सूची शाब्दिक के रूप में दिया जाना चाहिए, जैसे [5, 3, 4, 2, 6, 1]।

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

— FlipTack
स्रोत

मुझे लगता है कि पहली पंक्ति हो सकती है d,L,x=input(),[],0;d+=...।

— डैनियल

@ डोप्प्प बिल्कुल उसी बाइट की गिनती है

— FlipTack

4

Pyke, 11 8 बाइट्स ( पुराना संस्करण )

$0m<fm_s

यहाँ कोशिश करो! (नवीनतम संस्करण पर काम करता है)

$        -     delta(input)
 0m<     -    map(i<0 for i in ^)
    f    -   split_at(input, ^)
     m_  -  map(reverse, ^)
       s - sum(^)

— नीला
स्रोत

4

रेटिना , 163 बाइट्स

हां, मुझे पता है कि यह कितना डरावना है। ज़ीरो और निगेटिव का समर्थन सुपर मजेदार था । बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

\d+
$*
(?<=-1*)1
x
-

x,1
x¶1
\b(1+),(1+\1)\b
$1¶$2
,,1
,¶1
x,(¶|$)
x¶¶
(?<=\b\1x+(?=,(x+))),\b
¶
O%$#`.(?=(.*))
$.1
+`¶
,
\bx
-x
(\w+)
$.1
^,
0,
,$
,0
,,
,0,
^$
0

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

स्पष्टीकरण:

\d+                         # Convert to unary
$*
(?<=-1*)1                   # Replace negatives with x's instead of 1's
x
-                           # Remove minus sign

x,1                         # Separate if negative before positive
x¶1
\b(1+),(1+\1)\b             # or greater positive follows a positive
$1¶$2
,,1                         # or positive follows a zero
,¶1
x,(¶|$)                     # or zero follows a negative
x¶¶
(?<=\b\1x+(?=,(x+))),\b     # or negative follows a negative of greater magnitude.
¶
O%$#`.(?=(.*))              # Swear at the input, then reverse each line
$.1
+`¶                         # Remove breaks, putting commas back
,
\bx                         # Put the minus signs back
-x
(\w+)                       # Replace unary with length of match (decimal)
$.1
^,                          # Do a bunch of replacements to resurrect lost zeros
0,
,$
,0
,,
,0,
^$
0

— mbomb007
स्रोत

4

05AB1E , 19 18 16 14 बाइट्स

लुइस मेंडो की छंटनी चाल का उपयोग करके 2 बाइट्स बचाए

ü‹X¸ì.pO¹)ø{ø¤

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

व्याख्या

उदाहरण इनपुट [5, 2, 7, 6, 4, 1, 3]

ü‹               # pair-wise less-than
                 # STACK: [0, 1, 0, 0, 0, 1]
  X¸ì            # prepend a 1
                 # STACK: [1, 0, 1, 0, 0, 0, 1]
     .p          # prefixes
       O         # sum
                 # STACK: [1, 1, 2, 2, 2, 2, 3]
        ¹        # push input
                 # STACK: [1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]
         )       # wrap stack in list
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]]
          ø      # zip
                 # STACK: [[1, 5], [1, 2], [2, 7], [2, 6], [2, 4], [2, 1], [3, 3]]
           {     # sort
                 # STACK: [[1, 2], [1, 5], [2, 1], [2, 4], [2, 6], [2, 7], [3, 3]]
            ø    # zip
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [2, 5, 1, 4, 6, 7, 3]]
             ¤   # tail
                 # OUTPUT: [2, 5, 1, 4, 6, 7, 3]

पिछले 16 बाइट समाधान

Dü‹X¸ì.pO.¡€g£í˜

— Emigna
स्रोत

उन लाइनब्रीक्स ने इसे आश्चर्यजनक रूप से समझाया ...:

— स्टीवी ग्रिफिन

@StewieGriffin: हाँ, मैंने कोड को बदल दिया है और इससे पहले कि मैंने स्पष्टीकरण को फिर से लिखा हो, पोस्ट किया: P

— Emigna

4

जावास्क्रिप्ट (ECMA 6), 121 128 125 119 108 बाइट्स

f=a=>{p=a[0],c=[],b=[];for(e of a){e>p&&b.push(c.reverse(c=[]));c.push(p=e)}return[].concat.call([],...b,c)}

लैम्ब्डा अभिव्यक्ति एक एकल Arrayपैरामीटर लेता है a,।

मेरी पहली गलती को देखने में मेरी मदद करने के लिए @ETHproductions का धन्यवाद।

— XavCo7
स्रोत

अच्छा! मुझे लगता है कि आप return(b+","+c).split`,` अंत में कुछ बाइट्स को बचाने के लिए कर सकते हैं ।

— ETHproductions

1

बेहतर अभी तक, आप रिवर्स करने की आवश्यकता को दूर करने के c.unshiftबजाय उपयोग कर सकते हैं । ऐसा करने के बाद, मुझे 94 बाइट्स मिलीं । c.pushc

— ETHproductions

3

रूबी, 60 55 बाइट्स

s=->x{x.slice_when{|p,q|p<q}.map{|z|z.reverse}.flatten}

बहुत ज्यादा क्या चुनौती के लिए कहा। मैं एक लैम्ब्डा परिभाषित s, जिसे एक श्रृंखला लेता है x, और Sever छोटे टुकड़ों जहां निम्नलिखित तत्व से अधिक होना होगा में (स्लाइस) यह। यह वापस एक प्रगणक, जो हम नक्शे पर फोन कर सकते हैं और देता है रिवर्स टुकड़े के आदेश, इससे पहले कि अंत में यह समतल के साथ सब एक साथ है, जो लाने concatenates एक सरणी में परिभाषित क्रम में तत्वों।

टेस्ट

p s[[1]]===[1]
p s[[1, 1]]===[1, 1]
p s[[1, 2]]===[1, 2]
p s[[2, 1]]===[1, 2]
p s[[2, 3, 1]]===[2, 1, 3]
p s[[2, 1, 3]]===[1, 2, 3]
p s[[2, 1, 2]]===[1, 2, 2]
p s[[2, 1, 1]]===[1, 1, 2]
p s[[3, 1, 1, 2]]===[1, 1, 3, 2]
p s[[3, 2, 1, 2]]===[1, 2, 3, 2]
p s[[3, 1, 2, 2]]===[1, 3, 2, 2]
p s[[1, 3, 2, 2]]===[1, 2, 2, 3]
p s[[1, 0, 5, -234]]===[0, 1, -234, 5]
p s[[1, 0, 1, 0, 1]]===[0, 1, 0, 1, 1]
p s[[1, 2, 3, 4, 5]]===[1, 2, 3, 4, 5]
p s[[5, 4, 3, 2, 1]]===[1, 2, 3, 4, 5]
p s[[2, 1, 5, 4, 3]]===[1, 2, 3, 4, 5]
p s[[2, 3, 1, 5, 4]]===[2, 1, 3, 4, 5]
p s[[5, 1, 4, 2, 3]]===[1, 5, 2, 4, 3]
p s[[5, 2, 7, 6, 4, 1, 3]]===[2, 5, 1, 4, 6, 7, 3]
p s[[-5, -2, -7, -6, -4, -1, -3]]===[-5, -7, -2, -6, -4, -3, -1]
p s[[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9]]===[3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

— manonthemat
स्रोत

1

आपका स्वागत है, अच्छा <s> पहला </ s> दूसरा उत्तर, यह जांचें: codegolf.stackexchange.com/questions/363/…

— GB

बहुत बहुत धन्यवाद। इसे एक मेमने में बदल दिया, जैसा कि आपके द्वारा दिए गए लिंक में सुझाया गया है, और इस तरह से 5 बाइट्स बचाए गए हैं।

— मनमोहन

2

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

~c:{>=r}ac

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

व्याख्या

~c            Deconcatenate the Input
  :{>=r}a     Each resulting sublist must be non-increasing, and then reverse it
         c    Concatenate

— Fatalize
स्रोत

क्या Brachylog's c, जब रिवर्स में चलती है, तो जरूरी है कि पहले कम सूचियों में विभाजन का प्रयास करें?

@ ais523 हाँ, यह करता है।

— 13

1

दिल्लोग एपीएल , 7 15 बाइट्स

आवश्यकता है ⎕ML←3, जो कई प्रणालियों पर डिफ़ॉल्ट है। *

{∊⌽¨⍵⊂⍨1+⍵-⌊/⍵}

∊ सूची (समतल)

⌽¨ प्रत्येक-उलट

⍵⊂⍨ तर्क का विभाजन * काटकर जहां प्रत्येक संगत तत्व अपने पूर्ववर्ती की तुलना में बड़ा है

1+ एक प्लस

⍵- तर्क माइनस

⌊/⍵ तर्क का सबसे छोटा तत्व

गैर-धनात्मक पूर्णांक के साथ पुराना 7 बाइट समाधान विफल रहता है:

आवश्यकता है ⎕ML←3, जो कई प्रणालियों पर डिफ़ॉल्ट है। *

∊⌽¨⊆⍨⎕

∊ enlist (समतल)

⌽¨ प्रत्येक-उलट

⊂⍨ आत्म विभाजित *

* विभाजन ( ⊂) एक ऐसा कार्य है जो इसके दाहिने तर्क को काटता है जहां संबंधित बाएं तर्क पूर्ववर्ती की तुलना में बड़ा होता है। (दुर्भाग्य से यह केवल गैर-नकारात्मक पूर्णांक को स्वीकार करता है, और शून्य का विशेष अर्थ है।) संस्करण 16 से, यह कार्यक्षमता ⊂सभी प्रणालियों (यहां तक कि जहां ⎕ML≠3) पर उपलब्ध है, ग्लिफ़ का उपयोग करते हुए ⊆।

— एडम
स्रोत

1

हास्केल, 49 बाइट्स

(a:b)%l|any(<a)l=l++b%[a]|1<2=b%(a:l)
_%l=l
(%[])

प्रयोग उदाहरण: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3]।

पुनरावर्ती दृष्टिकोण। फ़ंक्शन %इनपुट सूची को अपने पहले पैरामीटर और एक संचायक के रूप में लेता है lजो अब तक गैर-आरोही चंक का ट्रैक रखता है (रिवर्स में)। बेस मामला तब तक पहुंच जाता है जब इनपुट सूची खाली होती है और फिर परिणाम संचायक होता है। यदि इनपुट सूची खाली नहीं है और पहला तत्व aवर्तमान चंक ( any(<a)l) में फिट नहीं होता है , तो संचायक को लौटाएं और बाकी सूची पर और aनए संचयकर्ता ( l++b%[a]) के रूप में पुनरावर्ती कॉल को जोड़ें । बाकी, सूची के बाकी हिस्सों पर एक पुनरावर्ती कॉल करें और aथा संचायक ( b%(a:l)) के लिए तैयार किया। मुख्य फ़ंक्शन एक खाली संचायक के साथ (%[])कॉल %करता है।

— nimi
स्रोत

1

रेटिना , 98 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

$

-(\d+)
$1$*-/
\d+
$*
S-`(?<=(-+)/ )(?!\1)|(?=\b(1+))(?<!\2 )
O%`\S* 
¶

((-)|1)*/? 
$2$#1 
 $

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

— मार्टिन एंडर
स्रोत

1

आर, 64 बाइट्स

cat(unlist(lapply(split(x<-scan(),cumsum(c(F,diff(x)>0))),rev)))

स्टड से इनपुट पढ़ता है। हम इनपुट को वैक्टर की एक सूची में विभाजित करते हैं split()जिसके उपयोग से इनपुट को समूहीकृत करने वाले कारक चर की आवश्यकता होती है। कारक तार्किक वेक्टर के संचयी योग को लेकर बनाया जाता है जिसके लिए अंतर सकारात्मक है।

वेक्टर पर विचार करें:

x=c(5, 2, 7, 6, 4, 1, 3)

अब अंतर लेना और Fदौड़ने से पूर्ववर्ती y=c(F,diff(x)>0)तार्किक वेक्टर का उत्पादन होगा:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

संचयी राशि लेने से cumsum(y)एक वेक्टर उत्पन्न होता है जहां प्रत्येक समूह को एक अद्वितीय कारक द्वारा दर्शाया जाता है, जिस पर हम splitफ़ंक्शन के साथ संयोजन कर सकते हैं :

[1] 0 0 1 1 1 1 2

— Billywob
स्रोत

diffinvइसके बजाय 60 बाइट्स का उपयोग करना cumsum।

— गिउसेप्पे

1

ऑक्टेव, 75 44 बाइट्स

@LuisMendo के MATL उत्तर के आधार पर

@(a)sortrows([cumsum([1;diff(a)>0]),a])(:,2)

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

पिछला उत्तर

@(a)[fliplr(mat2cell(f=fliplr(a),1,diff(find([1,diff(f)<0,numel(a)])))){:}]

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

सरणी को उल्टा करें

f=fliplr(a)

का पहला अंतर f

d = diff(f);

उस स्थिति को ढूंढें जहां अगला तत्व पिछले तत्व से कम है

p=find([1,diff(f)<0,numel(a)])

पदों का पहला अंतर प्रत्येक उप सरणी की लंबाई देता है

len=diff(p)

mat2cellसरणी की नेस्टेड सूची में सरणी को विभाजित करने के लिए प्रत्येक उप सरणी की लंबाई का उपयोग करें

nest = mat2cell(f,1,len);

नेस्टेड सूची को उल्टा करें

rev_nest = fliplr(nest)

नेस्टेड सूची को समतल करें

[rev_nest{:}]

— rahnema1
स्रोत

0

पायथ - 15 बाइट्स

s_McQf<@QtT@QTU

इसे यहाँ ऑनलाइन आज़माएँ ।

— Maltysen
स्रोत

0

पर्ल 6 , 59 बाइट्स

{map |+«*.[0].reverse,m/:s([(\-?\d+)<?{[>=] $0}>] +)+/[0]}

रेगेक्स-आधारित समाधान।
क्योंकि यह ~~स्पार्टा~~ पर्ल है !!

m/ /: इनपुट ऐरे को स्ट्रिंग करें, और इसके खिलाफ एक रेग्ज से मेल करें।
(\-? \d+): एक संख्या का मिलान करें, और इसे कैप्चर करें $0।
<?{ [>=] $0 }>: शून्य-चौड़ाई का दावा जो केवल तभी मेल खाता है यदि $0वर्तमान उप-मैच में अब तक पकड़े गए सभी गैर-आरोही क्रम में हैं।
([ ] +)+: अंतिम दो चरणों को जितनी बार संभव हो दोहराएं, अन्यथा एक नया उप-मैच शुरू करें।
map , [0]: उप-मैचों में Iterate।
|+«*.[0].reverse: प्रत्येक के लिए $0, द्वारा मिलान किए गए मानों की सूची लें, इसे उल्टा करें, मानों को संख्याओं ( +«) से जोड़ दें, और उन्हें बाहरी सूची ( |) में खिसका दें ।

पर्ल 6 , 63 बाइट्स

sub f(\a){flat $_,f a[+$_..*]with first {[<=] $_},:end,[\R,] a}

पुनरावर्ती सूची प्रसंस्करण समाधान।
जितना मैंने आशा की थी उससे अधिक श्रमशील।
भले ही भाषा में बहुत सारे सुविधाजनक बिल्ट-इन हों, लेकिन सूची विभाजन के लिए कोई नहीं लगता है (जैसे कि रूबी slice_whenया हास्केल का takeWhile)।

— SMLS
स्रोत

0

स्टैक किया गया , नॉनकंपेटिंग, 34 बाइट्स

फिर भी लगातार इस भाषा को विकसित कर रहे हैं।

{e.b:e b last<}chunkby$revmap flat

तर्क टीओएस पर निहित है। यहाँ कोशिश करो!

chunkbyएक फ़ंक्शन लेता है और सन्निहित डेटा के सरणियों को इकट्ठा करता है जो फ़ंक्शन को संतुष्ट करते हैं। समारोह है:

{e.b:e b last<}
{e.b:         }  function with arguments [e, <unused>, b]--the element, <the index>, and the
                 chunk being built
     e       <   check if e is less than
       b last    the last element of b

यह एक सख्ती से घटती हुई सरणी देता है।

$revmapमूल रूप से है [rev]mapऔर प्रत्येक आइटम को उलट देता है।

flat अंत में सरणी को समतल करता है।

सरणी को वास्तव में छाँटने के लिए कुछ मज़ा:

[{e.b:e b last<}chunkby$revmap flat] @:sortstep
[$sortstep periodloop] @:sort

10:> @arr
arr out
arr shuf @arr
arr out
arr sort out

यह आउटपुट (उदाहरण के लिए):

(0 1 2 3 4 5 6 7 8 9)
(4 5 1 0 6 7 2 8 9 3)
(0 1 2 3 4 5 6 7 8 9)

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

0

अजगर, 151 139 बाइट्स

सहेजे गए 12 बाइट्स @ Flp.Tkc की बदौलत!

@ Flp.Tkc के पास कहीं नहीं, अकेले चलो ...

def s(l):
 r=[];i=j=0
 while j<len(l)-1:
  if l[j+1]>l[j]:r+=l[i:j+1][::-1],;i=j+1
  j+=1
 r+=l[i:j+1][::-1],;return[i for s in r for i in s]

— Noodle9
स्रोत

एपेंड का उपयोग करने के बजाय, += data,अनुगामी अल्पविराम का उपयोग करें, स्पष्ट रूप से एक टपल का निर्माण करता है, जिसे फिर सूची में अंतिम तत्व के रूप में डेटा जोड़कर सूची के साथ समतल किया जाता है। इस संदर्भ में, Dor+=l[i:j+1][::-1],

— FlipTack

0

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

b=[];c=[];a+=9e9,
for i in a[:-1]:
 b=[a.pop(0)]+b
 if b[0]<a[0]:c+=b;b=[]

में इनपुट a, आउटपुट इनc

— सर्गेई पतिकिन
स्रोत

0

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

a=[int(i)for i in input().split()]
while a!=sorted(a):
 b=[[]]
 for i,j in enumerate(a):
  if a[i-1]<j:b+=[[j]]
  else:b[-1]+=[j]
 a=[]
 for l in[k[::-1]for k in b]:a+=[k for k in l]
print(a)

मुझे यकीन नहीं है कि अगर sortedफंक्शन का उपयोग करने की अनुमति यहां दी गई है, लेकिन मैं इसके खिलाफ एक अच्छा कारण नहीं सोच सकता, और इसने मेरी बाइट गिनती ~ 30 बाइट्स से नीचे ला दी।

— sonrad10
स्रोत

0

क्लोजर, 105 बाइट्स

#(filter number?(mapcat reverse(partition-by not(mapcat(fn[[a b]][a(< b a)])(partition 2 1(conj % 1))))))

लगातार संख्या, कहते हैं पर जोड़े में विभाजन trueया falseउन दोनों के बीच, पर विभाजन notकरने के लिए trueऔर जो नंबर बन falseऔर false true, उलट विभाजन और संख्यात्मक मानों रहता है।

— NikoNyrh
स्रोत

एक सरणी की तरह गंभीर

चुनौती

नियम

परीक्षण के मामलों

स्कोरिंग

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

टेस्ट स्निपेट

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

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

स्पष्टीकरण:

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

परीक्षण के मामलों

MATL , 15 बाइट्स

व्याख्या

गणितज्ञ, 30 27 बाइट्स

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

Pyke, 11 8 बाइट्स ( पुराना संस्करण )

रेटिना , 163 बाइट्स

05AB1E , 19 18 16 14 बाइट्स

जावास्क्रिप्ट (ECMA 6), 121 128 125 119 108 बाइट्स

रूबी, 60 55 बाइट्स

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

व्याख्या

दिल्लोग एपीएल , 7 15 बाइट्स

हास्केल, 49 बाइट्स

रेटिना , 98 बाइट्स

आर, 64 बाइट्स

ऑक्टेव, 75 44 बाइट्स

पायथ - 15 बाइट्स

पर्ल 6 , 59 बाइट्स

पर्ल 6 , 63 बाइट्स

स्टैक किया गया , नॉनकंपेटिंग, 34 बाइट्स

अजगर, 151 139 बाइट्स

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

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

क्लोजर, 105 बाइट्स