Bu soruda açıklandığı gibi :

David Morgan-Mar tarafından tasarlanan Dropsort, aslında, sıralanan, ancak orijinal öğelerin yalnızca bazılarını içeren bir liste üreten doğrusal zamanlı bir "sıralama algoritması" örneğidir. En azından ondan önceki öğelerin maksimum büyüklüğü kadar büyük olmayan herhangi bir öğe listeden çıkarılır ve atılır.

Test durumlarından birini kullanmak için, önceki ve "sıralanan" değerden daha küçük olmaları için olduğu gibi ve her ikisi de düşürülmüş bir {1, 2, 5, 4, 3, 7}verim girişidir .{1, 2, 5, 7}435

"Sıralama" algoritmalarını istemiyoruz, onların gerçek anlaşma olmasını istiyoruz. Bu nedenle, bir sayı listesi verilen, DropSorted listelerinin bir listesini çıkaran bir program yazmanızı istiyorum (tam bir sıralama algoritması olmak için, bu listeleri birleştirmemiz gerekir, ancak iki sıralı listenin birleştirilmesi daha önce yapıldı ve sizden tekrar yapmanı istemek hemen hemen iki soru sormaktır, bu yüzden bu soru özellikle tüm DropSort'umuzun "bölme" adımıdır).

Bununla birlikte, listelerimizin düzeni ve içeriği çok önemlidir. Programınızın çıktısı, bir DropSort çıktısına eşdeğer olmalı, ardından atılan değerlerin bir DropSort'unu takip etmelidir, vb. Yine, mevcut test takımını ödünç almak (ve iki tane daha eklemek):

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}}

Girişin boş olmadığını kabul edebilirsiniz.

Bu kod golf , bu yüzden standart kurallar geçerli!

Matl , 15 10 9 bayt

@Beaker'ın birikimli maksimum fikrini kullanarak 5 bayt

t"ttY>=&)

Giriş, biçimindeki sayısal bir satır vektörüdür [1, 2, 5, 4, 3, 7](virgül isteğe bağlıdır). Çıktı, her satırdaki sayılar boşluklarla ayrılmış, yeni satırlarla ayrılmış listeler içerir.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

Bir dizi göz önüne alındığında, kod, o girişten kümülatif maksimuma eşit olan her girişten onu seçer.

Örneğin, verilen

1 2 5 4 3 7

kod birinci, ikinci, üçüncü ve altıncı girişleri seçer:

1 2 5     7

Ardından, kalan girişlerin oluşturduğu alt dizide işlem tekrarlanır (orijinal sırayla):

      4 3

Bu, kalan girişlerin alt dizisi boşalana kadar yapılmalıdır. Gerekli yineleme sayısına bağlı olan bir üst sınır, giriş boyutudur. Son tekrarlamalar gerekli olmayabilir. Bu durumda boş bir dizide çalışırlar ve ek boş diziler oluştururlar.

Sonunda, yığın gerekli dizileri ve muhtemelen hiç görüntülenmeyen birkaç boş diziyi içerir.

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

Haskell, 67 59 58 bayt

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

Açıklama: Listelenen bir liste (zaten sıralanan) ve bir değer xverildiğinde, !operatör xson elemanı eşit veya daha küçük olan ilk listenin sonuna yerleştirecektir x. Eğer böyle bir liste yoksa, liste [x]sonuna yerleştirilir.

Çevrimiçi deneyin.

Kabuğu , 10 bayt

hUmü<¡Ṡ-ü<

Çevrimiçi deneyin!

Bu, diğer Husk cevabım ve Xnor'ın Haskell cevabının bir birleşimidir . Kopya ü<kopar geliyor, ama ondan nasıl kurtulacağımı bilmiyorum.

açıklama

İşlev Haskell ü<dilinde çevrilir nubBy(>). Bir listeyi soldan sağa doğru geçirir, önceden tutulan hiçbir öğenin kesinlikle daha büyük olmadığı öğeleri tutar. Başka bir deyişle, droport gerçekleştirir. Artık öğeler, orijinal listenin liste farkı ve sonucu alınarak elde edilir ü<.

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]]

Haskell , 50 bayt

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

Çevrimiçi deneyin!

Kabuğu , 16 bayt

hUm₁≤¡₁>
ṠfSz⁰G▲

Çevrimiçi deneyin!

açıklama

