41

जैसा कि इस प्रश्न में वर्णित है :

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

उनके परीक्षण मामलों में से एक का उपयोग करने के लिए, {1, 2, 5, 4, 3, 7}पैदावार का एक इनपुट {1, 2, 5, 7}, जैसा कि 4और 3दोनों को पहले "क्रमबद्ध" मूल्य से छोटा होने के लिए गिरा दिया गया है 5।

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

हालाँकि, हमारी सूचियों की व्यवस्था और सामग्री महत्वपूर्ण है। आपके प्रोग्राम का आउटपुट ड्रॉपसॉर्ट के आउटपुट के बराबर होना चाहिए, उसके बाद डिसलाइज्ड वैल्यू का ड्रॉपशॉट, और इसी तरह तब तक जब तक आपके पास केवल सॉर्ट की गई चेन की सूची न हो। फिर, मौजूदा परीक्षण सूट उधार (और दो और जोड़कर):

Input                  -> Output
{1, 2, 5, 4, 3, 7}     -> {{1, 2, 5, 7}, {4}, {3}}
{10, -1, 12}           -> {{10, 12}, {-1}}
{-7, -8, -5, 0, -1, 1} -> {{-7, -5, 0, 1}, {-8, -1}}
{9, 8, 7, 6, 5}        -> {{9}, {8}, {7}, {6}, {5}}
{10, 13, 17, 21}       -> {{10, 13, 17, 21}}
{10, 10, 10, 9, 10}    -> {{10, 10, 10, 10}, {9}}  //Note equivalent values aren't dropped
{5, 4, 3, 8, 7, 6}     -> {{5, 8}, {4, 7}, {3, 6}}
{0, 2, 5, 4, 0, 7}     -> {{0, 2, 5, 7}, {4}, {0}}

आप मान सकते हैं कि इनपुट गैर-रिक्त है।

यह कोड-गोल्फ है , इसलिए मानक नियम लागू होते हैं!

code-golf sorting

— भगवान फरक्काड
स्रोत

हम उत्पादन की तरह कर सकते हैं [5, 4, 3, 8, 7, 6] -> [5, 8], [4,3,7,6]?

— श्री Xcoder

5

@Xcoder, अच्छी तरह से मैं वाक्य रचना को बुरा नहीं मानता, लेकिन आपको अभी भी दूसरी सूची को क्रमबद्ध करना होगा (और इस मामले में विभाजित करना होगा)। यह जानना कि कब रोकना चुनौती का हिस्सा है;)। और स्टू, मुझे सच में नहीं पता कि आपको क्या बताना है। मैंने DropSort को चुनौती दी और सोचा कि यह मजेदार है। कोई भी मौका जो आपने अपने टाइम मशीन का इस्तेमाल किया था, आगे कूदने और इस सवाल को देखने के लिए? सबसे अच्छा जवाब देखने के लिए इसका इस्तेमाल न करें!

— लॉर्ड फरक्वाड

ध्यान दें कि बाईं ओर की छंटाई को जोड़ने से रैखिक समय से समाधान निकलता है।

— 22

में {3,4,5,3,4,5,3,4,5}परिणाम होना चाहिए {{3,4,5,5,5},{3,4,4},{3}}?

— QBrute 10

@ क्यू मुझे लगता है कि यह सही है।

— लॉर्ड फरक्वाड

10

MATL , 15 10 9 बाइट्स

संचयी अधिकतम के @ बीकर के विचार का उपयोग करके 5 बाइट्स

t"ttY>=&)

इनपुट एक संख्यात्मक पंक्ति वेक्टर है, प्रारूप में [1, 2, 5, 4, 3, 7](अल्पविराम वैकल्पिक हैं)। आउटपुट में नई सूचियों से अलग की गई सूची होती है, जिसमें प्रत्येक सूची में संख्याओं के अनुसार रिक्त स्थान होते हैं।

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

व्याख्या

एक सरणी को देखते हुए, कोड उस प्रत्येक प्रविष्टि से चुनता है जो उस प्रविष्टि तक संचयी अधिकतम के बराबर होती है।

उदाहरण के लिए, दिया गया

1 2 5 4 3 7

कोड पहले, दूसरे, तीसरे और छठे प्रविष्टियों को चुनता है:

1 2 5     7

फिर इस प्रक्रिया को शेष प्रविष्टियों (मूल क्रम में) द्वारा गठित सबर्रे पर दोहराया जाता है:

4 3

यह तब तक किए जाने की आवश्यकता है जब तक कि शेष प्रविष्टियों का सबरेरे खाली न हो जाए। पुनरावृत्तियों की आवश्यक संख्या पर एक ऊपरी बाध्य इनपुट आकार है। अंतिम पुनरावृत्तियों की आवश्यकता नहीं हो सकती है। उस मामले में वे एक खाली सरणी पर काम करते हैं, अतिरिक्त खाली सरणियों का उत्पादन करते हैं।

