Mọi người đều thích danh sách lồng nhau! Tuy nhiên, đôi khi thật khó để tạo một danh sách lồng nhau. Bạn phải quyết định nếu bạn muốn lồng nó sâu hơn, hoặc nếu bạn cần lồng nó nông hơn. Vì vậy, đối với thử thách của bạn, bạn phải "Tự động" một danh sách. Để tự động xác định danh sách, hãy so sánh mọi cặp mục trong danh sách.

• Nếu mục thứ hai nhỏ hơn, hãy tách hai phần tử bằng cách chèn dấu đóng và mở giữa chúng, như sau:

    } {
  {2 , 1}
  

  Ví dụ, {2, 1}trở thành {2}, {1}và {3, 2, 1}trở thành{3}, {2}, {1}

• Nếu mục thứ hai là như nhau, thì không thay đổi gì. Ví dụ, {1, 1, 1}giữ nguyên, và {2, 1, 1, 1}sẽ trở thành {2}, {1, 1, 1}.

• Nếu mục thứ hai lớn hơn, thì hãy lồng mọi mục sau sâu hơn một cấp. Ví dụ, {1, 2}sẽ trở thành {1, {2}}và {1, 2, 3}sẽ trở thành{1, {2, {3}}}

Các thách thức

Bạn phải viết một chương trình hoặc hàm nhận danh sách các số và trả về cùng một danh sách sau khi được tự động xác định. Lấy đầu vào này ở định dạng danh sách gốc ngôn ngữ của bạn (hoặc thay thế gần nhất) hoặc dưới dạng chuỗi. Bạn không phải sử dụng dấu ngoặc nhọn như tôi đã làm trong ví dụ của mình. Bạn có thể sử dụng bất kỳ loại dấu ngoặc nào là tự nhiên nhất trong ngôn ngữ của bạn, miễn là điều này phù hợp. Bạn có thể giả định rằng danh sách sẽ chỉ chứa số nguyên. Bạn cũng có thể giả sử danh sách sẽ có ít nhất 2 số trong đó. Đây là một số mẫu 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}}}}}

Các sơ hở tiêu chuẩn được áp dụng và câu trả lời ngắn nhất tính theo byte sẽ thắng!

MATL , 48 43 byte

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

Điều này sử dụng dấu ngoặc vuông trong đầu vào và đầu ra. Đầu ra có dấu phẩy không có khoảng trắng làm dấu phân cách.

Lưu ý rằng đầu ra sẽ không được hiểu là danh sách lồng nhau trong MATL. Nó sẽ trong các ngôn ngữ khác, và nó đáp ứng các đặc điểm kỹ thuật đầu ra trong thử thách.

Hãy thử trực tuyến!

Giải trình

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

Ví dụ sử dụng: ('{':).f $ [7,3,3,2,6,4]-> "{7},{3,3},{2,{6},{4}}".

Vì Haskell không có danh sách lồng nhau, tôi trả về kết quả dưới dạng chuỗi. Thuật toán lồng nhau rất dễ dàng: a) số in, b) nếu số tiếp theo lớn hơn (ít hơn, bằng), in ,{( },{, ,), c) thực hiện cuộc gọi đệ quy với phần còn lại của danh sách, d) in }nếu số đó là ít hơn cái tiếp theo, e) bao gồm mọi thứ trong {và }.

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)

Thí dụ:

$ 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

Cảm ơn Giacomo cho 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"}");}

Đầu vào được thực hiện thông qua các đối số dòng lệnh và đầu ra được đưa ra mặc dù thiết bị xuất chuẩn.

chạy mẫu:

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

Khai thác thực tế là số lượng dấu ngoặc cuối cùng nhiều hơn một số cặp liền kề đang tăng dần trong mảng.

Và tôi không biết ewtoán tử trước đó mà tôi phải thực hiện lại.

Đầu vào là không gian được phân tách danh sách được phân tách bằng dấu ngoặc vuông.

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

Giải trình

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

Tôi sẽ tìm hiểu làm thế nào để làm điều này với mảng lồng nhau thực tế thay vì dựa vào việc in đẹp.

Cuối cùng, ngang bằng với câu trả lời của MATL.

Võng mạc, 71 70 byte

Danh sách được phân tách không gian, với dấu ngoặc nhọn : {1 2 3}. Số âm không được hỗ trợ, vì vậy nếu đó là vấn đề, tôi sẽ xóa câu trả lời của mình. Retina + số âm = không đáng.

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

Dùng thử trực tuyến

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

Giải thích: Trường hợp các mục bằng nhau liên tiếp là dễ dàng; mục này chỉ được thêm vào mảng trong cùng (ở đây được đại diện bởi mbiến; nlà mảng chứa mphần tử cuối cùng của nó, trong khi olà đầu ra). Đối với trường hợp của các mục khác nhau, mục này luôn nằm trong một mảng trong cùng mới, sự khác biệt duy nhất là liệu mảng đó là anh chị em hay con của mảng trong cùng trước đó. Để có thêm tính gôn, tôi thiết lập các mảng sao cho mục ban đầu được tính là một mục bằng nhau liên tiếp.