Bu ilk satır ana fonksiyon ve ikincisi daha yüksek dereceli bir yardımcı fonksiyondur (argüman olarak bir fonksiyon alır ve yeni bir fonksiyon döndürür). Abonelikten erişilir ₁. Buradaki düşünce, ₁≤droport gerçekleştiren ve ₁>kalan elementleri verendir .

Ṡ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].

Ana işlevde, artıkları işlevini ₁>yineler ₁≤ve sonuçlara droport işlevini uygularız .

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]]

Python 3 , 131 112 103 95 bayt

Çok teşekkürler @ Mr. Smashing 19 bayt için Xcoder!

Harika bir 17 bayt için @ovs @ çok teşekkürler!

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))

Çevrimiçi deneyin!

Açıklama:

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

Haskell , 113 107 102 92 bayt

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=[]

Çevrimiçi deneyin!

Bu gerçekten çok uzun sürüyor.

açıklama

!#süslemeler toplanırken listedeki bırakma sırasını gerçekleştirir . gdaha sonra #liste bir liste halinde sonuçları boş bırakana kadar art arda uygulanır .

APL, 27 bayt

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

Açıklama:

• ⍵≡⍬:⍬: giriş boşsa, boş listeye dönün
• X←⍵≥⌈\⍵: tüm sayılar çalışan maksimum değere eşit veya daha büyük
• (⊂X/⍵): bu numaraların listesi
• ∇⍵/⍨~X: bu fonksiyonu kalan sayılar üzerinde çalıştırmanın sonucu

JavaScript (ES6), 64 bayt

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]

R , 61 bayt

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

Çevrimiçi deneyin!

Özyinelemeli işlevi. sum(x|1)kısaca length(x), bu nedenle özyineleme xboşalana kadar devam edecek . cummaxkümülatif maksimum değerini alır x, daha sonra xtekrar karşılaştırılır . Bu, xtüm TRUE'lerin sıralanmış değerlere karşılık geldiği bir boolean uzunluk vektörü üretir . Biz bir alt kümesini almak için kullanabilirsiniz xve printbunun. İşlev, kalan kısımda tekrar çağırılır x.

Java 8, 182 179 177 bayt

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;}

@Nevay sayesinde -3 bayt .
-2 bayt Stackyerine kullanarak Vector.

Açıklama:

Burada dene.

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

C #, 188 203 bayt

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();}

Bayt sayısı aşağıdakiler için +18 içerir:

using System.Linq;

Çevrimiçi deneyin!

C ++ 14, 118 108 bayt

W0lf Haskell cevabından algoritmayı kullanarak .

Adsız genel lambda olarak. İlk parametre, düşme noktası (gibi vector<int>) değerlerinin bir kabıdır ve ikinci parametre, vector<vector<int>>referans yoluyla geri dönüş değeri için uyumlu bir boş kap (benzeri ) gerektirir .

Programın ilk sürümünde, R.clear;()ilk ifade olarak vardı, böylece konteynerlerin boş olması gerekmezdi. Peter Cordes bunun şartnameye uygun olacağını düşündü, bu yüzden bunun için 10 bayt düşüyor.

[](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:;}}

Çevrimiçi deneyin!

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:;
 }
}

Python 2,8 bayt

Arnold Palmer sayesinde -4 bayt

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

Çevrimiçi deneyin!

@ W0lf's haskell ile benzer bir çözüm

for-elseİnşaat için nadir kullanım çantası

Sıralanan listelerde yineleyin for l in r(başlangıçta boştur).
Eğer eleman (girdiden) ilistenin son elemanından büyükse, listeye l[-1]eleman ekle l+=[i], kır.
Hiçbir liste kabul edilmediyse, bu elemenslerle yeni bir liste ekleyinr+=[[i]]

R, Devam eden iş (89, ama başarısız)

Burada bazı işlerim var, çünkü kendimi bir köşeye soktum %in%(yinelenen girişlerde, özellikle de son testte başarısız oluyor) ve şimdi başka şeyler yapmam gerekiyor, ama eğer biri üzerinde çalışmak isterse burada:

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
  }
}

JavaScript (ES6), 71 70 68 bayt

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

Oldukça basit, sadece diziyi tekrar eder, en son değeri bir <=sonraki değere düşecek olan ilk iç diziyi arar , eğer yoksa, çıktının bir sonraki değerine sahip yeni bir iç dizi ekler, aksi halde bir sonraki değeri ilke ekler koşula uygun iç dizi bulundu.