अंत में, स्टैक में आवश्यक सरणियाँ और संभवतः कई खाली सरणियाँ शामिल हैं, जो बिल्कुल प्रदर्शित नहीं होती हैं।

t        % Implicit input. Duplicate
"        % Do as many times as the input size
  tt     %   Duplicate twice
  Y>     %   Cumulative maximum
  =      %   Compare for equality. Will be used as logical index
  &)     %   Two-output indexing: pushes indexed subarray, and then
         %   a subarray with the remaining entries
         % End (implicit)
         % Display stack (implicit). Empty arrays are not displayed

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

23

हास्केल, 67 59 58 बाइट्स

(q:r)!x|x<last q=q:r!x|1<2=(q++[x]):r
_!x=[[x]]
foldl(!)[]

स्पष्टीकरण: सूचियों की एक सूची (जो पहले से ही क्रमबद्ध हैं) और एक मूल्य को देखते हुए x, !ऑपरेटर xपहली सूची के अंत में रखेगा , जिसका अंतिम तत्व उससे कम या उसके बराबर है x। यदि ऐसी कोई सूची मौजूद नहीं है, तो सूची [x]को अंत में रखा गया है।

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

— क्रिस्टियन लुपस्कू
स्रोत

3

यह एक अविश्वसनीय रूप से चतुर समाधान है। मैं ईमानदारी से ज्यादातर लोगों को उम्मीद करता हूं कि जब तक कुछ भी नहीं बचा है, तब तक बस ड्रॉप्सॉर्ट पर, लेकिन मुझे उम्मीद थी कि कोई और अधिक रचनात्मक तरीके से सोचेगा।

— लॉर्ड फरक्वाड

13

भूसी , 10 बाइट्स

hUmü<¡Ṡ-ü<

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

यह मेरे अन्य हस्क उत्तर और एक्सनॉर के हास्केल उत्तर का एक संयोजन है । डुप्लिकेट ü<को भद्दा लगता है, लेकिन मुझे नहीं पता कि इससे कैसे छुटकारा पाया जाए ...

व्याख्या

फ़ंक्शन हास्केल में ü<अनुवाद करता nubBy(>)है। यह उन तत्वों को रखते हुए बाएं से दाएं एक सूची का पता लगाता है, जिनके लिए पहले से कोई रखा गया तत्व कड़ाई से अधिक नहीं है। दूसरे शब्दों में, यह ड्रापोर्ट करता है। बचे हुए तत्वों को मूल सूची के अंतर और परिणाम के आधार पर प्राप्त किया जाता है ü<।

