Di APL, Anda dapat menulis fungsi diam-diam, yang disebut kereta . Cara mereka bekerja tidak relevan untuk tantangan ini. Berikut adalah berbagai cara mereka dapat dikelompokkan, menggunakan ⍴fungsinya:

⍴      -> ⍴
⍴⍴     -> ⍴⍴
⍴⍴⍴    -> ⍴⍴⍴
⍴⍴⍴⍴   -> ⍴(⍴⍴⍴)
⍴⍴⍴⍴⍴  -> ⍴⍴(⍴⍴⍴)
⍴⍴⍴⍴⍴⍴ -> ⍴(⍴⍴(⍴⍴⍴))
...

Urutannya tetap sama. Prosedurnya adalah selama ada lebih dari 3 fungsi, 3 fungsi terakhir dikelompokkan menjadi satu fungsi. Jika kita bertemu kereta bersarang, kita kurung itu terlebih dahulu, sebelum melanjutkan. Berikut adalah prosedur yang diterapkan untuk ⍴⍴⍴⍴⍴⍴:

Step 0: ⍴⍴⍴⍴⍴⍴
There are strictly more than 3 functions, repeat.
Step 1: ⍴⍴⍴(⍴⍴⍴)
There are strictly more than 3 functions, repeat.
Step 2: ⍴(⍴⍴(⍴⍴⍴))
There are 3 or less functions, we're done.

Berikut adalah prosedur yang sama diterapkan untuk ⍴⍴⍴(⍴⍴)⍴(⍴⍴⍴⍴(⍴⍴⍴))⍴⍴:

Step 0: ⍴⍴⍴(⍴⍴)⍴(⍴⍴⍴⍴(⍴⍴⍴))⍴⍴
There are strictly more than 3 functions, repeat.
We have met a nested train, applying procedure to that first:
  Step 0: ⍴⍴⍴⍴(⍴⍴⍴)
  There are strictly more than 3 functions, repeat.
  We have met a nested train, applying procedure to that first:
    Step 0: ⍴⍴⍴
    There are 3 or less functions, we're done.
  Step 1: ⍴⍴(⍴⍴(⍴⍴⍴))
  There are 3 or less functions, we're done.
Step 1: ⍴⍴⍴(⍴⍴)⍴((⍴⍴(⍴⍴(⍴⍴⍴)))⍴⍴)
There are strictly more than 3 functions, repeat.
We have met a nested train, applying procedure to that first:
  Step 0: ⍴⍴
  There are 3 or less functions, we're done.
Step 2: ⍴⍴⍴((⍴⍴)⍴((⍴⍴(⍴⍴(⍴⍴⍴)))⍴⍴))
There are strictly more than 3 functions, repeat.
Step 3: ⍴(⍴⍴((⍴⍴)⍴((⍴⍴(⍴⍴(⍴⍴⍴)))⍴⍴)))
There are 3 functions or less, we're done.

Memasukkan

Untuk tantangan ini, input akan disederhanakan. Ini artinya Anda dapat memilih 2 karakter berbeda untuk membuka dan menutup tanda kurung dan 1 karakter untuk fungsi, berbeda dari yang dipilih untuk tanda kurung. Karakter yang Anda pilih harus konsisten. Input tidak akan kosong, dan tidak akan mengandung tanda kurung tanpa konten (yaitu ()).

Keluaran

Sekali lagi, Anda dapat memilih 3 karakter yang berbeda, 2 untuk tanda kurung dan 1 untuk fungsi. Perhatikan bahwa mereka tidak harus sama dengan yang dipilih untuk input, tetapi mereka harus konsisten.

Aturan

• Jika ada tanda kurung yang hanya menyertakan satu fungsi di dalamnya dalam input, Anda harus menghapusnya di output. Output Anda mungkin tidak mengandung tanda kurung yang tidak dibutuhkan (yaitu, hanya melampirkan satu fungsi, atau melampirkan seluruh output).
• Anda tidak perlu menerapkan algoritme yang digunakan di sini, selama solusi Anda valid untuk tantangan ini.
• Input dan output adalah string dalam format yang dijelaskan di bagian Input dan Output. Input akan memiliki setidaknya satu karakter.
• Dilarang menggunakan celah standar .
• Ini kode-golf , jadi jawaban tersingkat menang. Namun, tidak akan ada jawaban yang diterima, karena ini adalah kompetisi per-bahasa, dan untuk mendorong penjawab dalam bahasa-bahasa di mana tugas ini akan menghasilkan kode yang lebih panjang dibandingkan dengan kode yang ditulis dalam bahasa lain.

