Orada olan bir kaç soru bu sitede parantez dengeleme ve parantez dengeli olup olmadığını kontrol etmeyle ilgili. Şimdi bu dengeli braketleri bir şey için kullanmanın zamanı geldi!

Matematik ve programlamada, parantez kabarcıklar gibidir, içindeki her şeyi dışardan izole etmek, içindeki her şeyi huzur içinde yapabilir ve dışarıdaki her şey yalnızca bir nesneyi görür. Bununla birlikte, bir dizi parantez tek boyutlu iken, kabarcıklar genellikle en az iki boyutludur. Bu, kabarcıkların birbirleriyle asla temas etmediği veya diğer kabarcıkların içi ve dışı arasında geçiş yapmadıkları sürece hareket etmekte özgür oldukları anlamına gelir.

Meydan okuma

Girdi, yuvarlak (), kare [], kıvrımlı {}veya açılı tek bir tür eşleşen köşeli parantez dizisidir <>. Programınızın kabul etmesini istediğiniz şey tamamen size bağlıdır ve yalnızca bir tür parantez kabul eden bir program kabul edilir. (Programınız bunlardan herhangi birini idare edebiliyorsa hayali ikramiye, aynı girdideki hepsini idare edebiliyorsa büyük hayali ikramiye puanları alır.) İzleyen boşluklara izin verilse de, giriş parantez arasında hiçbir şey içeremez.

Çıktı, iki ayrı dizge olmaksızın, aynı kabarcık konfigürasyonunu veren bu parantezlerin olası düzenlenmesidir (keyfi sırayla ve orijinal girdi dahil). Bu, bir giriş ile ()(), ()()teknik olarak, yer değiştirebilecek iki kabarcık olmasına rağmen , çıktının da adil olduğu anlamına gelir . Büyük hayali ikramiye için, {}[]()elbette bir irade girdisi , 6 farklı element / string / satır çıktısına yol açar.

Kabarcıkların iki konfigürasyonu "aynı" dır, eğer bir kabarcığı başka bir kabarcığın içinden dışarıya veya dışarıdan içeriye geçmesine izin vermeden kabarcıkları hareket ettirerek diğerinin içine sokabilirsiniz. İç içe parantezleri ağaçlara benzetirseniz (eşleşen her çift bir düğümdür ve içindeki her eşleşen çift bir alt düğümdür ve buradaki her eşleşen çift, bunlardan birinin alt düğümüdür ve burada), belirli bir düğümün alt düğümlerinin sıralandığı Daha sonra, kabarcıkların tek bir konfigürasyonu, düğümlerin sıralanmamış olduğu bir ağaçtır.

Herhangi makul çıkış biçimi için dizeleri listesini veya tek karakter veya boşluk çeşit, tek bir dize listesinin bir listesini dönen ya basmak gibi, yapacak stdoutya da stderrgörünür boşluk karakteri çeşit ile (en yaygın satır veya boşluk) arasında Her yeniden yapılanma.

Her bir yeniden düzenleme için takip eden boşluklar ve gerçek çıkışa izin verilmeden önce ve sonra yeni satırlar / boş liste öğelerinin sonundaki ve sonundaki takip eden boşluklar. Çıktınızda, girişte kabul ettiğiniz aynı parantezleri kullanmalısınız. Burada belirtildiği gibi parantezler, yeni çizgiler ve boşluklar ve ne tür bir ayırıcı kullanırsanız kullanın, hiçbir şey yazdırılmamalıdır (görünmez / sıfır genişlikli karakterler dahil).

Skor, koddaki bayt sayısıdır; Her dil için en düşük sayı kazanır. Düzenli ya da büyük hayali bir bonus alıp almadığınızı not edebilirsiniz, ancak puanınızı etkilemez. Gerçek bonusları dengelemek için çok zor.

Giriş-çıkış örnekleri

Örnek 1:

Giriş:

()(())

Çıktı:

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

Örnek 2:

Giriş:

(()())()()

Çıktı:

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

Örnek 3:

Giriş:

(()(()))()

Çıktı:

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

CJam , 18 bayt

{~{_{{B}%e!}&}:B~}

Çevrimiçi deneyin!

-2 Business Cat sayesinde .

Girdiyi yalnızca içeren bir dize olarak alır []. Permütasyon listesini (boş listeleri CJam boş dizeleri olarak aynı, yani yerine vardır döndürür []size almak olacak "").

Haskell , 227 210 208 205 bayt

import Data.List
l=last
a!x=init a++[l a++[x]]
h[]=[""]
h(x:y)=["("++z++")"++t|z<-v x,t<-h y]
g(a,r)x|x=='('=(a+1,l$(r++h[]):[r!x|a>0])|1>0=(a-1,l$r:[r!x|a>1])
v s=nub$h=<<(permutations.snd$foldl g(0,[])s)

Çevrimiçi deneyin!

