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

• Если второй элемент меньше, разделите два элемента, вставив между ними закрывающие и открывающие скобки, например:

    } {
  {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]]]]]]

Ява 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"}");}

Ввод осуществляется через аргументы командной строки, а вывод - через стандартный вывод.

образец прогона:

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

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