Dalam tantangan ini, Anda harus menguraikan daftar daftar, ke dalam format daftar yang lebih sederhana.

Tantangan ini didasarkan pada parser sadflak saya. Dalam parser sadflak saya, semua () dihapus, diganti dengan jumlah () pada awal daftar, untuk membuat program berjalan lebih cepat.

Untuk menguraikan Sad-List, Anda harus melakukan ini (implementasi python, menggunakan tuple tuple):

def sadlistfunc(list):
    new-sadlist = [0]
    for i in list:
        if i == ():
            new-sadlist[0]+=1
        else:
            new-sadlist.append(sadlistfunc(i))

Ini adalah fungsi rekursif. Untuk daftar, mulailah daftar baru, mulai dengan jumlah () dari input daftar, kemudian daftar ini adalah versi sedih-daftar setiap daftar yang bukan () dari input daftar, secara berurutan. kembalikan daftar.

Memasukkan:

Anda dapat mengambil input dalam beberapa format berbeda:

• Anda dapat menganggapnya sebagai daftar
• Anda bisa menganggapnya sebagai tuple
• Anda dapat menganggapnya sebagai string

jika Anda menganggapnya sebagai string, Anda harus menggunakan beberapa tanda kurung, seperti yang ditampilkan di brain-flak. Anda tidak boleh menggunakan karakter 1 dan 2

masuk akal saja

Input akan selalu berada di dalam satu daftar, tetapi program Anda dapat mengasumsikan lapisan daftar implisit di luar input, yaitu () () () = (() () () ()), atau mungkin memilih untuk tidak melakukannya. Contohnya akan dengan daftar luar eksplisit

keluaran:

mungkin daftar atau tupel atau string, atau apa pun. Anda dapat menggunakan format output apa pun yang masuk akal, seperti konsensus meta.

Contoh:

(()()()) = [3]
(((()))) = [0,[0,[1]]]
((())()(())) = [1, [1], [1]]
() = invalid input, if the outside bracket is explicit.
((((())())())(())()) = [1, [1, [1, [1]]], [1]]

perhatikan bahwa input tidak ketat. input ini bisa berupa:

[[],[],[]]
[[[[]]]]
[[[]],[],[[]]]
[]
[[[[[]],[]],[]],[[]],[]]

atau format lain yang masuk akal

menjelaskan test case:

(()()((())())())

untuk "membuat sedih" ini, pertama kita hitung jumlah ()

 ()()        ()
(    ((())())  )

3. lalu kita hapus ini, dan tambahkan 3 di awal

(3,((())()))

ada satu daftar dalam daftar ini. kami sedih ini

((())())

berapa banyak ()?

     ()
((())  )

1. kami menghapus dan menambahkan 1 di awal

(1,(()))

ini memiliki satu daftar di dalamnya

(())

menghitung

 ()
(  )

hapus dan tambahkan hitungan

(1)

lalu kita masukkan ini kembali ke daftar

(1,(1))

lalu kita masukkan ini kembali ke daftar

(3,(1,(1)))

selesai

Ini kode-golf , jadi lebih pendek lebih baik

Pyth , 13 byte

L+]/bYyM-b]Yy

Suite uji .

Bagaimana itu bekerja

L+]/bYyM-b]Yy
L               define a function y with argument b:
   /bY              list 1: count how many [] can be found in b
  ]                         wrap into singleton
        -b]Y        list 2: filter out [] from b
      yM                    apply y (this function) to each
 +                  concatenate the two lists above
            y   apply y to the input

CommonLisp, 49 byte

(defun s(l)(cons(count()l)(mapcar's(remove()l))))

mengambil input sebagai daftar daftar.

Cobalah online!

Brachylog , 21 byte

;[[]]x{↰₀}ᵐA&{∋∅}ᶜg,A

Cobalah online!

Mathematica, 42 byte

{#~Count~{0},##&@@#~DeleteCases~{0}}&//@#&

Menghindari rekursi eksplisit dengan menggunakan //@( MapAll) yang memetakan fungsi di atas setiap node dalam pohon. Ini juga berarti bahwa fungsi dijalankan dari daun ke atas. Namun, itu juga akan diterapkan {}yang bisa berubah dalam {0}proses. Itu sebabnya kami menghitung dan menghapus {0}saja {}.

Retina , 42 byte

+`(({()|}(?<-3>))*)(?!\3){}
1$1
{(1*)
{$.1

Cobalah online!

Clojure, 59 byte

(fn f[i](conj(map f(remove #{[]}i))(count(filter #{[]}i))))

Tidak jauh berbeda dengan jawaban CommonLisp . Its countdan removetampaknya menerima konstruk sedikit lebih bagus, di sini saya harus menggunakan set.

Sebenarnya , 12 byte

;[]@c@;░Q£Mo

Cobalah online!

Mengambil input sebagai daftar kurung kotak yang dipisahkan koma dengan tanda kurung luar yang eksplisit.

Penjelasan:

;[]@c@;░Q£Mo
;[]@c         count the number of empty lists
     @;░      filter out empty lists
        Q£Mo  recurse with filtered list and append result

Python 2 , 69 46 45 byte

f=lambda l:[l.count([])]+map(f,filter(len,l))

Cobalah online!

Jelly , 10 byte

Tị߀;@ċ“”$

Cobalah online!

Mengambil input sebagai daftar daftar daftar ...

Tentu saja menggunakan algoritma yang digunakan jawaban lain. ;)

Haskell , 102 byte

data L=I Int|T[L]deriving Show
(I n:r)#m=r#(n+m)
(x:r)#m=x:r#m
_#m=[I m]
f(T[])=I 1
f(T t)=T$map f t#0

Cobalah online!

Karena Haskell diketik dengan ketat, tidak ada daftar yang disarang secara sewenang-wenang. Sebagai obat data L=I Int|T[L]deriving Showmenyatakan daftar bersarang seperti pohon dengan Ints atau daftar kosong sebagai daun.

Masukan seperti dalam format contoh kedua, dengan konstruktor tambahan Tsebelum setiap penjepit pembukaan: T[T[T[]],T[],T[T[]]]. Hal yang sama berlaku untuk output, dengan setiap angka didahului oleh konstruktor I. Fungsi fmelakukan saddening .

Output untuk kasus uji:

T [I 3]
T [T [T [I 1],I 0],I 0]
T [T [I 1],T [I 1],I 1]
T [T [T [T [I 1],I 1],I 1],T [I 1],I 1]

Javascript (ES6), 77 byte

Golf:

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

Tidak Disatukan:

const traverse = arr => !arr.length || arr
    .map(traverse)
    .reduce(
        (accum, val) => (val.length ? accum.push(val) : accum[0]++, accum),
        [0]
    );

Demo

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

o.innerHTML = [
    JSON.stringify(m([[],[],[]])),
    JSON.stringify(m([[[[]]]])),
    JSON.stringify(m([[[]],[],[[]]])),
    JSON.stringify(m([])),
    JSON.stringify(m([[[[[]],[]],[]],[[]],[]]))
].join('\n')

<pre id=o></pre>