Parantez ( [{()}]) ve diğer karakterleri ( A- Z, a- z, 0- 9, noktalama işaretleri) içeren (muhtemelen boş) bir dize verilecektir . Aşağıdaki kurallara uyup uymadığını kontrol etmeniz gerekir:

• Köşeli ayraç olmayan karakterler yok sayılır.
• Her açık brakette [{(bir kapatma braketi vardır )}]. Buna [](izin verilmiyor.
• Köşeli ayraçlar düzgün şekilde yuvalanmış. [(])Müsade edilmez.
• Kıvırcık parantezlerin içinde köşeli parantez bulunamaz. Basit köşeli ayraçlar içlerinde kıvırcık veya köşeli ayraç içeremez. Yani [({})], [{[]}]ve ({})izin verilmez. Parantezler benzer parantezlerle yuvalanabilir, bu [[{((()))}{{(())}}]()]{()}nedenle izin verilir.

Çıktı, seçiminize göre tek bir doğruluk / falsey değeridir.

En kısa kod kazanır.

Test senaryoları

b[[a{(/)}(())+={{}-}],] -> Geçerli

([h][e][l][l][o]) -> Geçersiz

[///[{(\/(arg()))}1{{((-)-2)}}]()]{()} -> Geçerli

hi -> Geçerli

Retina , 84 bayt

^([^][}{)(]|()\(|(?<-2>)\)|(?!\2)((){|(?<-4>)}|(?!\4)(()\[|(?<-6>)])))*$(?!\2|\4|\6)

Çevrimiçi deneyin.

Bu, temel parantezleri kontrol eden .NET normal ifadesinin oldukça basit (ama golf edilmiş) bir uzantısıdır .

Dengeleme grupları ile bu mümkün olsa da, Perl'in özyineleme kesinlikle burada bir kenara sahiptir . Bununla birlikte, her iki yaklaşım da, Digital Trauma'nın sed cevabının yaptığı gibi , tekrarlanan ikameler yoluyla girdiyi kademeli olarak azaltmak lehine tek bir normal regex maçının zarafetini azaltarak yenilir . Bu, Retina'da 34 baytta uygulanabilir, ancak fikri kendim bulamadım, çünkü fikri bulamadım.

Retina, 34

İlk olarak, kredinin vadesi gelen kredi:

• Bu yaklaşımı ilk yayınlayan kişi @ ן nɟu approach ן oɯ .
• @ MartinBüttner bu cevabı önerdi , ancak bir sporcunun kendini göndermemesi için çok iyiydi.

Ben bağımsız olarak (daha sonra) sed aynı yaklaşımı ile geldi , bu yüzden ben ( büyük veya başka türlü) herhangi bir ayak parmakları üzerinde bu göndererek tedavi değil umuyoruz :

[^][(){}]

+`\(\)

+`{}

+`\[]

^$

Şimdi bir sudo apt-get install mono-completeve git clone https://github.com/mbuettner/retina.gitUbuntu VM'imde çalışan bir retina var. İşte test çıktısı:

$ while read; do echo "Input: \"$REPLY\", Ouput: $( mono Retina.exe -s brbal.ret <<< "$REPLY" )" ; done < ../brbal.txt 
Input: "[[{((()))}{{(())}}]()]{()}", Ouput: 1
Input: "b[[a{(/)}(())+={{}-}],]", Ouput: 1
Input: "[///[{(/(arg()))}1{{((-)-2)}}]()]{()}", Ouput: 1
Input: "hi", Ouput: 1
Input: "", Ouput: 1
Input: "", Ouput: 1
Input: "([h][e][l][l][o])", Ouput: 0
Input: "[](", Ouput: 0
Input: "[(])", Ouput: 0
Input: "[({})]", Ouput: 0
Input: "[{[]}]", Ouput: 0
Input: "({})", Ouput: 0
$ 

Sıska, 53

s/[^][(){}]//g
:;s/()//;t
:b;s/{}//;tb
:c;s/\[\]//;tc

Burada sedgerçekten doğruluk / falsey kavramına sahip olmadığından, boş dizeyi doğruluk anlamına ve diğer tüm dizeleri falsey olarak tanımladığımı iddia ediyorum.

Bu kabul edilebilir değilse, birkaç satır ekleyebiliriz, böylece:

Sıska, 66

s/[^][(){}]//g
:;s/()//;t
:b;s/{}//;tb
:c;s/\[\]//;tc
/./c0
/^$/c1

Bu, false için 0 ve true için 1 verir.

CJam, 27 26 bayt

"(){}[]"q1$f&_,@2/e*{/s}/!

Bu 1 (doğru) veya 0 (yanlış) yazdırır . Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın.

Nasıl çalışır

"(){}[]"                    Push that string.
        q                   Read all input and push it on the stack.
         1$                 Copy the bracket string.
           f&               Intersect each input character with the bracket string.
                            This pushes an array of singleton and empty strings.
             _,             Get the length of the array (L), i.e., the number of
                            characters in the original input.
               @            Rotate the bracket string on top of the stack.
                2/          Split it into ["()" "{}" "[]"].
                  e*        Repeat each character pair L times.
                    {  }/   For each character pair.
                     /      Split the string on the stack at occurrences of that
                            character pair. This dosn't work properly the first
                            time, since there's a string array on the stack.
                      s     Flatten the resulting array of strings.
                         !  Apply logical NOT.

𝔼𝕊𝕄𝕚𝕟, 43 karakter / 62 bayt

!Մ(Մ(Մ(ïċ/⁅⬮[\]{}]⌿),`⬮`,⬯),`{}`,⬯),`[]`,⬯)

Try it here (Firefox only).

Hayır!

Ancak, yeni uygulanan özellikleri kullanırsam, 28 karakter / 47 bayta kadar düşebilirim:

!ïċ/⁅⬮[\]{}]⌿)ė`⬮”ė`{}”ė`[]”

Japt , 42 37 bayt

Kendi dilimin olduğunu bilmediğim bir özellik ile 5 bayt kaydedildi ... Eklediğiniz için teşekkürler, @ Downgoat!

Japt gerçekten daha iyi RegExp desteğine ihtiyaç duyuyor ...

!Uo"()[\\]\{}" e"\\(\\)" e"\{}" e"\\[]

Çevrimiçi deneyin!

Nasıl çalışır

               // Implicit: U = input string
Uo"()[\\]\{}"  // Remove all non-bracket.
e"\\(\\)"      // Recursively remove all pairs of simple brackets.
e"\{}"         // Recursively remove all pairs of curly brackets.
e"\\[]         // Recursively remove all pairs of square brackets.
!              // Return the Boolean NOT of the result.
               // (true for empty string, false for anything else)
               // Implicit: output last expression

C99, 226 208 207 Bayt

Bu benim ilk kez bir şey golf oynamaya çalışıyor

#define S s[i]
t(s,i)char*s;{int a[]={['[']=0,['{']=0,['(']=0};for(i=0;S*!(S=='{'&a['(']|S=='['&(a['(']|a['{'])|S==']'&(a['(']|a['{'])|S=='}'&a['(']);i++)a[S]++,a[S-S/90-1]--;return !(a['[']+a['{']+a['(']);}

Okunabilir:

int t(char* s){
    int a[265]={['[']=0,['{']=0,['(']=0};
    for(int i=0;s[i]&&!((s[i]=='{'&a['(']>0)|(s[i]=='['&(a['(']>0|a['{']>0))|(s[i]==']'&(a['(']>0|a['{']>0))|(s[i]=='}'&a['(']>0));i++){
        a[s[i]]++;
        a[s[i]-(s[i]/90+1)]--;
    }
    return !(a['[']+a['{']+a['(']);
}

Bir arabellek taşması var ama hiçbir şeyi etkilemiyor gibi görünüyor - bunun hizalamadan kaynaklandığına inanıyorum.

Perl, 50 + 1 = 51 bayt

$_=/^((([^][)(}{]|\((?3)*\))|{(?2)*})|\[(?1)*])*$/

Doğruluk için -pbayrak ve baskı gerektirir ve 1yanlış sonuçlar için hiçbir şey gerekmez. Ben bir -polarak sayıyorum , çünkü ile birleştirilebilir -e:

> perl -pe '$_=/^((([^][)(}{]|\((?3)*\))|{(?2)*})|\[(?1)*])*$/'

Kod, Perl'in şık özyinelemeli regex özelliği kullanılarak, girişle yalnızca düz bir normal ifade eşleşmesidir.

Dennis'e bunu test etmeme ve Perl kazan plakasını golf etmeme yardımcı olduğu için teşekkürler.

Python 3: 120 bayt

@ Adnan'ın cevabına dayanarak , kullanımın daha kısa olduğu kanıtlandı:

import re
x=re.sub('[^[\](){}]','',input())  
for i in('()','{}','[]'):  
 while x.find(i)>=0:x=x.replace(i,'')  
print(x=='')

Piton 3, 196 170 160 154 bayt

Garip bir şekilde uzun, 6 bayt tasarruf sağladığı için Mego sayesinde:

d=y=""
for C in input():
 for a in "[](){}":y+=C*(C==a)
 y=y.replace("()",d)
x=y
for r in y:x=x.replace("{}",d)
for s in y:x=x.replace("[]",d)
print(x==d)