Todo mundo adora listas aninhadas! No entanto, às vezes é difícil fazer uma lista aninhada. Você precisa decidir se deseja aninhar mais fundo ou se precisa aninhar menos. Portanto, para o seu desafio, você deve "Autonestar" uma lista. Para autonestear uma lista, compare todos os itens da lista.

• Se o segundo item for menor, separe os dois elementos inserindo os colchetes de fechamento e abertura entre eles, assim:

    } {
  {2 , 1}
  

  Por exemplo, {2, 1}torna {2}, {1}- {3, 2, 1}se e torna - se{3}, {2}, {1}

• Se o segundo item for o mesmo, não altere nada. Por exemplo, {1, 1, 1}permanece o mesmo e {2, 1, 1, 1}se tornaria {2}, {1, 1, 1}.

• Se o segundo item for maior, aninhe cada item a seguir um nível mais profundo. Por exemplo, {1, 2}se tornaria {1, {2}}e {1, 2, 3}se tornaria{1, {2, {3}}}

O desafio

Você deve escrever um programa ou função que inclua uma lista de números e retorne a mesma lista após ser testado automaticamente. Pegue essa entrada no formato de lista nativa do seu idioma (ou a alternativa mais próxima) ou como uma string. Você não precisa usar chaves como eu fiz nos meus exemplos. Você pode usar o tipo de colchete mais natural no seu idioma, desde que consistente. Você pode assumir com segurança que a lista conterá apenas números inteiros. Você também pode assumir que a lista terá pelo menos 2 números. Aqui está um exemplo de IO:

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

As brechas padrão se aplicam e a resposta mais curta em bytes vence!

MATL , 48 43 bytes

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

Isso usa colchetes na entrada e na saída. A saída possui vírgulas sem espaços como separadores.

Observe que a saída não seria interpretada como uma lista aninhada no MATL. Seria em outros idiomas e satisfaz a especificação de saída no desafio.

Experimente online!

Explicação

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 bytes

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

Exemplo de uso: ('{':).f $ [7,3,3,2,6,4]-> "{7},{3,3},{2,{6},{4}}".

Como Haskell não possui listas aninhadas, retorno o resultado como uma sequência. O algoritmo de aninhamento é fácil: a) imprima o número, b) se o próximo número for maior (menor, igual), imprima ,{( },{, ,), c) faça uma chamada recursiva com o restante da lista; d) imprima }se o número for menor que o próximo, e) coloque tudo em {e }.

Python 3, 98 bytes

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)

Exemplo:

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

Java 8197187193 192 bytes

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 bytes

Obrigado a Giacomo por 7 bytes!

#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"}");}

A entrada é obtida através dos argumentos da linha de comando e a saída é fornecida pelo stdout.

amostra de execução:

$ ./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 bytes

Explora o fato de que o número do último colchete é um a mais do que o número de pares adjacentes que está aumentando na matriz.

E eu não conheço ewoperador antes que precisei reimplementar.

A entrada é uma lista separada por espaços delimitada por colchetes.

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

Explicação

'[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.

Vou descobrir como fazer isso com uma matriz aninhada real, em vez de depender da prettyprinting.

Finalmente, a par da resposta do MATL batido.

Retina, 71 70 bytes

As listas são espaço separado, com chavetas: {1 2 3}. Números negativos não são suportados, por isso, se isso for um problema, excluirei minha resposta. Retina + números negativos = não vale a pena.

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

Experimente online

JavaScript (ES6), 73 bytes

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

Explicação: O caso de itens iguais consecutivos é fácil; o item é adicionado apenas à matriz mais interna (aqui representada pela mvariável; né a matriz que contém mcomo seu último elemento, enquanto oé a saída). Para o caso de itens diferentes, o item sempre entra em uma nova matriz mais interna, a única diferença é se essa matriz é um irmão ou filho da matriz mais interna anterior. Para maior golfidade, configurei as matrizes para que o item inicial conte como um item igual consecutivo.