Tantangan

Diberikan array integer yang tidak kosong, misalnya:

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

Pertama-tama pisahkan ke dalam array di mana tidak ada item yang lebih besar dari sebelumnya (yaitu array yang tidak naik):

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

Selanjutnya, balikkan setiap larik:

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

Akhirnya, gabungkan semuanya bersama-sama:

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

Ini seharusnya yang dihasilkan oleh output / fungsi program Anda. Ulangi prosedur ini cukup kali dan array akan sepenuhnya diurutkan.

Aturan

• Input dan output dapat diberikan melalui metode standar apa pun, dan mungkin dalam format array yang wajar.
• Array input tidak akan pernah kosong, tetapi mungkin mengandung negatif dan / atau duplikat.
• Nilai absolut dari setiap bilangan bulat akan selalu kurang dari 2 ³¹ .

Uji kasus

Semoga ini mencakup semua kasus tepi:

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

Mencetak gol

Ini adalah kode-golf , jadi kode terpendek dalam byte menang.

JavaScript (ES6), 64 byte

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

Rekursi FTW! Algoritma dasar yang digunakan di sini adalah untuk melacak run non-ascending saat ini dalam array, "mengembalikannya" setiap kali elemen ascending ditemukan. Kami melakukan ini secara rekursif, terus menyatukan hasilnya, sampai kami kehabisan barang. Dengan membuat setiap menjalankan secara terbalik ( [n,...z]bukan [...z,n]), kita dapat menghindari yang panjang .reverse()tanpa biaya.

Cuplikan tes

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 byte

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

Cobalah online!

Jelly , 8 byte

Ṁ;<œṗ³UF

Cobalah online!

Penjelasan:

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

Tentu, ini sudah dikalahkan oleh jawaban ETHproductions , tapi itu yang terbaik yang bisa saya dapatkan sejauh ini tanpa menggunakan rekursi.

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

Catatan: Menginisialisasi keduanya rdan oke objek yang sama persis r = o = []mungkin terlihat seperti ide berbahaya. Tetapi aman untuk melakukannya di sini karena rsegera diberi contoh sendiri (berisi elemen pertama a) pada iterasi pertama dengan r = [n, ...r].

Uji kasus

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 byte

lidO>vYsGhXSOZ)

Input adalah vektor kolom, dengan format [5; 2; 7; 6; 4; 1; 3](titik koma adalah pemisah baris).

Cobalah online!

Ambil input [5; 2; 7; 6; 4; 1; 3]sebagai contoh.

Penjelasan

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 byte

^{3 byte disimpan karena @Martin Ender .}

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

Fungsi anonim. Mengambil daftar angka sebagai input dan mengembalikan daftar angka sebagai output.

Python 2, 100 byte

Golf yang sangat mengerikan, tetapi saya ingin memposting solusi saya (seseorang tidak hanya mengalahkan Dennis) ...

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

Uji pada repl.it!

Input harus diberikan sebagai literal daftar Python, seperti [5, 3, 4, 2, 6, 1].

Ide dasarnya adalah menggunakan sintaksis slicing Python, memotong setiap bagian yang diperlukan dari array, membalikkannya, dan menambahkannya ke array baru.

Pyke, 11 8 byte ( versi lama )

$0m<fm_s

Coba di sini! (bekerja pada versi terbaru)

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

Retina , 163 byte

Ya, saya tahu betapa mengerikannya ini. Mendukung nol dan negatif adalah sangat menyenangkan. Hitungan byte mengasumsikan penyandian ISO 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

Cobalah online

Penjelasan:

\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 byte

Disimpan 2 byte menggunakan trik sortir Luis Mendo

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

Cobalah online!

Penjelasan

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

Solusi 16 byte sebelumnya

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

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

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

Ekspresi Lambda mengambil satu Arrayparameter a,.

Terima kasih kepada @ETHproductions karena membantu saya melihat kesalahan pertama saya.

Ruby, 60 55 byte

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

Cukup banyak tantangan yang diminta. Saya mendefinisikan sebuah lambda s, yang mengambil array x, dan memotong (mengiris) itu menjadi potongan-potongan kecil di mana elemen berikut akan lebih besar dari. Ini mengembalikan pencacah, yang dapat kita sebut peta dan membalik urutan potongan-potongan, sebelum akhirnya menyatukan semuanya dengan merata, yang menggabungkan elemen-elemen dalam urutan yang ditetapkan ke dalam satu array.

Tes

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 byte

~c:{>=r}ac

Cobalah online!

Penjelasan

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

Dyalog APL , 7 15 byte

Membutuhkan ⎕ML←3, yang merupakan standar pada banyak sistem. *

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

∊ minta (ratakan)

⌽¨ masing-masing terbalik

⍵⊂⍨ argumen dipartisi * dengan memotong di mana setiap elemen yang sesuai lebih besar dari pendahulunya di

1+ satu ditambah

⍵- argumen dikurangi

⌊/⍵ elemen terkecil dari argumen

Solusi 7 byte lama gagal dengan bilangan bulat tidak positif:

Membutuhkan ⎕ML←3, yang merupakan standar pada banyak sistem. *

∊⌽¨⊆⍨⎕

∊ minta (ratakan)

⌽¨ masing-masing terbalik

⊂⍨ dipartisi sendiri *