Uji kasus

Karakter yang digunakan di sini adalah ()⍴, Anda harus menggantinya dengan karakter yang Anda pilih.

⍴                          -> ⍴
⍴                          -> ⍴
⍴⍴                         -> ⍴⍴
⍴⍴⍴                        -> ⍴⍴⍴
⍴⍴⍴⍴                       -> ⍴(⍴⍴⍴)
⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴⍴            -> ⍴⍴(⍴⍴(⍴⍴(⍴⍴(⍴⍴(⍴⍴(⍴⍴⍴))))))
⍴⍴⍴⍴⍴(⍴⍴⍴)⍴⍴(⍴(⍴⍴⍴)⍴⍴⍴)⍴⍴⍴ -> ⍴(⍴⍴(⍴⍴((⍴⍴⍴)⍴(⍴(⍴(⍴⍴⍴)(⍴⍴⍴))(⍴⍴⍴)))))
(⍴⍴⍴)(⍴⍴⍴)(⍴⍴⍴)            -> (⍴⍴⍴)(⍴⍴⍴)(⍴⍴⍴)
(⍴⍴⍴)(⍴⍴⍴)⍴⍴⍴              -> (⍴⍴⍴)(⍴⍴⍴)(⍴⍴⍴)
⍴⍴(⍴)⍴⍴                    -> ⍴⍴(⍴⍴⍴)
((⍴⍴))                     -> ⍴⍴
⍴⍴((⍴⍴))⍴⍴                 -> ⍴⍴((⍴⍴)⍴⍴)

_{Tantangan ini telah diposting di Sandbox. Jika Anda memiliki hak istimewa yang diperlukan, Anda dapat melihat posting sandbox di sini .}

APL (Dyalog Classic) , 71 68 65 63 byte

0{⍵≡⍕⍵:⍵⋄⍬≡⍵:'⍬'⋄1=≢⍵:⍺∇⊃⍵⋄3≥≢⍵:⍺⌽')(',⍣⍺∊1∇¨⍵⋄⍺∇¯3(↓,∘⊂1∇↑)⍵}⍎

Cobalah online!

Karakter saya memilih untuk I / O yang '(', ')', dan '⍬'.

Solusi ini sendiri merupakan kereta APL.

⍎mem-parsing input seolah-olah itu array bersarang - pohon dengan vektor numerik kosong ( ⍬) sebagai daun.

The dfn (yaitu lambda - { }) melintasi pohon secara rekursif dan mengubahnya menjadi string dengan tanda kurung yang benar. Argumen kiri ⍺mengontrol apakah tanda kurung harus ditambahkan ke level saat ini jika perlu.

DFN menangani kasus-kasus berikut berdasarkan argumen yang benar:

• jika sudah berupa string ( ⍵≡⍕⍵), kembalikan

• jika itu ⍬, kembalikan char'⍬'

• jika itu singleton, gali lebih dalam ( ∇adalah simbol untuk panggilan rekursif)

• jika panjangnya ≤3, kambuh untuk masing-masing item dan mengelilinginya ()jika perlu

• jika tidak, rekur ulang untuk 3-tail, tambahkan semua kecuali 3-tail, dan rekur ulang lagi

Python 2 , 224 208 204 byte

^{-16 byte terima kasih kepada Tn. Xcoder -4 byte terima kasih kepada ovs}

r=str.replace
p='p'
def c(l):
 while len(l)>3:l=l[:-3]+(l[-3:],)
 return l and map(c,l)or l
print r(r(r(r(r(`c(eval(r(r(r(input(),'(p)',p),p,'[],'),')','),')))`,'[]',p),*'[('),*'])'),' ',''),',','')[1:-1]

Cobalah online! atau Coba semua test case

Kode dapat dibagi dalam 3 langkah utama:
Mengubah input menjadi daftar bersarang dan mengganti (p)->p. Fungsi tunggal pakan diganti oleh daftar kosong.

eval(r(r(r(input(),'(p)',p),p,'[],'),')','),'))

Fungsi rekursif untuk menerapkan aturan "3 atau kurang" pada daftar saat ini dan menyebut dirinya di semua-sublists.

def c(l):
 while len(l)>3:l=l[:-3]+(l[-3:],)
 return l and map(c,l)or l

Banyak pengganti untuk memformat ke format output yang diinginkan

