Mengurai daftar daftar ke Sedih-Daftar

12

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 , jadi lebih pendek lebih baik

Lemon dirusak
sumber
Perhatikan bahwa dalam parser sad-flak yang sebenarnya, jumlah () sebenarnya adalah item kedua dari daftar, dan item pertama adalah indeks dari perintah
Destructible Lemon
Baik JavaScript for... in, buat saya ingat mengapa Anda tidak pernah menggunakannya: Fiddle
Stephen
Saya kira ((((())())())(())()) = [1, [1, [1, [1]], [1]]seharusnya begitu ((((())())())(())()) = [1, [1, [1, [1]]], [1]].
Renzo

Jawaban:

4

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
Biarawati Bocor
sumber
Anda bisa menghapus dulu ].
Erik the Outgolfer
3

CommonLisp, 49 byte

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

mengambil input sebagai daftar daftar.

Cobalah online!

Renzo
sumber
2

Brachylog , 21 byte

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

Cobalah online!

Biarawati Bocor
sumber
Bytes dan karakter tidak sama. Menggunakan UTF-8, itu akan memakan waktu 33 byte, meskipun hanya 21 karakter.
Samadi
1
@Samadi Brachylog menggunakan halaman kode sendiri , yang diizinkan per jawaban meta ini .
Leaky Nun
Ah, begitu. Aku sedang sedikit bingung. Terima kasih telah mengklarifikasi!
Samadi
@Samadi Tidak masalah, pertanyaan ini selalu ditanyakan.
Leaky Nun
2

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

Martin Ender
sumber
2

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.

NikoNyrh
sumber
2

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
Mego
sumber
2

Python 2 , 69 46 45 byte

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

Cobalah online!

ovs
sumber
Saya pikir Anda perlu menambahkan f=bytecount Anda, karena Anda menggunakan fungsi f, dan menyebutkannya jika tidak akan merusak solusi Anda
Leo
@ Leo kamu benar.
ovs
1

Jelly , 10 byte

Tị߀;@ċ“”$

Cobalah online!

Mengambil input sebagai daftar daftar daftar ...

Tentu saja menggunakan algoritma yang digunakan jawaban lain. ;)

Erik the Outgolfer
sumber
Itu bukan 10 byte. Ini 10 karakter . Jumlah byte akan tergantung pada pengkodean apa yang Anda gunakan.
Samadi
2
@Samadi Tidak, Jelly memiliki rangkaian karakter khusus yang merupakan default-nya, dan dapat mewakili karakter-karakter tersebut sebagai masing-masing satu byte. Lihat di sini .
Adám
Saya melihat. Terimakasih atas klarifikasinya!
Samadi
1

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]
Laikoni
sumber
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

HonoredMule
sumber