Bu zordu!

Birazcık golf oynadım

Laikoni sayesinde iki bayt kurtarıldı

Bruce Forte sayesinde iki bayttan tasarruf edin

Bunun her durumda işe yaradığından emin değilim. Bazı açıklamalar:

• a!xDize xdeğerini, içindeki son Dize listesine ekleyin a(a türü [[String]])

• snd$foldl(\(a,r)x->if x=='('then(a+1,last$(r++[[]]):[r!x|a>0])else(a-1,last$r:[r!x|a>1])basit fikri ifade etmek için daha kısa koşullu kullanır : bir String split kök )( . Örneğin "(()(()))()"verir ["()(())", ""].

• Bölmenin her bir bölümünü işlemeli, sonra doğru çıktıyı elde etmek için tüm dizeleri toplayıp birleştirmeliyiz:

  1. hparçaların bir listesini işler: vilk parça için geçerlidir ve sonucu kalan parçaların işlemi ile birleştirir.

  2. v parçaların her permütasyonu için sonuçları toplar ve kopyaları kaldırır.

Daha geniş bir görünüm eklemek için: temelde boş düğümleri olan bir ağacınız (ikili değil) vardır. Bırakın (). Her düğüm için dalların tüm permütasyonlarını üretmek zorundasınız, ancak bir düğümden dal alıp başka bir düğüme koyamayabilirsiniz. İlk aramada bir çeşit derinlik araştırdım.

Python 2, 353 350 331 Bayt

s=input()
f=lambda i,t=0:i+1if t<0else f(i+1,t-1)if"("<s[i+1]else f(i+1,t+1)
c=[(x,f(x))for x in range(len(s))if")">s[x]]
p=lambda l:[[]]if len(l)<1else[x for y in p(l[1:])for x in[y[:i]+[l[0]]+y[i:]for i in range(len(y)+1)]]
print[''.join(x)for x in p([s[c[x][0]:c[x][1]]for x in range(len(c))if all(c[x][1]>y[1]for y in c[:x])])]

()Giriş dizesini alır ve sonucu yazdırır.

Burada dene!

Paolo'nun bu soruya verdiği cevabın itertools.permutationsyardımıyla kullanmaktan kaçındım .

Teşekkür ederiz İş Cat 3 bayt bulmak için ve teşekkür ederim Sn Xcoder inanılmaz 19 byte için!

açıklama

1. ()Giriş dizesindeki her çiftin dizinlerinin bir listesini oluşturun .
2. Listeden başka bir ()çifte çevrilmiş olan herhangi bir tülü atın .
3. Kalan tuplesin indislerinde dize dilimleyin.
4. Dilim listesindeki her permütasyonun bir listesini yapın.
5. Listeye yazdırmak için yeni bir satır ekleyin.

JavaScript (Firefox 30-57), 222 bayt

s=>(g=a=>a+a?[for(x of g(a[0]))for(y of a.keys())for(z of g(a.slice(1)))(z.splice(y,0,x),z)]:[a])(eval(`[${s.replace(/]\[/g,`],[`)}]`)).map(g=a=>`[`+a.map(g).join``+`]`).sort().filter(s=>t<(t=s),t=``).map(s=>s.slice(1,-1))

Alır []dizeleri. Açıklama:

s=>(                                Inner function to permute an array
 g=a=>a+a?[                         If array is not empty
  for(x of g(a[0]))                 Permute the first element of the array
  for(y of a.keys())                Generate a list of insertion points
  for(z of g(a.slice(1)))           Permute the rest of the array
  (z.splice(y,0,x),z)]:             Make all possible permutations
  [a]                               Otherwise return a list of an empty array
)(eval(`[${                         Convert the string to a nested array
   s.replace(/]\[/g,`],[`)}]`)      ... inserting commas where necessary
).map(                              Process the results
 g=a=>`[`+a.map(g).join``+`]`       Recursively convert back to string
).sort().filter(s=>t<(t=s),t=``     Check for duplicates
).map(s=>s.slice(1,-1))             Remove outer `[]`s

Mathematica, 337 bayt

Kod-golf puanları almak değil , bu problemde Permutationsve kullanımlarını göstermek Distribute. Yine de daha iyi yaklaşımlar olabilir.

( seq: dizi,: altalternatifler)

SetAttributes[alt, {Flat, OneIdentity}]
StringTake[
  StringReplace[ToString[
    ToExpression["{" <> StringReplace[#, "}{" -> "},{"] <> "}"]
        /. List -> Permutations@*seq
       /. List -> alt
      /. seq -> (Distribute[seq@##, alt] &)
     /. {seq -> List, alt -> Alternatives}],
   {", " -> "", "} | {" -> "\n"}],
  {2, -2}] &

Kıvrımlı parantez {ve tuşlarını kullanarak girişi bir dizge olarak alın }. Çok satırlı bir dizge çıktılar.