Meydan okuma

Boş olmayan bir tamsayı dizisi verildiğinde, örneğin:

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

Öncelikle, hiçbir öğenin öncekinden daha büyük olmadığı dizilere bölün (örneğin yükselmeyen diziler):

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

Ardından, her bir diziyi tersten izleyin:

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

Sonunda hepsini bir araya getirin:

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

Programınızın çıktıları / işlevi bu şekilde dönmelidir. Bu işlemi yeterince tekrarlayın ve dizi tamamen sıralanacaktır.

kurallar

• Giriş ve çıkış herhangi bir standart yöntemle verilebilir ve herhangi bir makul dizi biçiminde olabilir.
• Giriş dizisi asla boş bırakılmaz, ancak negatifler ve / veya kopyalar içerebilir.
• Her bir tamsayının mutlak değeri her zaman 2 ^31'den az olacaktır .

Test durumları

Umarım bu tüm kenar davaları kapsar:

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

puanlama

Bu kod golf , yani bayt cinsinden en kısa kod kazanır.

JavaScript (ES6), 64 bayt

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

Özyineleme FTW! Burada kullanılan temel algoritma, yükselen bir dizide mevcut yükselen olmayan koşuyu izlemektir, yükselen bir eleman bulunduğunda onu "döndürür". Bunu tekrarlayarak yaparız, sonuçları tükenene kadar sonuçları bir araya getiririz. Her koşuyu tersine ( [n,...z]yerine [...z,n]) oluşturarak, uzun süreler bedelsiz .reverse()olarak önlenebiliriz .

Test pasajı

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>

Python 3 , 63 bayt

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

Çevrimiçi deneyin!

Jöle , 8 bayt

Ṁ;<œṗ³UF

Çevrimiçi deneyin!

Açıklama:

Ṁ;         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.

JavaScript (ES6), 70 bayt

Elbette, bu zaten ETHProductions'un cevabı tarafından yenildi , ancak özyineleme kullanmadan bugüne kadar bulabildiğim en iyisi bu.

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

Not: Her ikisini de rve oaynı nesneyi başlatmak r = o = [], tehlikeli bir fikir gibi görünebilir. Ancak burada bunu yapmak güvenlidir çünkü ilk yinelemede rhemen kendi örneğine (ilk öğesini içeren) atanır .ar = [n, ...r]

Test durumları

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

MATL , 15 bayt

lidO>vYsGhXSOZ)

Giriş, formatlı bir sütun vektörüdür [5; 2; 7; 6; 4; 1; 3](noktalı virgül satır ayırıcıdır).

Çevrimiçi deneyin!

Giriş [5; 2; 7; 6; 4; 1; 3]olarak örnek alın .

açıklama

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]

Mathematica, 30 27 bayt

^{@Martin Ender nedeniyle 3 bayt kaydedildi .}

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

Anonim işlev Giriş olarak sayıların bir listesini alır ve çıktı olarak bir sayıların listesini döndürür.

Python 2, 100 bayt

Gerçekten korkunç bir golf, ancak çözümümü yayınlamak istedim (biri Dennis'i dışlamaz) ...

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 üzerinde test edin!

Girdi, gibi bir Python listesi olarak verilmelidir [5, 3, 4, 2, 6, 1].

Temel fikir Python'un dilimleme sözdizimini yoğun kullanmak, her gerekli bölümü diziden dilimlemek, tersine çevirmek ve yeni diziye eklemek.

Pyke, 11 8 bayt ( eski versiyon )

$0m<fm_s

Burada dene! (en son sürümde çalışır)

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

Retina , 163 bayt

Evet, bunun ne kadar korkunç olduğunu biliyorum. Sıfırları ve negatifleri desteklemek süper eğlenceliydi. Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

\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

Çevrimiçi deneyin

Açıklama:

\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

05AB1E , 19 18 16 14 bayt

Luis Mendo'nun sıralama hilesini kullanarak 2 bayt kurtarıldı

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

Çevrimiçi deneyin!

açıklama

Örnek giriş [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]

Önceki 16 bayt çözüm

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

JavaScript (ECMA 6), 121 128 125 119 108 bayt

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

Lambda ifadesi tek bir Arrayparametre alır a,.

İlk hatamı görmeme yardımcı olduğu için @ETHproductions'a teşekkür ederiz.

Ruby, 60 55 bayt

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

Neredeyse meydan okuma için ne istedi. Bir lambda tanımlanan sbir dizi alır, xve sever aşağıdaki elemanının daha büyük olacak daha küçük parçalar halinde (dilim). Bu geri biz haritayı arayıp bir numaralandırıcıyı verir ters adet sipariş, daha önce nihayet düzleştirin tüm buluşmanızı, getiren birleştirir tek diziye tanımlanan sırayla elemanları.

Testler

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]

Brachylog , 10 bayt

~c:{>=r}ac

Çevrimiçi deneyin!

açıklama

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

Dyalog APL , 7 15 bayt

⎕ML←3Birçok sistemde varsayılan olan gerektirir . *

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

∊ enlist (düzleştirmek)

⌽¨ Her bir ters çevrilmiş

⍵⊂⍨ Argüman, * karşılık gelen her bir öğenin öncekinden daha büyük olduğu yeri keserek bölümlendirilir *

1+ bir artı

⍵- tartışma eksi

⌊/⍵ argümanın en küçük elemanı

Eski 7 byte çözüm pozitif olmayan tamsayılarla başarısız oluyor:

⎕ML←3Birçok sistemde varsayılan olan gerektirir . *

∊⌽¨⊆⍨⎕

∊ listelemek (düzleştirmek)

⌽¨ Her bir ters çevrilmiş

