Jeder liebt verschachtelte Listen! Manchmal ist es jedoch schwierig, eine verschachtelte Liste zu erstellen. Sie müssen sich entscheiden, ob Sie es tiefer nisten möchten oder ob Sie es flacher nisten möchten. Für Ihre Herausforderung müssen Sie also eine Liste "autonestieren". Vergleichen Sie jedes Elementpaar in der Liste, um eine Liste automatisch zu überprüfen.

• Wenn das zweite Element kleiner ist, trennen Sie die beiden Elemente, indem Sie zwischen ihnen schließende und öffnende Klammern einfügen:

    } {
  {2 , 1}
  

  Zum Beispiel {2, 1}wird {2}, {1}und {3, 2, 1}wird{3}, {2}, {1}

• Wenn das zweite Element identisch ist, ändern Sie nichts. Bleibt zum Beispiel {1, 1, 1}gleich und {2, 1, 1, 1}würde es werden {2}, {1, 1, 1}.

• Wenn der zweite Gegenstand größer ist, verschachteln Sie jeden folgenden Gegenstand eine Ebene tiefer. Zum Beispiel {1, 2}würde {1, {2}}und {1, 2, 3}würde werden{1, {2, {3}}}

Die Herausforderung

Sie müssen ein Programm oder eine Funktion schreiben, die eine Liste von Zahlen aufnimmt und nach der automatischen Überprüfung dieselbe Liste zurückgibt. Übernehmen Sie diese Eingabe im systemeigenen Listenformat (oder der nächstgelegenen Alternative) oder als Zeichenfolge. Sie müssen keine geschweiften Klammern verwenden, wie ich es in meinen Beispielen getan habe. Sie können jede Art von Klammern verwenden, die in Ihrer Sprache am natürlichsten ist, sofern dies konsistent ist. Sie können davon ausgehen, dass die Liste nur Ganzzahlen enthält. Sie können auch davon ausgehen, dass die Liste mindestens zwei Ziffern enthält. Hier ist ein Beispiel für 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}}}}}

Es gelten Standardlücken und die kürzeste Antwort in Bytes gewinnt!

MATL , 48 43 Bytes

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

Dies verwendet eckige Klammern bei der Eingabe und Ausgabe. Die Ausgabe enthält Kommas ohne Leerzeichen als Trennzeichen.

Beachten Sie, dass die Ausgabe in MATL nicht als verschachtelte Liste interpretiert wird. Es würde in anderen Sprachen und es erfüllt die Ausgabespezifikation in der Herausforderung.

Probieren Sie es online!

Erläuterung

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

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

Da Haskell keine verschachtelten Listen hat, gebe ich das Ergebnis als Zeichenfolge zurück. Der Verschachtelungsalgorithmus ist einfach: a) Nummer drucken, b) wenn die nächste Nummer größer (kleiner, gleich) ist, print ,{( },{, ,), c) einen rekursiven Aufruf mit dem Rest der Liste durchführen, d) }wenn die Nummer größer (gleich) ist, drucken weniger als die nächste, e) alles in {und einschließen }.

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)

Beispiel:

$ 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

Danke an Giacomo für 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"}");}

Die Eingabe erfolgt über Befehlszeilenargumente und die Ausgabe erfolgt über stdout.

Probelauf:

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

Nutzt die Tatsache aus, dass die Anzahl der letzten Klammern um eins höher ist als die Anzahl der benachbarten Paare, die im Array zunehmen.

Und ich kenne den ewOperator nicht, bevor ich ihn erneut implementieren musste.

Die Eingabe ist eine durch Leerzeichen getrennte Liste, die durch eckige Klammern getrennt ist.

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

Erläuterung

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

Ich werde herausfinden, wie dies mit tatsächlich verschachtelten Arrays gemacht werden kann, anstatt auf Prettyprinting zu vertrauen.

Schließlich auf Augenhöhe mit geschlagener Antwort des MATL.

Retina, 71 Bytes

Die Listen werden mit Leerzeichen getrennt, mit geschweiften Klammern: {1 2 3}. Negative Zahlen werden nicht unterstützt. Wenn dies ein Problem ist, lösche ich einfach meine Antwort. Netzhaut + negative Zahlen = nicht wert.

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

Probieren Sie es online aus

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

Erläuterung: Der Fall von aufeinanderfolgenden gleichen Elementen ist einfach. Das Element wird gerade zum innersten Array hinzugefügt (hier durch die mVariable dargestellt; nist das Array, das mals letztes Element enthält, während oes die Ausgabe ist). Bei verschiedenen Elementen wird das Element immer in einem neuen innersten Array abgelegt. Der einzige Unterschied besteht darin, ob dieses Array ein Geschwister oder ein untergeordnetes Element des vorherigen innersten Arrays ist. Für zusätzliche Aufmerksamkeit habe ich die Arrays so eingerichtet, dass der ursprüngliche Gegenstand als aufeinanderfolgender gleicher Gegenstand zählt.