Normal braketleri ( (), [], <>ve {}) Ancak birileri parantez olmayan ayraç karakteri kullanmak iyi bir fikir olacağını düşündük, güzel ve net bulunmaktadır. Bu karakterler |ve "belirsiz. Örneğin,

""""

karşılık vermek

(())

veya

()()

Bunu söylemek imkansız.

Belirsiz parantez türlerini karıştırdığınızda işler ilginçleşmeye başlar, örneğin

"|""||""|"

Aşağıdakilerden herhangi biri olabilir

([(([]))]),([()[]()]),([()][()])

Görev

Göreviniz belirsiz karakterlerden oluşan bir dize almak ve yazarın amaçladığı tüm olası dengeli dizeleri çıkarmaktır.

Daha somut olarak çıkış yerini yapılabilir tüm dengeli dizeleri |biriyle [veya ]ve "birlikte ya (ya ). Dengeli bir dizeyi iki kez çıkarmamalısınız.

IO

Giriş olarak |ve öğelerinden oluşan bir dize almalısınız ". Bunun dışında iki ayrı karakter seçmek |ve "yerine geçmek isterseniz, bunu yapabilirsiniz. Dengeli dizelerden oluşan bir kap çıkarmalısınız. Sen değiştirmeyi seçebilirsiniz []ve ()herhangi diğer iki braket çiftine sahip çıktı ( (), [], <>veya {}) istediğiniz. Çıktı formatınız tüm çalışmalarda tutarlı olmalıdır.

puanlama

Bu kod golftür, bu nedenle cevaplar daha az bayt daha iyi olacak şekilde bayt cinsinden puanlanır.

Test senaryoları

"" -> ["()"]
"|"| -> []
||| -> []
"""" -> ["(())","()()"]
""|| -> ["()[]"]
"|"||"|" -> ["([([])])"]    
"|""||""|" -> ["([(([]))])","([()[]()])","([()][()])"]    

Python 2 , 135 bayt

s=input()
for k in range(2**len(s)):
 try:c=''.join("[]() , ,"[int(c)|k>>i&1::4]for i,c in enumerate(s));eval(c);print c[::2]
 except:0

Çevrimiçi deneyin!

2002Bunun yerine girdi bekler "||"ve tırnak işaretleri içine alınır.

Dizeye "open" ve "close" 2 ^N olası atamasının tümünü yineler ve şöyle dizeler oluşturur c:

"( [ ( ),],[ ( ),],),( ),"

Eğer evalbu dizeyi -Ing bir istisna atar, bu eşsizdir. Değilse, yazdırırız, veririz c[::2]:

([()][()])()

Retina , 59 56 55 bayt

