Tout le monde aime les listes imbriquées! Cependant, il est parfois difficile de créer une liste imbriquée. Vous devez décider si vous souhaitez l'imbriquer plus profondément ou si vous devez l'imbriquer moins profondément. Donc, pour votre défi, vous devez "Autonest" une liste. Pour tester automatiquement une liste, comparez chaque paire d'éléments de la liste.

• Si le deuxième élément est plus petit, séparez les deux éléments en insérant des crochets de fermeture et d'ouverture entre eux, comme ceci:

    } {
  {2 , 1}
  

  Par exemple, {2, 1}devient {2}, {1}et {3, 2, 1}devient{3}, {2}, {1}

• Si le deuxième élément est le même, ne changez rien. Par exemple, {1, 1, 1}reste le même et {2, 1, 1, 1}deviendrait {2}, {1, 1, 1}.

• Si le deuxième élément est plus grand, imbriquez chaque élément suivant d'un niveau plus profond. Par exemple, {1, 2}deviendrait {1, {2}}et {1, 2, 3}deviendrait{1, {2, {3}}}

Le défi

Vous devez écrire un programme ou une fonction qui accepte une liste de nombres et renvoie la même liste après avoir été auto-testé. Prenez cette entrée dans le format de liste native de votre langue (ou l'alternative la plus proche) ou sous forme de chaîne. Vous n'avez pas besoin d'utiliser des accolades comme je l'ai fait dans mes exemples. Vous pouvez utiliser le type de parenthèses le plus naturel dans votre langue, à condition que cela soit cohérent. Vous pouvez supposer en toute sécurité que la liste ne contiendra que des entiers. Vous pouvez également supposer que la liste contiendra au moins 2 chiffres. Voici quelques exemples d'E / S:

{1, 3, 2}                         -->   {1, {3}, {2}}
{1, 2, 3, 4, 5, 6}                -->   {1, {2, {3, {4, {5, {6}}}}}}
{6, 5, 4, 3, 2, 1}                -->   {6}, {5}, {4}, {3}, {2}, {1}
{7, 3, 3, 2, 6, 4}                -->   {7}, {3, 3}, {2, {6}, {4}}
{7, 3, 1, -8, 4, 8, 2, -9, 2, 8}  -->   {7}, {3}, {1}, {-8, {4, {8}, {2}, {-9, {2, {8}}}}}

Les failles standard s'appliquent et la réponse la plus courte en octets l'emporte!

MATL , 48 43 octets

YY_XKx"@K<?93]44@K-?91]@XKV]v93Gd0>sQY"h4L)

Cela utilise des crochets en entrée et en sortie. La sortie comporte des virgules sans espaces comme séparateurs.

Notez que la sortie ne sera pas interprétée comme une liste imbriquée dans MATL. Il le ferait dans d'autres langues, et il satisfait la spécification de sortie du défi.

Essayez-le en ligne!

Explication

YY_XKx   % Push -inf. Copy to clipboard K (represents previous input entry). Delete
"        % Take numerical array implicitly. For each entry:
  @K<    %   Is current entry less than the previous one?
  ?93]   %   If so, push 93 (ASCII for ']')
  44     %   Push 44 (ASCII for comma)
  @K-    %   Is current entry different from the previous one?
  ?91]   %   If so, push 91 (ASCII for '[')
  @XKV   %   Push current entry, copy into clipboard K, convert to string
]        % End for each
v        % Concat vertically all stack contents, converting to char
93       % Push 93 (ASCII for ']') (to be repeated the appropriate number of times)
Gd0>sQ   % Determine how many times the input increases, plus 1
Y"       % Repeat 93 that many times
h        % Concat horizontally with previous string. Gives a row array, i.e. string
4L)      % Remove first char, which is an unwanted comma. Display implicitly

Haskell, 96 octets

a#b|a<b=",{"|a>b="},{"|1<2=","
f(a:b:c)=show a++a#b++f(b:c)++['}'|a<b]
f[x]=show x++"}"
('{':).f

