Semua orang suka daftar bersarang! Namun, terkadang sulit untuk membuat daftar bersarang. Anda harus memutuskan apakah Anda ingin membuatnya lebih dalam, atau jika Anda perlu membuatnya lebih dangkal. Jadi untuk tantangan Anda, Anda harus "Autonest" daftar. Untuk autonest daftar, bandingkan setiap pasangan item dalam daftar.

• Jika item kedua lebih kecil, pisahkan kedua elemen dengan memasukkan tanda kurung tutup dan buka di antaranya, seperti ini:

    } {
  {2 , 1}
  

  Misalnya, {2, 1}menjadi {2}, {1}, dan {3, 2, 1}menjadi{3}, {2}, {1}

• Jika item kedua sama, maka tidak ada perubahan. Misalnya, {1, 1, 1}tetap sama, dan {2, 1, 1, 1}akan menjadi {2}, {1, 1, 1}.

• Jika item kedua lebih besar, maka sarang setiap item berikut satu tingkat lebih dalam. Misalnya, {1, 2}akan menjadi {1, {2}}dan {1, 2, 3}akan menjadi{1, {2, {3}}}

Tantangan

Anda harus menulis program atau fungsi yang memuat daftar angka, dan mengembalikan daftar yang sama setelah diautonisasi. Ambil input ini dalam format daftar asli bahasa Anda (atau alternatif terdekat) atau sebagai string. Anda tidak harus menggunakan kurung kurawal seperti yang saya lakukan dalam contoh saya. Anda dapat menggunakan jenis kurung mana saja yang paling alami dalam bahasa Anda, selama ini konsisten. Anda dapat dengan aman menganggap daftar hanya akan berisi bilangan bulat Anda juga dapat mengasumsikan daftar tersebut memiliki setidaknya 2 angka di dalamnya. Berikut ini beberapa contoh 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}}}}}

Celah standar berlaku, dan jawaban tersingkat dalam byte menang!

MATL , 48 43 byte

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

Ini menggunakan tanda kurung siku dalam input dan output. Output memiliki koma tanpa spasi sebagai pemisah.

Perhatikan bahwa output tidak akan ditafsirkan sebagai daftar bersarang di MATL. Itu akan dalam bahasa lain, dan itu memenuhi spesifikasi output dalam tantangan.

Cobalah online!

Penjelasan

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

Contoh penggunaan: ('{':).f $ [7,3,3,2,6,4]-> "{7},{3,3},{2,{6},{4}}".

Karena Haskell tidak memiliki daftar bersarang, saya mengembalikan hasilnya sebagai string. Algoritma bersarang mudah: a) nomor cetak, b) jika nomor berikutnya lebih besar (kurang, sama), cetak ,{( },{, ,), c) melakukan panggilan rekursif dengan sisa daftar, d) mencetak }jika nomor tersebut adalah kurang dari yang berikutnya, e) sertakan semuanya dalam {dan }.

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)

Contoh:

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

Terima kasih kepada Giacomo selama 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"}");}

Input diambil melalui argumen baris perintah dan output diberikan melalui stdout.

contoh dijalankan:

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

Mengeksploitasi fakta bahwa jumlah braket terakhir adalah satu lebih dari jumlah pasangan yang berdekatan yang meningkat dalam array.

Dan saya tidak tahu ewoperator sebelumnya bahwa saya harus mengimplementasikan ulang.

Inputnya adalah daftar yang dipisahkan oleh ruang, dibatasi oleh tanda kurung siku.

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

Penjelasan

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

Saya akan mencari tahu bagaimana melakukan ini dengan nested array yang sebenarnya daripada mengandalkan prettyprinting.

Akhirnya, setara dengan jawaban MATL yang dipukuli.

Retina, 71 70 byte

Daftar yang dipisahkan spasi, dengan kurung kurawal: {1 2 3}. Angka negatif tidak didukung, jadi jika itu masalah, saya hanya akan menghapus jawaban saya. Retina + angka negatif = tidak layak.

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

Cobalah online

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

Penjelasan: Kasus item yang sama berturut-turut mudah; item baru saja ditambahkan ke array paling dalam (di sini diwakili oleh mvariabel; nadalah array yang berisi msebagai elemen terakhirnya, sedangkan ooutputnya). Untuk kasus item yang berbeda, item selalu masuk dalam array terdalam baru, satu-satunya perbedaan adalah apakah array itu adalah saudara kandung atau anak dari array terdalam sebelumnya. Untuk golfiness ekstra saya mengatur array sehingga item awal dihitung sebagai item yang sama berturut-turut.