Güncellemeler

Neil sayesinde üç bayt dönüştürme kurtardı (...,o)etmek ...&&ove geri arama yeniden organize map()daha kompakt olması.

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}

Japt , 29 bayt

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

Çevrimiçi test edin!

C (gcc) , 176 175 173 bayt

#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("");}}

Çevrimiçi deneyin!

Biraz okunabilir versiyonu:

#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("");
    }
}

PHP, 91 103 96 85 bayt

(Çıktıya print_r($r);gereksinimi karşılamak için 12 karakter eklemek üzere
düzenlenmiştir ) (PHP Hatalarına izin verirken 7 baytı
kaldırmak için düzenlenmiştir ) (Atama sırasında daha fazla golf oynadığınızda 11 baytı kaldırmak için düzenlenmiştir)

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

Verilen giriş $a, sonuç üretir$r

Güzel:

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

Sözde-özyinelemeli dış döngü, tutma $bve atma $ddizilerini boşalmaya başlatır , ardından temel bir bırakma sıralama döngüsünü başlatır , nihayet atılanları yeni giriş olarak ayarlar ve sonuçlara sonuç ekler$r

PHP , 102 bayt , 98 bayt

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

Çevrimiçi deneyin!

@Şemsiye sayesinde -4 bayt

açıklama

<?php

İşlev, giriş listesini bir dizi olarak alır.

function s($i) {

$snihayet döndürülen listelerin listesi olacak, statik ilan edildi. Bu, kapsamını bu fonksiyonun tüm çağrıları için genişletir, bu sonuç listesini bir argüman olarak iletmek veya geri döndürmek zorunda kalmadan fonksiyonun tekrarlı olarak çağrılmasını sağlar.

    static $s;

Listedeki her değer arasında döngü.

    foreach ($i as $v)

Mevcut en büyük liste üyesinden daha mı az?

        $v < max($l) ?

Evet, $fdaha fazla sıralama için listeye yerleştirin .

                        $f[] = $v :

Hayır, listeye yaz $l.

                        $l[] = $v;

Listeyi listenin $lüzerine getirin.

    $s[] = $l;

Listede bir şey varsa $f, daha fazla sıralama için tekrar yollayın.

    !$f ?: s($f);

Listelerin listesini döndür.

    return $s;
}

Adaçayı, 102 bayt

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

@Dead Possum en çok benzer bir cevap .
Her üyeyi ekler xarasında wbirinci listeye aile {listelerinin listesi} x's son öğeden büyük.
hiçbiri eğer ekler [x]için a.

Eğer hiçbir şey bulunmazsa existsgeri döndüysem gerçekten isterdim a! Ayrıca @ officialaimm'in tek satırlı fikrini uygulamaya çalışıyorum ...

Soru: Kodumu işlevden kaldırırsam, wdoğru girişi yapmak zorunda mıyım? Peki baytları kurtarır mı?

Ocaml , 69 62 bayt

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

Açıklama:

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

APL, 100 88 83 79 78 57 56 77 76 bayt

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

-0 bayt Kritixi Lithos sayesinde ...

Çevrimiçi deneyin!

Bunu yapmanın daha iyi bir yolu olmalı ( Var ). Herhangi bir ipucu çok takdir ve memnuniyetle karşılıyoruz.

Nasıl?

(Bunun nasıl çalıştığını unuttuğum gibi, açıklamanın bir kısmı yanlış olabilir.)

{⍵≡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)

Jöle, 26 bayt

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

Bu, marinus'un APL cevabı ile aynı yöntemdir.

Çevrimiçi deneyin! .

JavaScript (Node.js) , 125 109 106 bayt

- Zacharý'dan 16 18 bayt

-1 , "akıma en son ayarlanmış" ayarını içerecek şekilde artırıcıyı kaldırarak {ve }değiştirerek

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}

Temel olarak, geçerli listenin son maddeden büyük olduğunu sorar, ilk listeye ekler. Aksi takdirde, ikinciye ekleyin.

Bu sırada herhangi bir sayıyı karşılaştırarak her NaNzaman sonuçlanacağı ortaya çıktı false. İlginç!

Açıklama:

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

Çevrimiçi deneyin!