Exemple d'utilisation: ('{':).f $ [7,3,3,2,6,4]-> "{7},{3,3},{2,{6},{4}}".

Comme Haskell n'a pas de listes imbriquées, je renvoie le résultat sous forme de chaîne. L'algorithme d'imbrication est simple: a) imprimer le numéro, b) si le nombre suivant est supérieur (inférieur, égal), imprimer ,{( },{, ,), c) effectuer un appel récursif avec le reste de la liste, d) imprimer }si le numéro est moins que le suivant, e) enfermez tout dans {et }.

Python 3, 98 octets

p,*i=eval(input())
c=[p]
a=b=[c]
for x in i:
 if x>p:b=c
 if x!=p:c=[];b+=[c]
 c+=[x];p=x
print(a)

Exemple:

$ python3 autonest.py <<< "[7, 3, 1, -8, 4, 8, 2, -9, 2, 8]"
[[7], [3], [1], [-8, [4, [8], [2], [-9, [2, [8]]]]]]

Java 8 197 187 193 192 octets

String a(int[]b){int l=b.length,d=1,i=0;String c="{";for(;i<l-1;i++)if(b[i]>b[i+1])c+=b[i]+"},{";else if(b[i]<b[i+1]){d++;c+=b[i]+",{";}else c+=b[i]+",";c+=b[l-1];while(d-->0)c+="}";return c;}

C, 145 138 octets

Merci à Giacomo pour 7 octets!

#define P printf(
n;main(c,v,p,t)char**v;{p=-101;for(v++;*v;v++){t=atoi(*v);if(t<p)P"}{");if(t>p)P"{",n++);P"%d ",p=t);}for(;n--;)P"}");}

L'entrée est prise via des arguments de ligne de commande et la sortie est donnée via stdout.

échantillon:

$ ./autonest 7 3 1 -8 4 8 2 -9 2 8
{7 }{3 }{1 }{-8 {4 {8 }{2 }{-9 {2 {8 }}}}}

CJam, 51 49 48 46 octets

Exploite le fait que le nombre de dernière parenthèse est un de plus que le nombre de paires adjacentes qui augmente dans le tableau.

Et je ne connaissais pas d' ewopérateur avant d'avoir dû réimplémenter.

L'entrée est une liste séparée par des espaces délimitée par des crochets.

'[q~_W=\2ew_{~\_@-g)["["S"]["]=}%@@{~>M']?}%']

Explication

'[q~_W=\2ew_{~\_@-g)["["S"]["]=}%@@{~>M']?}%']
'[                                             e# Opening bracket
  q~                                           e# Read the input
    _W=\2ew                                    e# Save the last item and turn array into array of pair of next item and the item itself.
            _                                  e# We need two copies of that item                                       
             {~\_@-g)["["S"]["]=}%             e# Build the "body" that consist of the item and the suitable delimiter, space if equal, opening brace if the first item is the smallest, otherwise, closing bracket and opening bracket.
                                  @@           e# Put in the last item. (It was omitted in previous phase)
                                    {~<']""?}% e# Create the closing bracket as many as the number of increasing adjacent pair
                                               '] e# And one more bracket.

Je vais découvrir comment faire cela avec un tableau imbriqué réel au lieu de compter sur prettyprinting.

Enfin, à égalité avec la réponse de MATL battu.

Rétine, 71 70 octets

Les listes sont séparées par des espaces, avec des accolades: {1 2 3}. Les nombres négatifs ne sont pas pris en charge, donc si c'est un problème, je vais juste supprimer ma réponse. Rétine + nombres négatifs = n'en vaut pas la peine.

\d+
$*
+`\b(1+) (1+\1\b.*)
$1 {$2}
+`\b(1(1+)1*) (\2)\b
$1} {$2
1+
$.0

Essayez-le en ligne

JavaScript (ES6), 73 octets

a=>a.map(r=>l-r?(n=l<r?m:n).push(m=[l=r]):m.push(l),l=a[0],o=n=[m=[]])&&o

Explication: Le cas d'éléments égaux consécutifs est facile; l'élément est simplement ajouté au tableau le plus interne (ici représenté par la mvariable; nest le tableau qui contient mcomme dernier élément, tandis que ola sortie est). Dans le cas de différents éléments, l'élément va toujours dans un nouveau tableau le plus à l'intérieur, la seule différence étant que ce tableau soit un frère ou un enfant du tableau le plus à l'intérieur précédent. Pour plus de golf, j'ai configuré les tableaux de sorte que l'élément initial compte comme un élément égal consécutif.