* Partition ( ⊂) adalah fungsi yang memotong argumen kanannya di mana argumen kiri yang sesuai lebih besar dari yang sebelumnya. (Sayangnya itu hanya menerima bilangan bulat non-negatif, dan nol memiliki arti khusus.) Dari versi 16, fungsi ⊂ini tersedia pada semua sistem (bahkan yang ada di mana ⎕ML≠3), menggunakan mesin terbang ⊆.

Haskell, 49 byte

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

Contoh penggunaan: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3].

Pendekatan rekursif. Fungsi %mengambil daftar input sebagai parameter pertama dan akumulator lyang melacak potongan non-ascending sejauh ini (dalam urutan terbalik). Kasing dasar tercapai ketika daftar input kosong dan hasilnya adalah akumulator. Jika daftar input tidak kosong dan elemen pertama atidak cocok dengan chunk saat ini ( any(<a)l), kembalikan akumulator dan tambahkan panggilan rekursif pada sisa daftar dan asebagai akumulator baru ( l++b%[a]). Lain, buat panggilan rekursif pada sisa daftar dan aditambahkan ke akumulator ( b%(a:l)). (%[])Panggilan fungsi utama %dengan akumulator kosong.

Retina , 98 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

$

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

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

Cobalah online!

R, 64 byte

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

Membaca input dari stdin. Kami membagi input menjadi daftar vektor split()yang memerlukan variabel faktor yang mengelompokkan input. Faktor dibuat dengan mengambil jumlah kumulatif dari vektor logis yang perbedaannya positif.

Pertimbangkan vektor:

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

Sekarang mengambil perbedaan dan mengawali Fdengan menjalankan y=c(F,diff(x)>0)akan menghasilkan vektor logis berikut:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

Mengambil jumlah kumulatif cumsum(y)menghasilkan vektor di mana masing-masing kelompok diwakili oleh faktor unik yang dapat kita gabungkan dengan splitfungsi:

[1] 0 0 1 1 1 1 2

Oktaf, 75 44 byte

Berdasarkan jawaban MATL dari @LuisMendo

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

Cobalah secara Online!

Jawaban sebelumnya

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

Cobalah secara Online!

membalikkan array

f=fliplr(a)

ambil perbedaan pertama f

d = diff(f);

temukan posisi di mana elemen berikutnya kurang dari elemen sebelumnya

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

Perbedaan pertama dari posisi mengembalikan panjang setiap sub array

len=diff(p)

gunakan panjang masing-masing sub array mat2celluntuk membagi array ke daftar array yang bersarang

nest = mat2cell(f,1,len);

membalikkan daftar bersarang

rev_nest = fliplr(nest) 

meratakan daftar bersarang

[rev_nest{:}]

Pyth - 15 byte

s_McQf<@QtT@QTU

Cobalah online di sini .

Perl 6 , 59 byte

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

Solusi berbasis Regex.
Karena ini Sparta Perl !!

• m/ /: Merumuskan array input, dan mencocokkan regex dengan itu.
• (\-? \d+): Cocokkan angka, dan tangkap sebagai $0.
• <?{ [>=] $0 }>: Pernyataan nol-lebar yang hanya cocok jika semua yang $0ditangkap sejauh ini dalam sub-pertandingan saat ini berada dalam urutan non-naik.
• ([ ] +)+: Ulangi dua langkah terakhir sesering mungkin, jika tidak, mulailah sub-pertandingan baru.
• map , [0]: Iterate atas sub-pertandingan.
• |+«*.[0].reverse: Untuk masing-masing, ambil daftar nilai yang cocok dengan $0, balikkan, paksa nilai ke angka ( +«), dan masukkan ke daftar luar ( |).

Perl 6 , 63 byte

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

Solusi pemrosesan daftar rekursif.
Lebih melelahkan daripada yang saya harapkan.
Meskipun bahasanya memiliki banyak built-in yang nyaman, sepertinya tidak ada satu pun untuk partisi daftar (misalnya seperti Ruby slice_whenatau Haskell takeWhile).

Stacked , noncompeting, 34 byte

Masih terus mengembangkan bahasa ini.

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

Argumennya terletak pada TOS. Coba di sini!

chunkbymengambil fungsi dan mengumpulkan array data yang berdekatan yang memenuhi fungsi. Fungsi itu adalah:

{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

Ini memberikan array yang sangat menurun.

$revmappada dasarnya [rev]mapdan membalikkan setiap item.

flat akhirnya meratakan array.

Beberapa kesenangan untuk benar-benar menyortir array:

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

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

Output ini (misalnya):

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

Disimpan 12 Bytes berkat @ Flp.Tkc!

Tidak ada di dekat @ Flp.Tkc, apalagi ...

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 byte

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

Input masuk a, keluaran masukc

Python 3, 191 Bytes

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)

Saya tidak yakin apakah menggunakan sortedfungsi untuk memeriksa diizinkan di sini, tapi saya tidak bisa memikirkan alasan yang bagus untuk menolaknya, dan itu menurunkan jumlah byte saya hingga ~ 30 Bytes.

Clojure, 105 byte

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

Partisi berpasangan pada angka berurutan, menempatkan trueatau di falseantara mereka, partisi notke truedan angka menjadi falsedan false true, membalikkan partisi dan mempertahankan nilai numerik.