Усі люблять вкладені списки! Однак іноді важко скласти вкладений список. Ви повинні вирішити, чи хочете ви гніздіти його глибше, чи потрібно гніздіти його дрібніше. Тож для вашого виклику ви повинні "Автоматизувати" список. Щоб опублікувати список, порівняйте кожну пару елементів у списку.

• Якщо другий елемент менший, відокремте два елементи, вставивши між ними кронштейни, що закриваються та відкриваються так:

    } {
  {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 немає вкладених списків, я повертаю результат у вигляді рядка. Алгоритм введення простий: а) номер друку, б) якщо наступне число більше (менше, рівне), надрукувати ,{( },{, ,), в) здійснити рекурсивний дзвінок з рештою списку, г) друкувати, }якщо число менше, ніж наступний, д) укладати все в {і }.

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 байт

Дякую Джакомо за 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.

Я дізнаюся, як це зробити за допомогою фактичного вкладеного масиву, а не покладатися на гарне друкування.

Нарешті, нарівні з побитою відповіддю 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вихід -). У випадку з різними елементами елемент завжди надходить у новий найпотужніший масив, різниця полягає лише в тому, чи цей масив є однорідним братом чи дочірньою частиною попереднього внутрішнього масиву. Для додаткової гольфності я налаштував масиви таким чином, щоб початковий предмет вважався послідовним рівним предметом.