hUmü<¡Ṡ-ü<  Implicit input, say x = [2,3,5,4,4,2,7].
     ¡      Iterate
      Ṡ-    list difference between argument
        ü<  and its dropsort: [[2,3,5,4,4,2,7],[4,4,2],[2],[],[],[],...
  m         Map
   ü<       dropsort: [[2,3,5,7],[4,4],[2],[],[],[],...
 U          Prefix of unique elements: [[2,3,5,7],[4,4],[2],[]]
h           Drop last element: [[2,3,5,7],[4,4],[2]]

— Zgarb
स्रोत

10

33% "मैं दूनो , यह क्लिक्की महसूस करता है" द्वारा टॉपगॉल्स का जवाब

— लॉर्ड फरक्वाड

11

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

import Data.List
f[]=[]
f l|r<-nubBy(>)l=r:f(l\\r)

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

— XNOR
स्रोत

1

मैं लगभग यह था, बस \\ समारोह में पता नहीं था : (

— H.PWiz

2

ओह, यह वास्तव में एक बहुत ही आसान कार्य है! बहुत अच्छा समाधान =)

— त्रुटिपूर्ण

7

भूसी , 16 बाइट्स

hUm₁≤¡₁>
ṠfSz⁰G▲

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

व्याख्या

यह पहली पंक्ति मुख्य कार्य है, और दूसरा एक उच्च क्रम सहायक कार्य है (यह एक फ़ंक्शन को तर्क के रूप में लेता है और एक नया फ़ंक्शन देता है)। इसे सबस्क्रिप्ट द्वारा एक्सेस किया जाता है ₁। विचार यह है कि ₁≤ड्रापोर्ट करता है और ₁>बचे हुए तत्वों को देता है।

ṠfSz⁰G▲  Helper function, takes binary function p (as ⁰) and list x (implicit).
         For example, p = (≤) and x = [2,4,3,4,5,2].
     G▲  Left scan on x with maximum: [2,4,4,4,5,5].
  Sz     Zip with x
    ⁰    using the function p: [1,1,0,1,1,0].
Ṡf       Keep elements of x at truthy indices: [2,4,4,5].

मुख्य फ़ंक्शन में, हम बचे हुए फ़ंक्शन को पुनरावृत्त करते हैं ₁>और ₁≤परिणामों के लिए ड्रॉपशॉट फ़ंक्शन को लागू करते हैं ।

hUm₁≤¡₁>  Main function, implicit list argument, say x = [2,4,3,4,5,2].
     ¡    Iterate
      ₁>  the leftovers function: [[2,4,3,4,5,2],[3,2],[2],[],[],[],...
  m       Map
   ₁≤     the dropsort function: [[2,4,4,5],[3],[2],[],[],[],...
 U        Prefix of unique elements: [[2,4,4,5],[3],[2],[]]
h         Drop last element (an empty list): [[2,4,4,5],[3],[2]]

— Zgarb
स्रोत

हस्क नई जेली है ...

— एरिक आउटगोल्फर

1

MATL द्वारा @EriktheOutgolfer को हराया गया। : /

— जरगब

6

पायथन 3 , 131 112 103 95 बाइट्स

बहुत बहुत शुक्रिया @Mr एक मुंहतोड़ 19 बाइट्स के लिए Xcoder !!

एक अद्भुत 17 बाइट्स के लिए बहुत बहुत धन्यवाद @ovs!

def f(x):
 a,*x=x or[0];m=[a];d=[]
 for i in x:[m,d][i<m[-1]]+=i,
 return[m]+(x and(d>[])*f(d))

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

स्पष्टीकरण:

def f(x):               #recursive function taking list, returns list of lists 
 if len(x)<2:return[x]  #for a single element return [element] 
 m=[x[0]];d=[]          #initialize main and dropped lists
 for i in x[1:]:[m,d][i<m[-1]]+=[i]  #append elements from the argument list accordingly into main and dropped list 
 return[m]+(d>[])*list(f(d)) #add main-list along with further evaluated dropped-list(recursived) into a list of lists

— officialaimm
स्रोत

2

116 बाइट्स। if-elseमें ढह किया जा सकता है [m,d][i<m[-1]]+=[i]।

— श्री Xcoder

वाह, बहुत बहुत धन्यवाद ... मैं उस [m,d]चीज़ की कोशिश कर रहा था, लेकिन यह किसी भी तरह से काम नहीं कर रहा था ....

— आधिकारिक

1

113 बाइट्स । (len(d)>0)है bool(d), क्योंकि खाली सूची पायथन में झूठी हैं। +1, अच्छा समाधान!

— श्री एक्सकोडर

1

95 बाइट्स

— अंडा

2

i,के लिए सिर्फ एक छोटा है (i,), जो एक tuple युक्त है a। a,*x = x or [0]है python3 के विस्तारित unpacking । यहाँ कुछ उदाहरणों के साथ इस विषय पर एक सहायक SO पोस्ट है।

— अंडा

6

हास्केल , 113 107 102 92 बाइट्स

import Data.List
a!(b:c)|b<last a=a!c|1>0=a++[b]!c
a!b=a
g x@(b:c)|i<-[b]!c=i:g(x\\i)
g x=[]

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

यह वास्तव में लंबा लगता है ।

व्याख्या

!एक सूची पर ड्रॉप सॉर्ट करता है, जबकि #छंटनी एकत्र करता है। gतब #तक बार-बार लागू होता है जब तक कि सूची खाली न हो किसी सूची में परिणाम दर्ज नहीं किया जाता है।

— गेहूं का जादूगर
स्रोत

1

जगह head aके साथ a!!0एक बाइट बचाता है।

— 21

5

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

{⍵≡⍬:⍬⋄(⊂X/⍵),∇⍵/⍨~X←⍵≥⌈\⍵}

स्पष्टीकरण:

⍵≡⍬:⍬: यदि इनपुट खाली है, तो खाली सूची लौटाएं
X←⍵≥⌈\⍵: सभी संख्याएँ अधिक से अधिक या बराबर चल रही हैं
(⊂X/⍵): उन नंबरों की सूची,
∇⍵/⍨~X: शेष संख्याओं पर इस फ़ंक्शन को चलाने के परिणाम के बाद

— मारीनस
स्रोत

एक बाइट के साथ सहेजें {⍵≡⍬:⍬⋄(⊂⍵~r),∇r←⍵/⍨⍵<⌈\⍵}। अपने ईमेल के जवाब की कमी से मोर्टेन चिंतित हो रहे हैं। सलामती तो है?

— एडम

बाप रे। मुझे यहां खुशी है कि आप कामयाब रहे। आपसे अगले हफ्ते मिलते हैं।

— आदम

4

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

f=(a,l,r=[])=>a+a&&[a.filter(e=>e<l?!r.push(e):(l=e,1)),...f(r)]

Ungolfed:

f=(a,l,r=[])=>
  a+a&&                                    //any elements left?
  [a.filter(                               //filter elements that are in order,
    e=>e<l?!r.push(e):(l=e,1)              //push unsorted elements to r
   ),                                      //push() returns the new length of the array,
                                           //... so !push() will always return false
   ...f(r)                                 //recurse on r
  ]

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

f=(a,l,r=[])=>a+a&&[a.filter(e=>e<l?!r.push(e):(l=e,1)),...f(r)]

console.log(JSON.stringify(f([1, 2, 5, 4, 3, 7])));     // [1, 2, 5, 7][4][3]
console.log(JSON.stringify(f([10, -1, 12])));           // [10, 12][-1]
console.log(JSON.stringify(f([-7, -8, -5, 0, -1, 1]))); // [-7, -5, 0, 1][-8, -1]
console.log(JSON.stringify(f([9, 8, 7, 6, 5])));        // [9][8][7][6][5]
console.log(JSON.stringify(f([10, 13, 17, 21])));       // [10, 13, 17, 21]
console.log(JSON.stringify(f([10, 10, 10, 9, 10])));    // [10, 10, 10, 10][9]
console.log(JSON.stringify(f([5, 4, 3, 8, 7, 6])));     // [5, 8][4, 7][3, 6]
console.log(JSON.stringify(f([0, 2, 5, 4, 0, 7])));     // [0,2,5,7],[4],[0]

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

— रिक हिचकॉक
स्रोत

1

एक दूसरे विभाजन के लिए मैंने सोचा ?!कि कुछ फैंसी नए ऑपरेटर थे ...

— नील

हा, हाँ, मुझे एक स्पष्टीकरण शामिल करना चाहिए था। अब जोड़ा गया।

— रिक हिचकॉक

@ नील?!

— पैट्रिक रॉबर्ट्स

(i,n,o=[])=>[i.filter(a=>(n||a)<=a?(n=a,1):!o.push([a])),...o]जाहिर है, महान दिमाग (एक तरह का) एक जैसा सोचते हैं। दुर्भाग्य से मैं किसी भी अधिक बाइट्स शेव करने के लिए प्रतीत नहीं कर सकता ... बस ध्यान दे रहा है, आप f=अपने कोड में निकाल सकते हैं , और हो सकता है कि मेरा कोड आपको कुछ विचार दे सकता है कि आपको और भी कैसे गोल्फ के लिए।

— डेविड आर्किबाल्ड

धन्यवाद, @DavidArchibald मैं f=अपने कोड से नहीं हटा सकता , क्योंकि यह पुनरावर्ती है। तुम्हारा एक दिलचस्प दृष्टिकोण है, लेकिन यह परीक्षण मामलों के एक जोड़े के लिए काम नहीं करता है। उदाहरण के लिए, यह [[5,8],[4],[3],[7],[6]] अगले-से-अंतिम मामले के लिए वापस आ जाता है।

— रिक हिचकॉक

4

आर , 61 बाइट्स

f=function(x)if(sum(x|1)){print(x[b<-x==cummax(x)]);f(x[!b])}

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

पुनरावर्ती कार्य। sum(x|1)के लिए आशुलिपि है length(x), इसलिए यह पुनरावृत्ति जब तक चलेगी xखाली है। cummaxअधिकतम संचयी लेता है x, जो फिर से तुलना की जाती है x। यह लंबाई के बूलियन वेक्टर का उत्पादन करता है x, जहां सभी TRUE क्रमबद्ध मानों के अनुरूप होते हैं। हम इसका उपयोग करते हैं xऔर printइसका सबसेट लेने के लिए । फ़ंक्शन को फिर शेष पर बुलाया जाता है x।

— JAD
स्रोत

4

जावा 8, 182 179 177 बाइट्स

import java.util.*;l->{List r=new Stack(),t;for(int p,i,x;l.size()>0;)for(p=l.get(0),r.add(t=new Stack()),i=0;i<l.size();p=x)if((x=l.get(i++))>=p)t.add(l.remove(--i));return r;}

-3 बाइट्स @ नवे के लिए धन्यवाद ।
के Stackबजाय का उपयोग करके -2 बाइट्स Vector।

स्पष्टीकरण:

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

import java.util.*;            // Required import for List and Vector
l->{                           // Method with ArrayList<Integer> parameter and List return-type
  List r=new Stack(),          //  Return-List
       t;                      //  Temp-List
  for(int p,i,x;               //  Some temp integers
      l.size()>0;)             //  Loop (1) as long as there are still items left in the list
    for(p=l.get(0),            //   Set `p` to the first item of the list
        r.add(t=new Stack()),  //   Add a new inner List to the result-List
        i=0;i<l.size();        //   Inner loop (2) from 0 to the size of the list (exclusive)
         p=x)                  //     After every iteration, save the previous value in `p`
      if((x=l.get(i++))>=p)    //    If the current item is equal or larger than the previous:
        t.add(l.remove(--i));  //     Add it to the temp-List, and remove it from the input-List
                               //   End of inner loop (2) (implicit / single-line body)
                               //  End of loop (1) (implicit / single-line body)
  return r;                    //  Return result-List
}                              // End of method

— केविन क्रूज़सेन
स्रोत

क्या आप कुछ को बचाने के लिए try{}catch{}जाँच के बजाय उपयोग कर सकते हैं l.size()?

— TheLethalCoder

1

आप आंतरिक लूप को शुरू कर सकते हैं 0और बाहरी फॉर-लूप

l->{List r=new Vector(),t;for(int p,i,x;l.size()>0;)for(p=l.get(0),r.add(t=new Vector()),i=0;i<l.size();p=x)if((x=l.get(i++))>=p)t.add(l.remove(--i));return r;}

(-3 बाइट्स) के ब्रैकेट को हटा सकते हैं ।

— नेवय

3

सी #, 188 203 बाइट्स

int[][]f(int[]a){int[]t=a.Where((n,i)=>i<1||n>=a[i-1]).ToArray(),m=a.Where((n,i)=>i>0&&n<a[i-1]).ToArray();var s=new int[][]{t}.ToList();if(m.Any())s.AddRange(f(m));return s.ToArray();}

बाइट गिनती में +18 शामिल हैं:

using System.Linq;

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

— TheLethalCoder
स्रोत

15 बाइट्स की कीमत पर @RickHitchcock फिक्स्ड! अच्छी जगह है।

— TheLethalCoder

अच्छी नौकरी

— रिक हिचकॉक

3

सी ++ 14, 118 108 बाइट्स

W0lf के हास्केल उत्तर से एल्गोरिथ्म का उपयोग करना ।

अनाम जेनेरिक लैम्ब्डा के रूप में। पहला पैरामीटर ड्रापोर्ट (जैसे vector<int>) के मानों का एक कंटेनर है और दूसरे पैरामीटर को vector<vector<int>>संदर्भ के लिए वापसी मूल्य के लिए कंटेनर (जैसे ) के एक संगत खाली कंटेनर की आवश्यकता होती है ।

कार्यक्रम के पहले संस्करण में, R.clear;()पहले बयान के रूप में था , ताकि कंटेनर के कंटेनर को खाली होने की आवश्यकता न हो। पीटर कॉर्डेस ने सोचा कि यह विनिर्देश में हो सकता है, इसलिए उसके लिए 10 बाइट छोड़ना होगा।

[](auto A,auto&R){for(auto x:A){for(auto&D:R)if(D.back()<x){D.push_back(x);goto F;}R.emplace_back(1,x);F:;}}

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

Ungolfed:

[](auto A,auto&R){
 for(auto x:A){       //foreach item
  for(auto&D:R)       //foreach result list
   if(D.back()<x){    //x bigger than last element
    D.push_back(x);   //add x
    goto F;           //break and jump over the emplace
   }
  R.emplace_back(1,x);//create new list with this element
  F:;
 }
}

— कार्ल नेफ
स्रोत

आप शायद छोड़ने के साथ दूर हो सकते हैं R.clear(), और बस एक खाली कंटेनर के साथ शुरू करने के लिए कॉलर की आवश्यकता होती है।

— पीटर कॉर्ड्स

@PeterCordes अच्छा विचार है, मैं अपने अन्य C ++ उत्तरों का सम्मान कर सकता हूं, जो संदर्भ पैरामीटर के माध्यम से वापस आए।

— कार्ल नेफ्फ

2

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

-4 बाइट्स अर्नोल्ड पामर को धन्यवाद

b,r=input(),[]
for i in b:
 for l in r:
	if l[-1]<=i:l+=[i];break
 else:r+=[[i]]
print r

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

@ W0lf's haskell [उत्तर] [1] के समान समाधान

for-elseनिर्माण के लिए दुर्लभ उपयोग का मामला

सॉर्ट की गई सूचियों for l in r(आरंभ में खाली) के माध्यम से Iterate करें ।
यदि तत्व (इनपुट से) iसूची के अंतिम तत्व से बड़ा है, तो सूची l[-1]में तत्व जोड़ें l+=[i], ब्रेक करें।
यदि कोई सूची स्वीकार नहीं की गई थी, तो इस सूची के साथ नई सूची जोड़ेंr+=[[i]]

— मृत पोसुम
स्रोत

1

88 बाइट्स केवल इसे अपने फंक्शन से निकालकर।

— अर्नोल्ड पामर

1

आर, कार्य प्रगति पर (89, लेकिन असफल)

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

z=function(x){if(length(x)){a=x[x>=cummax(x)]
append(list(a),z(x[!(x%in%a)]))}else{NULL}}

Ungolfed:

z=function(x){
  if(length(x)){
    a=x[x>=cummax(x)]
    append(list(a),z(x[!(x%in%a)]))
  } else {
    NULL
  }
}

— एलेक्स एक्स्टेलम
स्रोत

जब आप इसे ठीक कर रहे हों, तो शायद आपको इसे समय के लिए हटा देना चाहिए ताकि आपको डाउनवोट न मिले।

— Giuseppe

1

z=function(x)"if"(sum(x|1),{a=x[(i=x>=cummax(x))] c(list(a),z(x[!i]))},NULL)काम करता है

— Giuseppe

के बीच का स्थान ]और cएक नई रेखा (या अर्धविराम) है

— Giuseppe

मैंने पहले कभी नहीं देखा है "if", लेकिन मैं आर गोल्फिंग के लिए बहुत नया हूं। आपको अपने स्वयं के उत्तर के रूप में पोस्ट करना चाहिए, और मैं अपना नीचे ले जा सकता हूं। मुझे लगता है कि आपने iसूचकांक के साथ क्या किया , %in%समस्या के चारों ओर पाने के लिए ।

— एलेक्स एक्थेल्म

नहीं, आपने पूरी मेहनत की है! मैं इस समस्या के इर्द-गिर्द अपना सिर नहीं लपेट सकता था जब तक कि मैंने आपका कार्यान्वयन नहीं देखा - मैंने कभी याद नहीं किया होगा cummax!

— Giuseppe

1

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

a=>a.map(n=>(o.find(b=>[...b].pop()<=n)||(n=[n],o)).push(n),o=[])&&o

बहुत सरल, बस सरणी को पुनरावृत्त करता है, पहले आंतरिक सरणी की तलाश करता है जिसका अंतिम मान <=ड्रॉप करने के लिए अगले मान पर है, यदि कोई भी मौजूद नहीं है, तो आउटपुट के अगले मूल्य के साथ एक नया आंतरिक सरणी जोड़ें, अन्यथा अगले मूल्य को पहले मान में जोड़ें। आंतरिक सरणी पाया गया जो कि स्थिति से मेल खाता है।

अपडेट

नील के लिए धन्यवाद, तीन बाइट्स को परिवर्तित (...,o)करने ...&&oऔर कॉलबैक को फिर से व्यवस्थित करने के लिए और map()अधिक कॉम्पैक्ट होने से बचाया ।

f=a=>a.map(n=>(o.find(b=>[...b].pop()<=n)||(n=[n],o)).push(n),o=[])&&o;[[1,2,5,4,3,7],[10,-1,12],[-7,-8,-5,0,-1,1],[9,8,7,6,5],[10,13,17,21],[10,10,10,9,10],[5,4,3,8,7,6],[0,2,5,4,0,7]].map(f).map(JSON.stringify).map(v=>console.log(v))

.as-console-wrapper{max-height:100%!important}

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

— पैट्रिक रॉबर्ट्स
स्रोत

1

&&oसे एक बाइट कम है (,o)।

— नील

@ नील गाह! ग्रेट कैच, धन्यवाद

— पैट्रिक रॉबर्ट्स

1

मुझे आपकी पसंद है [...b].pop(), लेकिन मुझे लगता (o.find(b=>[...b].pop()<=n)||(n=[n],o)).push(n)है कि आप एक बाइट या दो बचाता है।

— नील

इस दर पर, मैं इसे सामुदायिक पोस्ट के रूप में चिह्नित करने के लिए बाध्य महसूस करूंगा ... लानत है

— पैट्रिक रॉबर्ट्स

सिर्फ दोहों के कारण? यह अभी भी मूल रूप से एक ही कोड है ...

— नील

1

जाप , 29 बाइट्स

@lOpP)<1}a@=f_<VªOoV=Z+S}V=Ug

