每个人都喜欢嵌套列表！但是，有时很难创建嵌套列表。您必须决定是否要将其嵌套得更深，或者是否需要将其嵌套得更浅。因此，对于您的挑战，您必须“自动”列表。要自动列出列表，请比较列表中的每对项目。

• 如果第二个元素较小，则通过在两个元素之间插入闭合和打开括号来分隔这两个元素，如下所示：

    } {
  {2 , 1}
  

  例如，{2, 1}变为{2}, {1}，并且{3, 2, 1}变为{3}, {2}, {1}

• 如果第二项相同，则保持不变。例如，{1, 1, 1}保持不变，{2, 1, 1, 1}将变为{2}, {1, 1, 1}。

• 如果第二个项目较大，则将每个后续项目嵌套更深一层。例如，{1, 2}将成为{1, {2}}并且{1, 2, 3}将成为{1, {2, {3}}}

挑战

您必须编写一个接受数字列表的程序或函数，并在自动嵌套后返回相同的列表。以您的语言本机列表格式（或最接近的替代格式）或字符串形式输入此输入。您不必像我在示例中那样使用花括号。您可以使用语言中最自然的括号类型，只要这是一致的即可。您可以放心地假设列表将仅包含整数。您也可以假设列表中至少包含2个数字。这是一些示例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}}}}}

存在标准漏洞，最短的答案以字节为单位！

MATL，48 43字节

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

这在输入和输出中使用方括号。输出的逗号之间没有空格作为分隔符。

请注意，输出不会在MATL中解释为嵌套列表。它会以其他语言显示，并且满足挑战中的输出规范。

在线尝试！

说明

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个字节

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

用法示例：('{':).f $ [7,3,3,2,6,4]-> "{7},{3,3},{2,{6},{4}}"。

由于Haskell没有嵌套列表，因此我将结果作为字符串返回。嵌套算法很容易：a）打印数字，b）如果下一个数字更大（较小，等于），则打印,{（},{，,），c）与列表的其余部分进行递归调用，d）}如果数字为n，则打印小于下一个，e）将所有内容都包含在{和中}。

Python 3，98个字节

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)

例：

$ 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个字节

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字节

感谢Giacomo提供了7个字节！

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

输入是通过命令行参数获取的，而输出是通过stdout给出的。

样品运行：

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

利用了最后一个括号的数量比数组中增加的相邻对的数量多一个事实。

而且我不知道ew运算符，之后我不得不重新实现它。

输入是用方括号分隔的以空格分隔的列表。

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

说明

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

我将了解如何使用实际的嵌套数组而不是依靠prettyprinting来做到这一点。

最后，与被击败的MATL的回答相提并论。

视网膜，71 70字节

列表以大括号隔开，以空格分隔{1 2 3}。不支持负数，因此，如果有问题，我将删除答案。视网膜+负数=不值得。

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

在线尝试

JavaScript（ES6），73个字节

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

说明：连续相等项的情况很容易；该项只是添加到最里面的数组中（此处由m变量表示；n是包含m为最后一个元素的数组，而o输出是）。对于不同的项目，该项目始终位于新的最里面的数组中，唯一的区别是该数组是前一个最里面的数组的同级元素还是子元素。为了增加高尔夫球感，我设置了数组，以便将初始项计为连续的相等项。