Tutti adorano le liste nidificate! Tuttavia, a volte è difficile creare un elenco nidificato. Devi decidere se vuoi annidarlo più in profondità, o se devi annidarlo in profondità. Quindi, per la tua sfida, devi "Autonest" un elenco. Per autonestare un elenco, confronta ogni coppia di elementi nell'elenco.

• Se il secondo elemento è più piccolo, separa i due elementi inserendo parentesi di chiusura e apertura tra loro, in questo modo:

    } {
  {2 , 1}
  

  Ad esempio, {2, 1}diventa {2}, {1}e {3, 2, 1}diventa{3}, {2}, {1}

• Se il secondo elemento è lo stesso, non modificare nulla. Ad esempio, {1, 1, 1}rimane lo stesso e {2, 1, 1, 1}diventerebbe {2}, {1, 1, 1}.

• Se il secondo oggetto è più grande, nidifica ogni oggetto successivo di un livello più in profondità. Ad esempio, {1, 2}sarebbe diventato {1, {2}}e {1, 2, 3}sarebbe diventato{1, {2, {3}}}

La sfida

È necessario scrivere un programma o una funzione che accetta un elenco di numeri e restituisce lo stesso elenco dopo essere stato autonestato. Prendi questo input nel formato dell'elenco nativo delle tue lingue (o l'alternativa più vicina) o come stringa. Non devi usare le parentesi graffe come ho fatto nei miei esempi. Puoi utilizzare qualsiasi tipo di parentesi più naturale nella tua lingua, purché sia ​​coerente. Puoi tranquillamente supporre che l'elenco conterrà solo numeri interi. Puoi anche supporre che l'elenco contenga almeno 2 numeri. Ecco alcuni esempi di 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}}}}}

Si applicano scappatoie standard e vince la risposta più breve in byte!

MATL , 48 43 byte

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

Questo utilizza parentesi quadre in input e output. L'output ha virgole senza spazi come separatori.

Si noti che l'output non verrebbe interpretato come un elenco nidificato in MATL. Lo farebbe in altre lingue e soddisfa le specifiche di output nella sfida.

Provalo online!

Spiegazione

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 byte

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

Esempio di utilizzo: ('{':).f $ [7,3,3,2,6,4]-> "{7},{3,3},{2,{6},{4}}".

Poiché Haskell non ha elenchi nidificati, restituisco il risultato come stringa. L'algoritmo di annidamento è semplice: a) stampa il numero, b) se il numero successivo è maggiore (minore, uguale), stampa ,{( },{, ,), c) effettua una chiamata ricorsiva con il resto dell'elenco, d) stampa }se il numero è meno di quello successivo, e) racchiudere tutto in {e }.

Python 3, 98 byte

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)

Esempio:

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

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 byte

Grazie a Giacomo per 7 byte!

#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'input viene preso attraverso gli argomenti della riga di comando e l'output viene fornito tramite stdout.

esempio di esecuzione:

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

Sfrutta il fatto che il numero dell'ultima parentesi è uno in più rispetto al numero della coppia adiacente che sta aumentando nell'array.

E non conosco l' ewoperatore prima che ho dovuto reimplementare.

L'input è un elenco separato da spazi delimitato da parentesi quadre.

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

Spiegazione

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

Scoprirò come farlo con un vero array nidificato invece di affidarmi a prettyprinting.

Finalmente, alla pari con la battuta risposta di MATL.

Retina, 71 70 byte

Liste sono separate da uno spazio, con parentesi graffe: {1 2 3}. I numeri negativi non sono supportati, quindi se questo è un problema, eliminerò semplicemente la mia risposta. Retina + numeri negativi = non ne vale la pena.

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

Provalo online

JavaScript (ES6), 73 byte

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

Spiegazione: Il caso di articoli uguali consecutivi è semplice; l'elemento viene appena aggiunto all'array più interno (qui rappresentato dalla mvariabile; nè l'array che contiene mcome ultimo elemento, mentre oè l'output). Nel caso di diversi articoli, l'elemento va sempre in un nuovo array più interno, l'unica differenza è se quell'array è un fratello o un figlio del precedente array più interno. Per maggiore golfiness ho impostato le matrici in modo che l'articolo iniziale conti come un oggetto uguale consecutivo.