Bu zorlukta, bir liste listesini daha basit bir liste biçiminde ayrıştırmalısınız.

Bu zorluk sadflak ayrıştırıcıma dayanıyor. Sadflak ayrıştırıcımda, programın daha hızlı çalışmasını sağlamak için, listenin başındaki () toplamıyla değiştirilen tüm () kaldırıldı.

Bir Sad-List'e ayrıştırmak için bunu yapmanız gerekir (python uygulama işi, bir grup tuple kullanır):

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

Bu özyinelemeli bir işlevdir. Bir liste için, liste girişindeki () sayısıyla başlayarak yeni bir liste başlatın, ardından bu listenin geri kalanı, liste girişinden () olmayan her listenin sıralı liste sürümleridir. listeyi döndür.

Giriş:

birkaç farklı biçimde girdi alabilirsiniz:

• bir liste olarak alabilirsin
• onu bir demet olarak alabilirsin
• onu bir dize olarak alabilirsin

Eğer bir dize olarak alırsanız, beyin-flak'ta göründüğü gibi bazı braketler kullanmalısınız. 1 ve 2 karakterlerini kullanamazsınız

sadece makul ol

Girdi her zaman bir listenin içinde olacaktır, ancak programınız girdinin dışında örtük bir liste katmanı varsayabilir, yani () () () = (() () ()) veya yapmamayı tercih edebilir. Örnekler açık dış listeyle olacak

çıktı:

liste veya grup veya dize ya da her neyse olabilir. meta konsensüs gibi makul çıktı biçimlerini kullanabilirsiniz.

Misal:

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

girişin katı olmadığını unutmayın. bu girdiler şunlar olabilir:

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

veya başka bir makul format

Açıklanan test örneği:

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

bunu "üzmek" için, önce () sayısını sayıyoruz

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

3. sonra bunları kaldırırız ve başında 3 ekleriz

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

bu listede bir liste var. bunu üzüyoruz

((())())

kaç ()?

     ()
((())  )

1. biz kaldırmak ve başında 1 ekleyin

(1,(()))

içinde bir liste var

(())

Miktar

 ()
(  )

kaldır ve sayı ekle

(1)

sonra bunu tekrar listeye ekledik

(1,(1))

sonra bunu tekrar listeye ekledik

(3,(1,(1)))

tamam

Bu kod golf , bu yüzden daha kısa daha iyidir

Pyth , 13 bayt

L+]/bYyM-b]Yy

Test takımı .

Nasıl çalışır

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 bayt

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

girişleri liste listesi olarak alır.

Çevrimiçi deneyin!

Brachylog , 21 bayt

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

Çevrimiçi deneyin!

Mathematica, 42 bayt

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

Bir ağaçtaki her düğüm üzerinde bir işlevi eşleyen //@( MapAll) kullanarak açık özyinelemeden kaçınır . Bu aynı zamanda fonksiyonların yapraklardan yukarı doğru yürütüldüğü anlamına gelir. Bununla birlikte, süreç içinde {}dönüşen uygulama da uygulanacaktır {0}. Bu yüzden {0}onun yerine sayıyoruz ve kaldırıyoruz {}.

Retina , 42 bayt

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

Çevrimiçi deneyin!

Clojure, 59 bayt

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

CommonLisp yanıtından pek farklı değil . Onun countve removebiraz daha güzel bir yapı kabul gibi görünüyor, burada setleri kullanmak zorunda kaldı.

Aslında 12 bayt

;[]@c@;░Q£Mo

Çevrimiçi deneyin!

Girdileri, açık dış ayraçlarla virgülle ayrılmış köşeli ayraç listesi olarak alır.

Açıklama:

;[]@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 bayt

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

Çevrimiçi deneyin!

Jöle , 10 bayt

Tị߀;@ċ“”$

Çevrimiçi deneyin!

Listelerin listesi olarak girdi alır ...

Elbette diğer cevapların kullandığı algoritmayı kullanır. ;)

Haskell , 102 bayt

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

Çevrimiçi deneyin!

Haskell kesinlikle yazıldığından, keyfi olarak iç içe liste yoktur. Bir çare olarak data L=I Int|T[L]deriving Show, Ints veya boş listeler yaprak olarak ağaç benzeri iç içe listeler bildirilir.

Girdi ek kurucu ile, ikinci örnek biçiminde gibi Ther bir açıklık desteğin önce: T[T[T[]],T[],T[T[]]]. Aynı durum çıktı için de geçerlidir ve her sayıdan önce bir kurucu gelir I. İşlev üzüntüyüf gerçekleştirir .

Test senaryoları için çıktılar:

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 bayt

golfed:

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

Ungolfed:

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

gösteri

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>