इसे ऑनलाइन टेस्ट करें!

— ETHproductions
स्रोत

1

सी (जीसीसी) , 176 175 173 बाइट्स

#define P(x)printf("%d ",t=x);
l[2][99];t;x;i;j;w;main(a){while(scanf("%d",*l+w)>0)++w;while(i=w){P(l[a=!a][w=0])for(j=1;j<i;++j){x=l[a][j];x<t?l[!a][w++]=x:P(x)}puts("");}}

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

कुछ पठनीय संस्करण:

#define P(x)printf("%d ",t=x);
l[2][99];t;x;i;j;w;
main(a)
{
    while(scanf("%d",*l+w)>0)++w;
    while(i=w)
    {
        P(l[a=!a][w=0])
        for(j=1;j<i;++j)
        {
            x=l[a][j];
            x<t?l[!a][w++]=x:P(x)
        }
        puts("");
    }
}

— फेलिक्स पालमेन
स्रोत

175 बाइट्स ।

— श्री एक्सकोडर

उह, बेशक, कितना बेवकूफ - धन्यवाद!

— फेलिक्स पैलमेन

1

PHP, 91 103 96 85 बाइट्स

( print_r($r);आउटपुट के लिए आवश्यकता को पूरा करने के लिए 12 वर्णों को जोड़ने का संपादन किया गया )
(PHP त्रुटियों की अनुमति देते समय 7 बाइट्स
को निकालने के लिए संपादित ) (कार्य को आगे बढ़ने पर 11 बाइट्स निकालने के लिए संपादित)

