Wszyscy uwielbiają zagnieżdżone listy! Czasami jednak trudno jest utworzyć listę zagnieżdżoną. Musisz zdecydować, czy chcesz zagnieżdżać go głębiej, czy też chcesz zagnieżdżać go płytko. Aby podjąć wyzwanie, musisz „Autonestować” listę. Aby automatycznie przetestować listę, porównaj każdą parę elementów na liście.

• Jeśli drugi element jest mniejszy, rozdziel dwa elementy, wstawiając między nimi klamry zamykające i otwierające:

    } {
  {2 , 1}
  

  Na przykład {2, 1}staje się {2}, {1}i {3, 2, 1}staje{3}, {2}, {1}

• Jeśli drugi element jest taki sam, nic nie zmieniaj. Na przykład {1, 1, 1}pozostaje taki sam i {2, 1, 1, 1}stałby się {2}, {1, 1, 1}.

• Jeśli drugi element jest większy, zagnieżdż każdy następny element o jeden poziom głębiej. Na przykład {1, 2}stałby się {1, {2}}i {1, 2, 3}stałby się{1, {2, {3}}}

Wyzwanie

Musisz napisać program lub funkcję, która pobiera listę liczb i zwraca tę samą listę po automatycznym przetestowaniu. Weź to wejście w formacie natywnej listy języków (lub najbliższej alternatywy) lub jako ciąg. Nie musisz używać nawiasów klamrowych, jak ja w moich przykładach. Możesz użyć dowolnego rodzaju nawiasów, który jest najbardziej naturalny w twoim języku, o ile jest to spójne. Możesz bezpiecznie założyć, że lista będzie zawierać tylko liczby całkowite. Możesz również założyć, że lista będzie zawierać co najmniej 2 liczby. Oto kilka przykładowych 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}}}}}

Obowiązują standardowe luki, a najkrótsza odpowiedź w bajtach wygrywa!

MATL , 48 43 bajtów

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

Wykorzystuje nawiasy kwadratowe na wejściu i wyjściu. Dane wyjściowe mają przecinki bez spacji jako separatory.

Zauważ, że dane wyjściowe nie będą interpretowane jako lista zagnieżdżona w MATL. Byłoby to w innych językach i spełnia specyfikację danych wyjściowych w wyzwaniu.

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Przykład użycia: ('{':).f $ [7,3,3,2,6,4]-> "{7},{3,3},{2,{6},{4}}".

Ponieważ Haskell nie ma zagnieżdżonych list, zwracam wynik jako ciąg. Algorytm zagnieżdżania jest łatwy: a) wydrukuj numer, b) jeśli następny numer jest większy (mniejszy, równy), wydrukuj ,{( },{, ,), c) wykonaj rekurencyjne połączenie z resztą listy, d) wydrukuj, }jeśli numer jest mniej niż następny, e) zamknij wszystko w {i }.

Python 3, 98 bajtów

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)

Przykład:

$ 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 bajtów

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 bajtów

Dzięki Giacomo za 7 bajtów!

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

Dane wejściowe są pobierane za pomocą argumentów wiersza poleceń, a dane wyjściowe są podawane przez stdout.

przykładowy przebieg:

$ ./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 bajtów

Wykorzystuje fakt, że liczba ostatniego nawiasu jest o jeden większa niż liczba sąsiedniej pary, która rośnie w szyku.

I nie znam ewoperatora wcześniej, że musiałem ponownie wdrożyć.

Dane wejściowe to lista rozdzielona spacjami, oddzielona nawiasami kwadratowymi.

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

Wyjaśnienie

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

Dowiedzę się, jak to zrobić z rzeczywistą tablicą zagnieżdżoną, zamiast polegać na ładnym drukowaniu.

Wreszcie, na równi z pobitą odpowiedzią MATL.

Siatkówka, 71 70 bajtów

Listy są spacjami, z klamrami: {1 2 3}. Liczby ujemne nie są obsługiwane, więc jeśli to problem, po prostu usunę moją odpowiedź. Siatkówka + liczby ujemne = nie warto.

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

Wypróbuj online

JavaScript (ES6), 73 bajty

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

Objaśnienie: Przypadek kolejnych równych elementów jest łatwy; element jest właśnie dodawany do najbardziej wewnętrznej tablicy (tutaj reprezentowanej przez mzmienną; njest to tablica, która zawiera mjako ostatni element, a odane wyjściowe). W przypadku różnych przedmiotów element zawsze trafia do nowej najbardziej wewnętrznej tablicy, jedyną różnicą jest to, czy ta tablica jest rodzeństwem, czy dzieckiem z poprzedniej najbardziej wewnętrznej tablicy. Dla dodatkowej gry w golfa ustawiłem tablice, aby początkowy element liczył się jako kolejny równy element.