Défi

Étant donné un tableau d'entiers non vide, par exemple:

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

Commencez par diviser le tableau en tableaux où aucun élément n’est plus volumineux que le précédent (tableaux non ascendants):

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

Ensuite, inversez chaque tableau:

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

Enfin, concaténez-les tous ensemble:

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

Cela devrait correspondre aux résultats / fonctions de votre programme. Répétez cette procédure suffisamment de fois et le tableau sera entièrement trié.

Règles

• L'entrée et la sortie peuvent être données par n'importe quelle méthode standard et dans n'importe quel format de tableau raisonnable.
• Le tableau en entrée ne sera jamais vide, mais peut contenir des négatifs et / ou des doublons.
• La valeur absolue de chaque entier sera toujours inférieure à 2 ³¹ .

Cas de test

Espérons que ceux-ci couvrent tous les cas extrêmes:

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

Notation

C'est le code-golf , donc le code le plus court en octets gagne.

JavaScript (ES6), 64 octets

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

Récursion FTW! L'algorithme de base utilisé ici consiste à garder une trace de l'exécution actuelle non ascendante dans un tableau, en la "renvoyant" à chaque fois qu'un élément ascendant est trouvé. Nous procédons de manière récursive en continuant à concaténer les résultats jusqu'à épuisement des éléments. En créant chaque exécution en sens inverse ( [n,...z]au lieu de [...z,n]), nous pouvons éviter les longs .reverse()sans frais.

Extrait de test

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 octets

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

Essayez-le en ligne!

Gelée , 8 octets

Ṁ;<œṗ³UF

Essayez-le en ligne!

Explication:

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

Bien sûr, cela est déjà dépassé par la réponse d'ETHproductions , mais c'est le mieux que je pourrais trouver jusqu'à présent sans utiliser de récursivité.

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

Remarque: initialiser les deux ret oexactement sur le même objet r = o = []peut ressembler à une idée hasardeuse. Mais il est prudent de le faire ici, car rsa propre instance (contenant le premier élément de a) est immédiatement affectée à la première itération avec r = [n, ...r].

Cas de 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 octets

lidO>vYsGhXSOZ)

L'entrée est un vecteur de colonne, au format [5; 2; 7; 6; 4; 1; 3](le point-virgule est le séparateur de lignes).

Essayez-le en ligne!

Prenons l’entrée [5; 2; 7; 6; 4; 1; 3]comme exemple.

Explication

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 octets

^{3 octets enregistrés à cause de @Martin Ender .}

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

Fonction anonyme. Prend une liste de nombres en entrée et renvoie une liste de nombres en sortie.

Python 2, 100 octets