while($a){$b=$d=[];foreach($a as$i)${max($b)>$i?d:b}[]=$i;$a=$d;$r[]=$b;}print_r($r);

इनपुट को देखते हुए $a, यह परिणाम पैदा करता है$r

सुंदर हे:

while ($a) {
    $b = $d = [];
    foreach ($a as $i) {
        ${max($b) > $i ? d : b}[] = $i;
    }
    $a   = $d;
    $r[] = $b;
}

छद्म-पुनरावर्ती बाहरी लूप रखने $bऔर $dसरणियों को खाली करने से रोकता है, फिर एक बुनियादी ड्रॉप सॉर्ट लूप करता है, अंत में नए इनपुट के रूप में डिस्क को सेट करता है और परिणाम में रखता है।$r

— छाता
स्रोत

1

PHP , 102 बाइट्स , 98 बाइट्स

<?php function s($i){static$s;foreach($i as$v)${$v<max($l)?f:l}[]=$v;$s[]=$l;!$f?:s($f);return$s;}

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

-4 बाइट्स, @Umbrella के लिए धन्यवाद

व्याख्या

<?php

फ़ंक्शन इनपुट सूची को एक सरणी के रूप में लेता है।

function s($i) {

$s, जो सूची की अंतिम रूप से लौटी सूची बन जाएगी, को स्थिर घोषित किया जाता है। यह इस फ़ंक्शन के सभी कॉल के लिए अपना दायरा बढ़ाता है , जिससे फ़ंक्शन को इस परिणाम सूची को एक तर्क के रूप में पारित करने या इसे वापस करने के बिना पुनरावर्ती रूप से कॉल करने की अनुमति मिलती है।

    static $s;

सूची में प्रत्येक मूल्य के माध्यम से लूप।

    foreach ($i as $v)

क्या यह सबसे बड़ी वर्तमान सूची सदस्य से कम है?

        $v < max($l) ?

हां, इसे $fआगे छँटाई के लिए सूची में रखें ।

                        $f[] = $v :

नहीं, इसे सूची में रखें $l।

                        $l[] = $v;

सूची की सूची $lपर पुश सूची ।

    $s[] = $l;

यदि सूची में कुछ भी है $f, तो इसे आगे छँटाई के लिए फिर से भेजें।

    !$f ?: s($f);

सूचियों की सूची वापस करें।

    return $s;
}

