Sfida

Dato un array non vuoto di numeri interi, ad esempio:

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

Prima taglialo in matrici in cui nessun oggetto è più grande del precedente (cioè matrici non ascendenti):

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

Quindi, invertire ciascun array:

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

Infine, concatenali tutti insieme:

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

Questo dovrebbe essere ciò che restituisce il tuo programma output / funzione. Ripetere questa procedura abbastanza volte e l'array verrà completamente ordinato.

Regole

• L'input e l'output possono essere forniti con qualsiasi metodo standard e possono essere in qualsiasi formato di array ragionevole.
• L'array di input non sarà mai vuoto, ma può contenere negativi e / o duplicati.
• Il valore assoluto di ciascun numero intero sarà sempre inferiore a 2 ³¹ .

Casi test

Speriamo che coprano tutti i casi limite:

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

punteggio

Questo è code-golf , quindi vince il codice più breve in byte.

JavaScript (ES6), 64 byte

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

Ricorsione FTW! L'algoritmo di base in uso qui è di tenere traccia della corsa corrente non crescente in un array, "restituendola" ogni volta che viene trovato un elemento crescente. Lo facciamo in modo ricorsivo, concatenando continuamente i risultati, fino a quando non finiamo gli articoli. Creando ogni corsa al contrario ( [n,...z]anziché [...z,n]), possiamo evitare il lungo .reverse()senza alcun costo.

Test snippet

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

Provalo online!

Gelatina , 8 byte

Ṁ;<œṗ³UF

Provalo online!

Spiegazione:

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

Certo, questo è già battuto dalla risposta ETHproductions , ma è il massimo che ho potuto inventare finora senza usare la ricorsione.

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

Nota: inizializzazione sia re oper la stessa identica oggetto con r = o = []può sembrare un'idea pericolosa. Ma è sicuro farlo qui perché rviene immediatamente assegnata la propria istanza (contenente il primo elemento di a) sulla prima iterazione con r = [n, ...r].

Casi test

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)

L'input è un vettore di colonna, con il formato [5; 2; 7; 6; 4; 1; 3](punto e virgola è il separatore di riga).

Provalo online!

Prendi l'input [5; 2; 7; 6; 4; 1; 3]come esempio.

Spiegazione

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 salvati grazie a @Martin Ender .}

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

Funzione anonima. Prende un elenco di numeri come input e restituisce un elenco di numeri come output.

Python 2, 100 byte