r(r(r(r(r(`c(...)`,'[]',p),*'[('),*'])'),' ',''),',','')[1:-1]

CJam , 56 byte

^{Mengalahkan APL!}

lW%~]]]{{_,{K_,({~}|}&}%{_,3>}{3/(aa\+:~}w}:K~~`1>W<W%S/

Cobalah online!

Ini bekerja (saya pikir) dan saya tidak tahu mengapa ...

Karakter input adalah ][Tuntuk ()⍴, dan karakter output adalah ][0untuk ()⍴(ya, ini berarti mereka terbalik dari apa yang Anda harapkan; misalnya, Anda mungkin masuk TTT]TT[T]TTTT]TTT[[TT).

Tinjauan Tingkat Tinggi

Program bekerja dengan input mundur, karena lebih nyaman. Untuk mem-parsing input, kami memanfaatkan parser CJam - membalikkan dan mengeksekusi input memberikan bentuk input parsing (mundur).

Kami kemudian mendefinisikan prosedur K. Kmelakukan sebagian besar pekerjaan untuk pengiriman kami, dan berfungsi sebagai berikut:

• Array input akan menjadi campuran dari nol dan sub-array nonempty. Identifikasi sub-array dan terapkan secara rekursif Kkepada mereka. Hasilnya harus berupa array lain, dan jika array ini hanya terdiri dari satu elemen saja, bongkar itu (ini menghilangkan tanda kurung yang berlebihan).
• Selama hasilnya memiliki lebih dari tiga elemen, kelompok tiga pertama (bukan tiga terakhir; ingat bahwa input sedang diproses mundur) ke dalam satu daftar.
• Kembalikan hasilnya.

Dengan menerapkan Kpada input, kita mendapatkan bentuk input yang dipasangkan dengan benar (satu-satunya hal yang perlu diperhatikan adalah bahwa kita benar-benar membungkus input dalam daftar tunggal dan membukanya setelah itu; alasan untuk ini adalah bahwa kita ingin potongan yang membongkar singletons untuk diterapkan pada program tingkat atas, dan bukan hanya sub-arraynya). Setelah itu, kami hanya menerapkan beberapa pemformatan minimal untuk mendapatkan hasil kami.

Beberapa penjelasan untuk bit golf

Golf yang paling saya banggakan gunakan ,untuk melakukan pemeriksaan antara bilangan bulat dan array.

• Jika top-of-stack adalah bilangan bulat n , ,menghasilkan kisaran [0..n) . Karena satu-satunya bilangan bulat yang akan kita temui adalah 0, ini selalu memberi kita daftar kosong [], yaitu falsey.
• Jika top-of-stack adalah sebuah array, ,perlu panjangnya. Karena semua array yang kita temui akan kosong, ini selalu memberi kita bilangan bulat positif, yang benar.

Golf lain yang mungkin menarik adalah metode yang saya gunakan untuk mengelompokkan tiga elemen pertama dari array; itu agak mirip dengan kiriman saya "Turing golf interpreter code language lengkap" . CJam tidak memiliki cara pendek untuk memecah array menjadi dua bagian (Anda dapat mencoba mengiris bagian pertama dan kemudian bagian lainnya sambil mempertahankan array asli dan indeks pada tumpukan, tetapi itu tidak berfungsi dengan baik) , jadi yang saya lakukan adalah menggunakan 3/, yang mengelompokkan array menjadi blok 3. Saya kemudian dapat menghapus elemen pertama (, membungkus array dua kali aa, dan kemudian menambahkan kembali ke awal daftar \+. Alasan kita membungkus array dua kali adalah kita harus melepas sebuah layer dengan :~, karena kita baru saja mengelompokkan array yang lain menjadi beberapa bagian juga.

JavaScript (ES6), 149 146 byte

i='a';f=s=>s==(s=s[R='replace'](/\((\w+)\)/,(q,t)=>(f[q=i+=0]=f(t),q)))&&s==(s=s[R](/(?!^)((a0+|p){3})$/,"($1)"))?s[R](/a0+/g,t=>`(${f[t]})`):f(s)

<textarea cols=80 id=I>ppp(pp)p(pppp(ppp))pp</textarea><br>
<button onclick=O.innerText=f(I.value)>Run</button><br>
<pre id=O></pre>

Penggunaannya ()p, meskipun Anda menggunakan huruf yang berbeda, Anda bisa mengubah pbagian akhir.