0`"
<$%">
}0`'
{$%"}
.+
$&_$&
+m`^_|(<>|{})(?=.*_)

A`_

Çevrimiçi deneyin! Maalesef iki takım eşleşen parantez için test yapılması, tek bir .NET regex'inin golfitesini aşar, bu nedenle manuel olarak kontrol etmek için 15 bayt tasarruf sağlar. Düzenleme: @ H.PWiz sayesinde kaydedilmiş 3 4 bayt. Açıklama:

0`"
<$%">

A'yı bulun "ve satırın biri a <ve diğeri a ile iki kopyasını oluşturun >. Bunu "her seferinde yapın, böylece her "biri satır sayısını ikiye katlar.

}0`'
{$%"}

Benzer ile ', {ve }. Tüm kadar Sonra, değiştirilmesi devam "ler ve 'tüm kopyalarda ler değiştirilmiştir.

.+
$&_$&

A ile ayrılmış köşeli parantezleri kopyalayın _.

+m`^_|(<>|{})(?=.*_)

Kopyada, hiçbiri kalmayıncaya kadar eşleşen parantezleri tekrar tekrar silin, bu durumda da silin _.

A`_

Hâlâ olan tüm satırları silin _.

Retina , 74 71 70 bayt

0`"
<$%">
}0`'
{$%"}
Lm`^(.(?<=(?=\3)(<.*>|{.*}))(?<-3>)|(.))+(?(3)_)$

Çevrimiçi deneyin! Açıklama: İlk iki aşama yukarıdaki gibidir. Üçüncü aşama, eşleşen iki braket kümesinin sonucunu doğrudan yazdırır. Bu, .NET'in dengeleme gruplarını kullanır. Eşleşmedeki her aşamada, normal ifade bir karakterle eşleşmeye çalışır, ardından bir çift eşleşen parantez olup olmadığına bakın, ardından yığının üst kısmının açık parantezle eşleşip eşleşmediğini kontrol edin. Bunu yapabiliyorsa, braket dengelenir ve açık braket yığından fırlatılır. Aksi takdirde, varsayım yığına itilmesi gereken açık bir parantezdeyiz. Bu varsayımlar beklemezse, yığın sonunda boş olmaz ve maç başarısız olur.

Alternatif yaklaşım, ayrıca 74 71 bayt:

Lm`^((?=(<.*>|{.*})(?<=(.))).|\3(?<-3>))+(?(3)_)$

Burada, ya <... >ya da {... 'e }bakıyoruz, sonra kapanış desteğini yığına itmek için arkasına bakıyoruz . Aksi takdirde, daha önce yakaladığımız kapatma braketini eşleştirip patlatmamız gerekir. Bu sürümde normal ifade dizenin sonuna kadar gelmeyebilir, ancak <<<>boş bir yığını kontrol etmediysek gibi bazı dizeler net üzerinden kayabilir.

Kabuk , 19 bayt

fo¬ω`ḞoΣx½¨÷₂¨ΠmSe→

Çevrimiçi deneyin! Girişteki karakterleri dsve karşılık gelen parantez çiftlerini deve stçıktıdaki karakterleri kullanır .

açıklama

Fikir, girişin tüm olası parantezlerini oluşturmak ve bitişik parantezleri tekrar tekrar kaldırdığımızda boş dizeye düşenleri tutmaktır. ¨÷₂¨Sıkıştırılmış bir dizge genişlettiği "dest"kısa bir sıkıştırılmış bir yapıya sahiptir ve komşu codepoints karakter çiftinden oluşur, çünkü seçildi. Böylece program aşağıdakine eşittir.

fo¬ω`ḞoΣx½"dest"ΠmSe→  Implicit input, say "ddssdd".
                 m     Map over the string:
                  Se    pair character with
                    →   its successor.
                       Result: ["de","de","st","st","de","de"]
                Π      Cartesian product: ["ddssdd","ddssde",..,"eettee"]
f                      Keep those strings that satisfy this:
                        Consider argument x = "ddsted".
   ω                    Iterate on x until fixed:
         ½"dest"         Split "dest" into two: ["de","st"]
    `Ḟ                   Thread through this list (call the element y):
        x                 Split x on occurrences of y,
      oΣ                  then concatenate.
                          This is done for both "de" and "st" in order.
                        Result is "dd".
 o¬                    Is it empty? No, so "ddsted" is not kept.
                      Result is ["destde","ddstee"], print implicitly on separate lines.

Perl, 56 55 53 bayt

içerir +1içinn

[için []ve {için kullanır{}

perl -nE 's%.%"#1$&,+\\$&}"^Xm.v6%eg;eval&&y/+//d+say for< $_>' <<< "[{[[{{[[{["

Tüm 2 ^ N olasılıklarını oluşturur, ardından eval'+ [+ {}]' gibi bir dizenin geçerli kod olup olmadığını kontrol etmek için perl kullanır ve eğer varsa +sonucu kaldırır ve yazdırır

APL (Dyalog Klasik) , 55 53 bayt

{a/⍨~×≢¨'\(\)|\[]'⎕r''⍣≡a←⊃∘'()[]'¨¨(⊂'".'⍳⍵)+,⍳2⊣¨⍵}

Çevrimiçi deneyin!

Temiz , 203 186 179 bayt

?['(':l][')':t]= ?l t
?['[':l][']':t]= ?l t
?l[h:t]= ?[h:l]t
?[][]=True
?_ _=False
@['"']=[['('],[')']]
@['|']=[['['],[']']]
@[h:t]=[[p:s]\\[p]<- @[h],s<- @t]
$s=[k\\k<- @s| ?[]k]

Çevrimiçi deneyin!

Yalnızca kalıp eşleme ve kavrama kullanır.

Perl, 56 bayt

içerir +içinn

[Çıktı için giriş kullanır [veya]

{Çıktı için giriş kullanır {veya}

perl -nE '/^((.)(?{$^R.$2})(?1)*\2(?{$^R.=$2^v6}))*$(?{say$^R})^/' <<< "[{[[{{[[{["

Geri izleme sırasında yapılan seçimleri takip ederken kaşlı ayraçlar için perl genişletilmiş normal ifadeyi kullanır. Bu, 2 ^ N adaylarının tümünü oluşturmaktan çok daha etkili olabilir, çünkü giriş dizesinde yarı yolda iken birçok imkansız atamayı zaten reddetmektedir.

Kotlin , 240 236 234 bayt

fold(listOf("")){r,c->r.flatMap{i->when(c){'"'->"()".map{i+it}
else->"[]".map{i+it}}}}.filter{val d=ArrayList<Char>()
it.all{fun f(c:Any)=d.size>1&&d.removeAt(0)==c
when(it){')'->f('(')
']'->f('[')
else->{d.add(0,it);1>0}}}&&d.size<1}

Beautified

    fold(listOf("")) {r,c ->
        r.flatMap {i-> when(c) {
            '"'-> "()".map {i+it}
            else -> "[]".map {i+it}
        }}
    }.filter {
        val d = ArrayList<Char>()
        it.all {
            fun f(c:Any)=d.size>1&&d.removeAt(0)==c
            when(it) {
                ')' -> f('(')
                ']' -> f('[')
                else -> {d.add(0,it);1>0}
            }
        } && d.size<1
    }

Ölçek

private fun String.f(): List<String> =
fold(listOf("")){r,c->r.flatMap{i->when(c){'"'->"()".map{i+it}
else->"[]".map{i+it}}}}.filter{val d=ArrayList<Char>()
it.all{fun f(c:Any)=d.size>1&&d.removeAt(0)==c
when(it){')'->f('(')
']'->f('[')
else->{d.add(0,it);1>0}}}&&d.size<1}

data class Test(val input: String, val outputs: List<String>)

val tests = listOf(
    Test("""""""", listOf("()")),
    Test(""""|"|""", listOf()),
    Test("""|||""", listOf()),
    Test("""""""""", listOf("(())","()()")),
    Test("""""||""", listOf("()[]")),
    Test(""""|"||"|"""", listOf("([([])])")),
    Test(""""|""||""|"""", listOf("([(([]))])","([()[]()])","([()][()])"))
)

fun main(args: Array<String>) {
    for ((input, output) in tests) {
        val actual = input.f().sorted()
        val expected = output.sorted()
        if (actual != expected) {
            throw AssertionError("Wrong answer: $input -> $actual | $expected")
        }
    }

Düzenlemeler

• -4 jrtapsell - Yüklemeyi kontrol etme işlemi yeniden düzenlendi
• -2 jrtapsell - true-> 1>0ve == 0->< 1

C (gcc) , 315 bayt

• 19 bayt için ceilingcat'e teşekkürler .

j,b;B(char*S){char*s=calloc(strlen(S)+2,b=1)+1;for(j=0;S[j];b*=(S[j]<62||*--s==60)*(S[j++]-41||*--s==40))S[j]==60?*s++=60:0,S[j]<41?*s++=40:0;return*s>0&*--s<1&b;}f(S,n,k)char*S;{if(n<strlen(S))for(k=2;k--;)S[n]==46-k-k?S[n]=40+k*20,f(S,n+1),S[n]=41+k*21,f(S,-~n),S[n]=46-k-k:0;else B(S)&&puts(S);}F(int*S){f(S,0);}

Çevrimiçi deneyin!

C (gcc) , 334 bytes (eski sürüm)

j,b;B(char*S){char*s=calloc(strlen(S)+2,1)+1;for(b=1,j=0;S[j];j++){if(S[j]==60)*s++=60;if(S[j]<41)*s++=40;b*=!(S[j]>61&&*--s!=60)*!(S[j]==41&&*--s!=40);}return*s>0&*--s<1&b;}f(S,n,k)char*S;{if(n>=strlen(S))return B(S)&&puts(S);for(k=0;k<2;k++)S[n]==46-k-k&&(S[n]=40+k*20,f(S,n+1),S[n]=41+k*21,f(S,-~n),S[n]=46-k-k);}F(char*S){f(S,0);}

Çevrimiçi deneyin!

Açıklama (eski sürüm)

j,b;B(char*S){                   // determine if string is balanced
 char*s=calloc(strlen(S)+2,1)+1; // array to store matching brackets
 for(b=1,j=0;S[j];j++){          // loop through string (character array)
  if(S[j]==60)*s++=60;           // 60 == '<', opening bracket
  if(S[j]<41)*s++=40;            // 40 == '(', opening bracket
  b*=!(S[j]>61&&*--s!=60)*       // 62 == '>', closing bracket
   !(S[j]==41&&*--s!=40);}       // 41 == ')', closing bracket
 return*s>0&*--s<1&b;}           // no unmatched brackets and no brackets left to match
f(S,n,k)char*S;{                 // helper function, recursively guesses brackets
 if(n>=strlen(S))                // string replaced by possible bracket layout
  return B(S)&&puts(S);          // print if balanced, return in all cases
 for(k=0;k<2;k++)                // 46 == '.', guess 40 == '(',
  S[n]==46-k-k&&(S[n]=40+k*20,   //  guess 41 == '(', restore
   f(S,n+1),S[n]=41+k*21,        // 44 == ',', guess 60 == '<',
   f(S,-~n),S[n]=46-k-k);}       //  guess 62 == '>', restore
F(char*S){f(S,0);}               // main function, call helper function

Çevrimiçi deneyin!