— WebSmithery
स्रोत

1

मेरे द्वारा छोड़े गए 31 चरों का लेखा-जोखा <?php function d($a){return$r;}, आपने मुझे दिल से कुचल दिया। इसके अलावा, मुझे बस एहसास हुआ कि हम दोनों आउटपुट करना भूल गए हैं।

— छाता

मैं अपने समाधान गोल्फ किया गया है नीचे तुम्हारा का उपयोग किए बिना हरा तुम्हारा करने की कोशिश करने के लिए और मैंने पाया एक तरह से तुम्हारा सुधार किया जा सकता: मुझे लगता है कि आप की जगह चार अक्षर बचा सकता है $v<max($l)?$f[]=$v:$l[]=$v;के साथ ${$v<max($l)?f:l}[]=$v;- कम से कम, यह मेरी परीक्षणों में काम करता है।

— अम्ब्रेला

@Umbrella, वापस नहीं आ रहा है, outputting ??? और उन 4 बाइट्स के लिए धन्यवाद। मैं चर नाम का मूल्यांकन करने के लिए कोड का उपयोग करके उस तरह से काम करने के बारे में कभी नहीं सोचता। मुझे भविष्य में आने वाली चुनौतियों पर विचार करना याद रखना चाहिए ...।

— WebSmithery