Un golf davvero terribile, ma volevo pubblicare la mia soluzione (non si supera semplicemente 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

Test su repl.it!

L'input dovrebbe essere dato come un elenco Python letterale, come [5, 3, 4, 2, 6, 1].

L'idea di base è quella di fare un uso intensivo della sintassi di divisione di Python, suddividere ogni sezione necessaria dall'array, invertirla e aggiungerla al nuovo array.

Pyke, 11 8 byte ( vecchia versione )

$0m<fm_s

Provalo qui! (funziona sull'ultima versione)

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

Retina , 163 byte

Sì, so quanto sia orribile. Supportare zeri e negativi è stato molto divertente. Il conteggio dei byte presuppone la codifica 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

Provalo online

Spiegazione:

\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

Hai salvato 2 byte usando il trucco di ordinamento di Luis Mendo

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

Provalo online!

Spiegazione

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

Precedente soluzione a 16 byte

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

Espressione lambda assume un singolo Arrayparametro, a.

Grazie a @ETHproductions per avermi aiutato a vedere il mio primo errore.

Rubino, 60 55 byte

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

Praticamente quello che la sfida ha richiesto. Ho definito un lambda s, che accetta un array x, e lo divido in sezioni più piccole in cui il seguente elemento sarebbe maggiore di. Questo restituisce un enumeratore, sul quale possiamo richiamare la mappa e invertire l'ordine dei pezzi, prima di riunire infine tutto insieme con appiattire, che concatena gli elementi nell'ordine definito in un array.

test

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

Provalo online!

Spiegazione

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

Dyalog APL , 7 15 byte

Richiede ⎕ML←3, che è predefinito su molti sistemi. *

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

∊ arruolarsi (appiattire)

⌽¨ ogni invertita

⍵⊂⍨ l'argomento partizionato * tagliando dove ogni elemento corrispondente è più grande del suo predecessore in

1+ uno più

⍵- l'argomento meno

⌊/⍵ il più piccolo elemento dell'argomento

La vecchia soluzione a 7 byte ha esito negativo con numeri interi non positivi:

Richiede ⎕ML←3, che è predefinito su molti sistemi. *

∊⌽¨⊆⍨⎕

∊ arruolare (appiattire) il

⌽¨ ogni invertita

⊂⍨ auto-partizionato *

* Partition ( ⊂) è una funzione che taglia il suo argomento destro in cui l'argomento sinistro corrispondente è più grande di quello precedente. (Sfortunatamente accetta solo numeri interi non negativi e zero ha un significato speciale.) Dalla versione 16, questa funzionalità di ⊂è disponibile su tutti i sistemi (anche quelli in cui ⎕ML≠3), usando il glifo ⊆.

Haskell, 49 byte

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

Esempio di utilizzo: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3].

Approccio ricorsivo La funzione %prende l'elenco di input come primo parametro e un accumulatore lche tiene traccia del blocco non crescente finora (in ordine inverso). Il caso base viene raggiunto quando l'elenco di input è vuoto e quindi il risultato è l'accumulatore. Se l'elenco di input non è vuoto e il primo elemento anon si adatta al blocco corrente ( any(<a)l), restituisce l'accumulatore e aggiungi una chiamata ricorsiva sul resto dell'elenco e acome nuovo accumulatore ( l++b%[a]). Altrimenti, effettua una chiamata ricorsiva sul resto dell'elenco e aanteposta all'accumulatore ( b%(a:l)). La funzione principale (%[])chiama %con un accumulatore vuoto.

Retina , 98 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

$

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

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

Provalo online!

R, 64 byte

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

Legge input da stdin. Dividiamo l'input in un elenco di vettori usando il split()quale richiede una variabile fattore che raggruppa l'input. Il fattore viene creato prendendo la somma cumulativa del vettore logico per il quale la differenza è positiva.

Considera il vettore:

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

Ora prendere la differenza e anticipare Feseguendo y=c(F,diff(x)>0)produce il seguente vettore logico:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

Prendere la somma cumulativa cumsum(y)produce un vettore in cui ogni gruppo è rappresentato da un fattore unico su cui possiamo combinare con la splitfunzione:

[1] 0 0 1 1 1 1 2

Ottava, 75 44 byte

Basato sulla risposta MATL di @LuisMendo

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

Provalo online!

Risposta precedente

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

Provalo online!

invertire l'array

f=fliplr(a)

prendere la prima differenza di f

d = diff(f);

trova la posizione in cui l'elemento successivo è inferiore all'elemento precedente

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

la prima differenza delle posizioni restituisce la lunghezza di ciascun array secondario

len=diff(p)

utilizzare la lunghezza di ciascun array secondario mat2cellper dividere l'array in un elenco nidificato di array

nest = mat2cell(f,1,len);

inverti l'elenco nidificato

rev_nest = fliplr(nest) 

appiattire l'elenco nidificato

[rev_nest{:}]

Pyth - 15 byte

s_McQf<@QtT@QTU

Provalo online qui .

Perl 6 , 59 byte

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

Soluzione basata su Regex.
Perché questo è Sparta Perl !!

• m/ /: Stringa l'array di input e abbina una regex contro di esso.
• (\-? \d+): Abbina un numero e acquisiscilo come $0.
• <?{ [>=] $0 }>: Asserzione di larghezza zero che corrisponde solo se tutti i dati $0acquisiti finora nella corrispondenza secondaria corrente sono in ordine non crescente.
• ([ ] +)+: Ripeti gli ultimi due passaggi il più spesso possibile, altrimenti avvia una nuova sotto-partita.
• map , [0]: Iterate sulle sotto-partite.
• |+«*.[0].reverse: Per ognuno, prendi la lista dei valori corrispondenti $0a, invertila, coercita i valori in numeri ( +«) e inseriscili nella lista esterna ( |).

Perl 6 , 63 byte

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

Soluzione di elaborazione elenco ricorsiva.
Più laborioso di quanto avessi sperato.
Anche se il linguaggio ha molti comodi incorporati, sembra che non ce ne sia nessuno per il partizionamento degli elenchi (ad es. Come quello di Ruby slice_wheno Haskell takeWhile).

Impilato , non competitivo, 34 byte

Sviluppando ancora costantemente questo linguaggio.

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

L'argomento si basa su TOS. Provalo qui!

chunkbyaccetta una funzione e raccoglie matrici di dati contigui che soddisfano la funzione. La funzione quindi è:

{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

Questo dà un array strettamente decrescente.

$revmapè fondamentalmente [rev]mape inverte ogni articolo.

flat infine appiattisce l'array.

Divertimento per l'ordinamento dell'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

Questo produce (ad esempio):

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

Risparmiato 12 byte grazie a @ Flp.Tkc!

Da nessuna parte vicino a @ Flp.Tkc, figuriamoci ...

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

Ingresso in a, uscita inc

Python 3, 191 byte

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)

Non sono sicuro se l'uso della sortedfunzione per verificare sia consentito qui, ma non potrei pensare a una buona ragione per non farlo, e ha ridotto il mio conteggio dei byte di ~ 30 byte.

Clojure, 105 byte

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

Partizioni in coppie su numeri consecutivi, mette trueo falsetra di essi, partizioni notper truee numeri diventano falsee false true, pareti inverte e mantiene valori numerici.