Sever-trier un tableau

44

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 31 .

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 , donc le code le plus court en octets gagne.

ETHproductions
la source
4
Quel est le gros de cette méthode de tri?
mbomb007
1
@ mbomb007 Je ne comprends pas très bien la notation big-o, mais je pense qu'une seule itération est O (n). Multipliez cela par n itération dans le cas le plus défavorable et vous obtiendrez O (n ^ 2) (dans le cas le plus défavorable, le meilleur des cas serait O (n), je pense, pour une seule itération).
ETHproductions
1
Cela me semble juste, mais il est utile de souligner que l'inversion d'un tableau n'est pas une opération très efficace, c'est donc un processus lentO(n^2)
DJMcMayhem
2
@WheatWizard inverser un tableau ne nécessite pas d'espace pour une copie du tableau, mais pour un seul élément. et est O(n). permutez les premier et dernier éléments puis échangez les deuxième et deuxième derniers éléments, etc., lorsque vous arrivez au milieu.
Jasen
L'inversion l'est O(n), mais l'inversion peut être intégrée directement dans l'algorithme (c'est ce que ma réponse JS fait); étant donné que chaque itération effectue une boucle sur chaque élément du tableau une seule fois, une seule itération l’est O(n). (Je pense ...)
ETHproductions

Réponses:

19

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

ETHproductions
la source
Pouvez-vous expliquer comment votre tableau est analysé dans votre premier paramètre [n,...a]. C'est quoi n? Est-ce juste le premier élément de votre tableau?
Oliver
1
@obarakon Correct. nest le premier élément du tableau et aconstitue le reste du tableau. Vous pouvez trouver plus d'informations ici .
ETHproductions
Merci. C'était très utile. Puisque votre premier paramètre est un tableau, pourquoi avez-vous besoin d'inclure le ...a? Est-ce juste pour que vous puissiez en profiter n? Une dernière chose, quand vous appelez f(a,q), est qréglé sur le paramètre z?
Oliver
1
@obarakon Eh bien, f=([n])=>...ne capturerait que le premier élément et f=([n,a])=>...capturerait uniquement le premier net le second a. Une autre façon de faire ce que ce f=([n,...a])=>,,,serait f=a=>(n=a.unshift(),....
ETHproductions
1
Et puisque zest le deuxième paramètre de la fonction, quand f(a,q)est appelé, le fvoit comme z. J'espère que cela t'aides!
ETHproductions
11

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.
Lynn
la source
1
J'étais sur le point de frapper Save Edit quand j'ai vu votre réponse ... Bien joué.
Dennis
@ Dennis Heh, vous avez donc ajouté Dyalog partitioned enclose, mais qu'en est-il de la partition APL2?
Adám
11

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

Arnauld
la source
2
Pas de soucis, j'adore voir différentes approches. Et on finit souvent par devenir plus court qu'un autre après le golf :-)
ETHproductions
8

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]
Luis Mendo
la source
J'ai traduit votre réponse en Octave m'a sauvé 31 octets!
rahnema1
7

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.

LegionMammal978
la source
Battez-moi à elle! :)
Greg Martin
5

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.

FlipTack
la source
Je pense que la première ligne peut être d,L,x=input(),[],0;d+=....
Daniel
@Dopapp c'est exactement le même nombre d'octets
FlipTack
4

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(^)
Bleu
la source
4

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
mbomb007
la source
4

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£í˜
Emigna
la source
Ces sauts de ligne l'ont expliqué à merveille ... :-P
Stewie Griffin
@StewieGriffin: Ouais, j'ai changé le code et posté avant d'avoir réécrit l'explication: P
Emigna
4

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.

XavCo7
la source
Agréable! Je pense que vous pouvez faire return(b+","+c).split`,` pour sauver quelques octets à la fin.
ETHproductions
1
Mieux encore, vous pouvez utiliser c.unshiftau lieu de c.pushsupprimer le besoin d’inverser c. Après cela, j'ai 94 octets .
ETHproductions
3

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]
manonthemat
la source
1
Bienvenue, belle <s> première </ s> deuxième réponse, vérifiez ceci: codegolf.stackexchange.com/questions/363/…
FR
Merci beaucoup. Transformez cela en lambda, comme suggéré dans le lien que vous avez fourni, et enregistrez 5 octets de cette façon.
Manonthemat
2

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
Fataliser
la source
Est-ce que Brachylog c, lorsqu'il est exécuté en sens inverse, essaie nécessairement de se scinder en moins de listes en premier?
@ ais523 oui, c'est le cas.
Fataliser
1

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 .

Adam
la source
1

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.

nimi
la source
1

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!

Martin Ender
la source
1

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
Billywob
la source
60 octets utilisant diffinvplutôt que cumsum.
Giuseppe
1

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{:}]
rahnema1
la source
0

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

smls
la source
0

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)
Conor O'Brien
la source
0

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]
Noodle9
la source
Au lieu d'utiliser append, utiliser += data,la virgule de fin construit implicitement un tuple, qui est ensuite concaténé avec la liste, en ajoutant les données en tant que dernier élément de la liste. Dans ce contexte, faitesr+=l[i:j+1][::-1],
FlipTack
0

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

Sergei Patiakin
la source
0

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.

sonrad10
la source
0

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.

NikoNyrh
la source