यह मिला, सर्वसम्मति से उत्पादन के रूप में लौटने को स्वीकार करने लगता है: codegolf.meta.stackexchange.com/questions/2447/…

— छाता

0

ऋषि, 102 बाइट्स

def f(w,a=[]):
 for x in w:
  q,c=exists(a,lambda b:b[-1]<=x)
  if q:c+=[x]
  else:a+=[[x]]
 return a

@ डेड पॉसम के जवाब के समान । प्रथम सूची के
प्रत्येक सदस्य xको {अंतिम सूची में} से अधिक अंतिम तत्व के साथ जोड़ देता है। यदि कोई नहीं, के लिए अपील करता है । wax
[x]a

मैं वास्तव में यह पसंद है, तो होगा existsलौटे a, तो कुछ भी नहीं मिला था! इसके अलावा @ आधिकारिक के एक-लाइन विचार को लागू करने की कोशिश कर रहा है ...

प्रश्न: यदि मैंने फ़ंक्शन से अपना कोड हटा दिया है, तो मुझे wसही इनपुट करना होगा? तो क्या यह बाइट्स को बचाएगा?

— संभावित हो
स्रोत

0

Ocaml , 69 62 बाइट्स

let rec d=function h::i::t when h>i->d(h::t)|h::t->h::d t|x->x

स्पष्टीकरण:

let rec d = function (* Implicitly take an list as a parameter *)
    (* If the list starts with two elements h and i and h is greater than i, drop i and sort the list starting with h and the rest t *)
    | h::i::t when h > i -> d (h::t) 
    (* If h is not greater than i, make a new list starting with h and a tail containing the drop sorted rest *)
    | h::t -> h::d t
    (* If none of the cases apply, the list is empty. *)
    | x -> x

— पल्ले
स्रोत

0

एपीएल, 100 88 83 79 78 57 56 77 76 बाइट्स

{(E/⍵),⊂⍵/⍨~E←(⍬≢⍴)¨⍵}∘{⍵≡(S←¯1↓⍵),⊃⊃⌽⍵:⍵⋄∇S,⊃⌽⍵}{⍵≡X←⍵/⍨~V←⍵≠⌈\⍵:⍵⋄X(∇V/⍵)}