⊂⍨ kendinden bölümlenmiş *

* Partition ( ⊂), ilgili sol argümanın öncekinden daha büyük olduğu yerde sağ argümanını kesen bir fonksiyondur. (Ne yazık ki, yalnızca negatif olmayan tamsayıları kabul eder ve sıfırın özel bir anlamı vardır.) Sürüm 16'dan itibaren, bu işlev , glif kullanılarak ⊂tüm sistemlerde (hatta bu yerlerde ⎕ML≠3) kullanılabilir ⊆.

Haskell, 49 bayt

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

Kullanım örneği: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3].

Özyinelemeli yaklaşım. İşlev %, giriş listesini ilk parametresi olarak ve lyükselen öbek yığınını şimdiye kadar izleyen bir akümülatör (ters sırada) olarak alır. Giriş listesi boş olduğunda temel duruma ulaşılır ve sonuç akümülatördür. Giriş listesi boş değilse ve ilk öğe ageçerli öbeğe ( any(<a)l) sığmıyorsa , akümülatörü döndürün ve listenin geri kalanına ve ayeni akümülatör ( l++b%[a]) olarak tekrarlamalı bir çağrı ekleyin . Aksi halde, listenin geri kalanında özyinelemeli bir çağrı yapın ve aakümülatöre ( b%(a:l)) hazırlanın. Ana işlev boş bir akü ile (%[])çağırır %.

Retina , 98 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

$

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

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

Çevrimiçi deneyin!

R, 64 bayt

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

Stdin'den girişi okur. Girişi split(), girişleri gruplayan bir faktör değişkeni gerektiren bir vektörler listesine ayırdık . Faktör, farkın pozitif olduğu mantıksal vektörün kümülatif toplamını alarak yaratılır.

Vektörü düşünün:

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

Şimdi farkı almak ve koşarak Fhazırlanmak y=c(F,diff(x)>0)aşağıdaki mantıksal vektörü üretecektir:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

Biriktirici toplamı almak, cumsum(y)her grubun, splitişlevle birleştirebileceğimiz benzersiz bir faktörle temsil edildiği bir vektör üretir :

[1] 0 0 1 1 1 1 2

Octave, 75 44 bayt

Dayanarak Matl cevap @LuisMendo arasında

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

Çevrimiçi Deneyin!

Önceki cevap

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

Çevrimiçi Deneyin!

diziyi ters çevir

f=fliplr(a)

ilk farkını almak f

d = diff(f);

sonraki öğenin önceki öğeden daha az olduğu konumu bulun

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

Konumların ilk farkı her alt dizinin uzunluğunu döndürür

len=diff(p)

mat2celldiziyi iç içe dizilerin listesine bölmek için her alt dizinin uzunluğunu kullanın

nest = mat2cell(f,1,len);

iç içe geçmiş listeyi ters çevir

rev_nest = fliplr(nest) 

iç içe geçmiş listeyi düzleştirmek

[rev_nest{:}]

Pyth - 15 bayt

s_McQf<@QtT@QTU

Burada çevrimiçi deneyin .

Perl 6 , 59 bayt

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

Regex tabanlı çözüm.
Çünkü bu Sparta Perl!

• m/ /: Girdi dizisini dizge edin ve buna göre bir regex eşleştirin.
• (\-? \d+): Bir numarayı eşleştir ve onu yakala $0.
• <?{ [>=] $0 }>: Yalnızca $0mevcut alt maçta şimdiye kadar yakalananların tümü artan sırada değilse, eşleşen genişlik iddiası .
• ([ ] +)+: Son iki adımı mümkün olduğunca tekrarlayın, aksi takdirde yeni bir alt maç başlatın.
• map , [0]: Alt eşleşmeleri tekrar eder.
• |+«*.[0].reverse: Her biri için eşleşen değerlerin listesini alın $0, ters çevirin, değerleri sayılara zorlayın ( +«) ve bunları dış listeye ( |) kaydırın .

Perl 6 , 63 bayt

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

Özyinelemeli liste işleme çözümü.
Beklediğimden daha zahmetli.
Dilin birçok yerleşik yerleşimi olsa da, liste bölümlemesi için hiçbir şey yok gibi görünüyor (örneğin Ruby's slice_whenveya Haskell'inki gibi takeWhile).

Yığılmış , rekabet etmeyen, 34 bayt

Hala sürekli bu dili geliştiriyorum.

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

Argüman TOS'ta yatıyor. Burada dene!

chunkbybir işlevi alır ve işlevi yerine getiren bitişik veri dizilerini toplar. İşlev o zaman:

{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

Bu kesinlikle azalan bir dizi verir.

$revmaptemelde [rev]mapve her öğeyi tersine çevirir.

flat Sonunda diziyi düzleştirir.

Diziyi gerçekten sıralamak için biraz eğlenceli:

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

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

Bu çıktılar (örneğin):

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

Python, 151 139 Bayt

@ Flp.Tkc sayesinde 12 bayt kaydedildi!

@ Flp.Tkc'nin hiçbir yerinde, yalnız kalsın ...

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]

Python 2,74 bayt

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

Giriş a, çıkışc

Python 3, 191 Bayt

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)

sortedBurada kontrol etmek için bu fonksiyonun kullanılmasına izin verilip verilmediğinden emin değilim , ancak buna karşı iyi bir sebep düşünemedim ve bayt sayımı ~ 30 Bayt düşürdü.

Clojure, 105 bayt

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

Ardışık sayılar, atmaktadır ikili gruplara bölmeler trueveya falsearalarındaki üzerine bölümleri notiçin trueve rakamlar haline falseve false true, tersine çevirir bölümleri ve sayısal değerleri tutar.