¡Todos aman las listas anidadas! Sin embargo, a veces es difícil hacer una lista anidada. Tienes que decidir si quieres anidar más profundo o si necesitas anidar menos profundo. Entonces, para su desafío, debe "Autonest" una lista. Para autonestizar una lista, compare cada par de elementos en la lista.

• Si el segundo elemento es más pequeño, separe los dos elementos insertando corchetes de cierre y apertura entre ellos, de esta manera:

    } {
  {2 , 1}
  

  Por ejemplo, se {2, 1}convierte {2}, {1}y se {3, 2, 1}convierte en{3}, {2}, {1}

• Si el segundo elemento es el mismo, no cambie nada. Por ejemplo, {1, 1, 1}permanece igual y {2, 1, 1, 1}se volvería {2}, {1, 1, 1}.

• Si el segundo elemento es más grande, anide cada elemento siguiente un nivel más profundo. Por ejemplo, {1, 2}se convertiría {1, {2}}y {1, 2, 3}se convertiría en{1, {2, {3}}}

El reto

Debe escribir un programa o función que tome una lista de números y devuelva la misma lista después de que se haya autoajustado. Tome esta entrada en el formato de lista nativa de su idioma (o la alternativa más cercana) o como una cadena. No tiene que usar llaves como lo hice en mis ejemplos. Puede usar cualquier tipo de paréntesis que sea más natural en su idioma, siempre que sea coherente. Puede asumir con seguridad que la lista solo contendrá enteros. También puede suponer que la lista tendrá al menos 2 números. Aquí hay una muestra 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}}}}}

Se aplican las lagunas estándar, ¡y gana la respuesta más corta en bytes!

MATL , 48 43 bytes

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

Esto usa corchetes en entrada y salida. La salida tiene comas sin espacios como separadores.

Tenga en cuenta que la salida no se interpretará como una lista anidada en MATL. Lo haría en otros idiomas, y satisface la especificación de salida en el desafío.

Pruébalo en línea!

Explicación

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

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

Como Haskell no tiene listas anidadas, devuelvo el resultado como una cadena. El algoritmo de anidación es fácil: a) imprimir número, b) si el siguiente número es mayor (menor, igual), imprimir ,{( },{, ,), c) hacer una llamada recursiva con el resto de la lista, d) imprimir }si el número es menos que el siguiente, e) incluir todo en {y }.

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)

Ejemplo:

$ 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 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

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

La entrada se toma a través de argumentos de línea de comando y la salida se da a través de stdout.

ejecución de muestra:

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

Explota el hecho de que el número del último paréntesis es uno más que el número de pares adyacentes que aumenta en matriz.

Y no se ew operador antes que tuve que reimplementar.

La entrada es una lista separada por espacios delimitada por corchetes.

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

Explicación

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

Descubriré cómo hacer esto con una matriz anidada real en lugar de confiar en prettyprinting.

Finalmente, a la par con la respuesta vencida de MATL.

Retina, 71 70 bytes

Las listas se espacio separado, con llaves: {1 2 3}. Los números negativos no son compatibles, por lo que si eso es un problema, simplemente eliminaré mi respuesta. Retina + números negativos = no vale la pena.

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

Pruébalo en línea

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

Explicación: El caso de elementos iguales consecutivos es fácil; el elemento se acaba de agregar a la matriz más interna (aquí representada por la mvariable; nes la matriz que contiene mcomo último elemento, mientras que oes la salida). Para el caso de diferentes elementos, el elemento siempre va en una nueva matriz más interna, la única diferencia es si esa matriz es un hermano o un hijo de la matriz más interna anterior. Para golfiness adicional configuré los arreglos para que el elemento inicial cuente como un elemento igual consecutivo.