-०-बाइट्स कृतिका लिथोस को धन्यवाद ...

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

वहाँ ऐसा करने के लिए कुछ बेहतर तरीका हो गया है ( वहाँ है )। किसी भी सुझाव बहुत सराहना और स्वागत है।

कैसे?

(ध्यान दें, इस स्पष्टीकरण में से कुछ गलत हो सकता है, क्योंकि मैं भूल गया कि यह कैसे काम करता है)

{⍵≡X←⍵/⍨~V←⍵≠⌈\⍵:⍵⋄X(∇V/⍵)} - separate the argument into nested drop-sorts
{⍵≡(S←¯1↓⍵),⊃⊃⌽⍵:⍵⋄∇S,⊃⌽⍵}  - un-nesting (passed the result of the above)
{(E/⍵),⊂⍵/⍨~E←(⍬≢⍴)¨⍵}∘     - fixing array mishaps (passed the result of the above)

— जाकारी
स्रोत

{⍬≢⍴⍵}बन सकते हैं(⍬≢⍴)

— क्रिस्ति लिथोस

आपकी टिप्पणी को देखे बिना, पहले से ही ऐसा किया है

— Zacharý

का उद्देश्य क्या है {(⍵/⍨~E),⊂⍵/⍨E←(⍬≡⍴)¨⍵}? यह सब कुछ से अलग हो गया लगता है

— क्रिटिक्स लिथोस

इसके बिना, पहला परीक्षण मामला [[1,2,5,7],[4],3]आवश्यक के बजाय कुछ ऐसा होगा [[1,2,5,7],[4],[3]]।

— ज़ाचारि

आप उस dfn को छोटा करने में सक्षम हो सकते हैं(,¨)

— Kritii Lithos

0

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

<»\¬x@ðW;µ⁸Ñ
<»\x@µÑ
1Ŀ¹L?

यह मारिनस के APL उत्तर के समान विधि है।

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

— जाकारी
स्रोत

0

जावास्क्रिप्ट (Node.js) , 125 109 106 बाइट्स

- 16 18 Zacharý से बाइट्स

-1 को हटाने {और }वेतन वृद्धि को बदलकर "वर्तमान में अंतिम सेट" को शामिल करने के लिए

m=x=>{z=[[],[]];l=NaN;for(i=0;i<x.length;l=x[i++])if(l>x[i])z[1].push(x[i]);else z[0].push(x[i]);return z}

मूल रूप से, पूछता है कि वर्तमान आइटम अंतिम आइटम से अधिक है, पहली सूची में जोड़ें। अन्यथा, दूसरे में जोड़ें।

इस दौरान पता चला कि किसी भी संख्या की तुलना NaNहमेशा होगी false। दिलचस्प!

स्पष्टीकरण:

m = x => {                         // Create function
  z = [[], []];                      // Initialize dropsort output
  l = NaN;                           // Initialize last element
  for (i = 0; i < x.length; l=x[i++])// For each item in input...
    if (l > x[i])                    // If current item is greater than previous
      z[1].push(x[i]);               // Then add it to the first part of output
    else                             // Elsewise
      z[0].push(x[i]);               // Add it to the nonordered part of the dropsort
                                     // Set last item to current item
  }                                  // Repeat
  return z                           // Return finished dropsort
}                                    // End function

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

— स्टेन स्ट्रम
स्रोत

क्या आपको उपयोग करना है var?

— ज़ाचारि

@ Zacharý, मुझे जांचने दो!

— स्टेन स्ट्रम

Parens के आसपास की जरूरत नहीं है x।

— Zacharý

इसे ड्रॉप करें जैसे कि यह गर्म है

MATL , 15 10 9 बाइट्स

व्याख्या

हास्केल, 67 59 58 बाइट्स

भूसी , 10 बाइट्स

व्याख्या

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

भूसी , 16 बाइट्स

व्याख्या

पायथन 3 , 131 112 103 95 बाइट्स

एक अद्भुत 17 बाइट्स के लिए बहुत बहुत धन्यवाद @ovs!

स्पष्टीकरण:

हास्केल , 113 107 102 92 बाइट्स

व्याख्या

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

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

आर , 61 बाइट्स

जावा 8, 182 179 177 बाइट्स

सी #, 188 203 बाइट्स

सी ++ 14, 118 108 बाइट्स

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

आर, कार्य प्रगति पर (89, लेकिन असफल)

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

अपडेट

जाप , 29 बाइट्स

सी (जीसीसी) , 176 175 173 बाइट्स

PHP, 91 103 96 85 बाइट्स

PHP , 102 बाइट्स , 98 बाइट्स

ऋषि, 102 बाइट्स

Ocaml , 69 62 बाइट्स

एपीएल, 100 88 83 79 78 57 56 77 76 बाइट्स

कैसे?

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

जावास्क्रिप्ट (Node.js) , 125 109 106 बाइट्स