Un golf vraiment épouvantable, mais je voulais poster ma solution (on ne dépasse pas simplement le golfe 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

Testez sur repl.it!

L'entrée doit être donnée sous forme de littéral de liste Python, tel que [5, 3, 4, 2, 6, 1].

L'idée de base est d'utiliser intensivement la syntaxe de découpage de Python, découpant chaque section nécessaire du tableau, l'inversant et l'ajoutant au nouveau tableau.

Pyke, 11 8 octets ( ancienne version )

$0m<fm_s

Essayez-le ici! (fonctionne sur la dernière version)

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

Retina , 163 octets

Oui, je sais à quel point c'est horrible. Soutenir les zéros et les négatifs était super amusant. Le nombre d'octets suppose un codage 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

Essayez-le en ligne

Explication:

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

2 octets enregistrés en utilisant le truc de tri de Luis Mendo

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

Essayez-le en ligne!

Explication

Exemple d'entrée [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]

Solution précédente de 16 octets

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

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

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

Expression Lambda prend un seul Arrayparamètre, a.

Merci à @ETHproductions pour m'aider à voir ma première erreur.

Ruby, 60 à 55 octets

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

À peu près ce que le défi demandait. J'ai défini un lambda s, qui prend un tableau x, et le divise (en tranches) en morceaux plus petits où l'élément suivant serait supérieur à. Cela rend un énumérateur, sur lequel on peut appeler map et inverser l'ordre des pièces, avant de finalement tout mettre ensemble avec flatten, ce qui concatène les éléments de l'ordre défini dans un tableau.

Des tests

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 octets

~c:{>=r}ac

Essayez-le en ligne!

Explication

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

Dyalog APL , 7 à 15 octets

Requiert ⎕ML←3, qui est la valeur par défaut sur de nombreux systèmes. *

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

∊ enrôler (aplatir)

⌽¨ chacun inversé

⍵⊂⍨ l'argument partitionné * en coupant où chaque élément correspondant est plus grand que son prédécesseur dans

1+ un plus

⍵- l'argument moins

⌊/⍵ le plus petit élément de l'argument

L'ancienne solution de 7 octets échoue avec des entiers non positifs:

Requiert ⎕ML←3, qui est la valeur par défaut sur de nombreux systèmes. *

∊⌽¨⊆⍨⎕

∊ enrôler le

⌽¨ chacun inversé

⊂⍨ auto-partitionné *

* Partition ( ⊂) est une fonction qui coupe son argument de droite lorsque l'argument de gauche correspondant est plus grand que le précédent. (Malheureusement, il accepte uniquement les entiers non négatifs, et zéro a une signification particulière.) À partir de la version 16, cette fonctionnalité de ⊂est disponible sur tous les systèmes (même ceux où ⎕ML≠3), à l'aide du glyphe ⊆.

Haskell, 49 octets

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

Exemple d'utilisation: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3].

Approche récursive La fonction %prend la liste d'entrée comme premier paramètre et un accumulateur lqui garde la trace du morceau non ascendant jusqu'à présent (dans l'ordre inverse). Le cas de base est atteint lorsque la liste d'entrée est vide et que le résultat est l'accumulateur. Si la liste d'entrée n'est pas vide et que le premier élément ane rentre pas dans le chunk actuel ( any(<a)l), renvoyez l'accumulateur et ajoutez un appel récursif au reste de la liste et en atant que nouvel accumulateur ( l++b%[a]). Sinon, faites un appel récursif sur le reste de la liste et apréfixé à tha accumulator ( b%(a:l)). La fonction principale (%[])appelle %avec un accumulateur vide.

Rétine , 98 octets

Le nombre d'octets suppose un codage ISO 8859-1.

$

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

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

Essayez-le en ligne!

R, 64 octets

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

Lit les entrées de stdin. Nous divisons l’entrée en une liste de vecteurs utilisant split()une variable facteur qui regroupe l’entrée. Le facteur est créé en prenant la somme cumulée du vecteur logique pour lequel la différence est positive.

Considérons le vecteur:

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

Maintenant, en prenant la différence et en ajoutant des points Fen exécutant, on y=c(F,diff(x)>0)obtiendrait le vecteur logique suivant:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

La somme cumulée cumsum(y)produit un vecteur où chaque groupe est représenté par un facteur unique sur lequel on peut combiner avec la splitfonction:

[1] 0 0 1 1 1 1 2

Octave, 75 44 octets

Basé sur la réponse MATL de @LuisMendo

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

Essayez-le en ligne!

Réponse précédente

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

Essayez-le en ligne!

inverser le tableau

f=fliplr(a)

prendre la première différence de f

d = diff(f);

trouver la position d'où l'élément suivant est inférieur à l'élément précédent

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

première différence des positions retourne la longueur de chaque sous-tableau

len=diff(p)

utilisez la longueur de chaque sous-tableau mat2cellpour diviser le tableau en liste imbriquée de tableaux

nest = mat2cell(f,1,len);

inverser la liste imbriquée

rev_nest = fliplr(nest) 

aplatir la liste imbriquée

[rev_nest{:}]

Pyth - 15 octets

s_McQf<@QtT@QTU

Essayez-le en ligne ici .

Perl 6 , 59 octets

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

Solution basée sur regex.
Parce que c'est Sparta Perl !!

• m/ /: Stringify le tableau en entrée et associe une expression rationnelle à celle-ci.
• (\-? \d+): Correspond à un nombre et capture le comme $0.
• <?{ [>=] $0 }>: Assertion de largeur nulle qui correspond uniquement si tous les $0objets capturés jusqu'à présent dans la sous-correspondance actuelle sont dans un ordre non croissant.
• ([ ] +)+: Répétez les deux dernières étapes aussi souvent que possible, sinon commencez une nouvelle sous-correspondance.
• map , [0]: Itérer sur les sous-correspondances.
• |+«*.[0].reverse: Pour chacune d'elles, prenez la liste des valeurs correspondant $0, renversez-la, forcez-la en nombres ( +«) et glissez-les dans la liste externe ( |).

Perl 6 , 63 octets

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

Solution de traitement de liste récursive.
Plus laborieux que je ne l'avais espéré.
Bien que le langage comporte de nombreuses fonctions intégrées pratiques, il ne semble pas exister de partitionnement de liste (comme par exemple Ruby's slice_whenou Haskell takeWhile).

Empilé , non compétitif, 34 octets

Développer constamment ce langage.

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

L'argument repose sur TOS. Essayez-le ici!

chunkbyprend une fonction et collecte des tableaux de données contiguës qui satisfont la fonction. La fonction est alors:

{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

Cela donne un tableau strictement décroissant.

$revmapest fondamentalement [rev]mapet renverse chaque élément.

flat aplatit enfin le tableau.

Un peu de plaisir pour trier le tableau:

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

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

Cette sortie (par exemple):

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

Sauvegardé 12 octets grâce à @ Flp.Tkc!

Nulle part près de @ Flp.Tkc, encore moins ...

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 octets

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

Entrée a, sortiec

Python 3, 191 octets

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)

Je ne suis pas sûr si l'utilisation de la sortedfonction pour vérifier est autorisée ici, mais je ne pouvais pas penser à une bonne raison contre cela, et cela a réduit mon nombre d'octets d'environ 30 octets.

Clojure, 105 octets

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

Les partitions en paires sur des numéros consécutifs, met trueou falseentre eux, partitions notpour trueet les numéros deviennent falseet false trueintervertit les partitions et conserve des valeurs numériques.