Bir dizi parantez alan ve o dizenin tamamen eşleşip eşleşmediğini çıkaran bir program veya işlev yazmalısınız. Programınız bir truthy veya sahtekarlık değeri yazdırmalıdır ve IO herhangi bir yerde olabilir. makul formatta olabilir .

Kurallar ve tanımlar:

• Bu zorluğun amacı doğrultusunda, bir "parantez" bu karakterlerden herhangi biri: ()[]{}<> .

• Açma ve kapama parantezleri doğru sıradaysa ve içlerinde karakterleri yoksa, bir parantez bir çift parantez olarak kabul edilir.

  ()
  []{}
  

  Veya içindeki her alt öğe de eşleşirse.

  [()()()()]
  {<[]>}
  (()())
  

  Alt öğeler ayrıca birkaç kat derinlikte yuvalanabilir.

  [(){<><>[()]}<>()]
  <[{((()))}]>
  

• Bir dize "Tam olarak eşleşen" olarak kabul edilir ve yalnızca:

  1. Her karakter bir dirsek

  2. Her bir braket çifti, doğru açma ve kapama braketine ve doğru sıraya sahiptir ve

  3. Her braket eşleştirilir.

• Girişin yalnızca yazdırılabilir ASCII içereceğini varsayabilirsiniz .

Test IO

İşte bir gerçeğe uygun değer döndürmesi gereken bazı girdiler:

()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]

Ve burada sahte bir değer döndürmesi gereken bazı çıktılar:

(               Has no closing ')'
}{              Wrong order
(<)>            Each pair contains only half of a matched element
(()()foobar)    Contains invalid characters
[({}<>)>        The last bracket should be ']' instead of '>'
(((()))         Has 4 opening brackets, but only 3 closing brackets.

Her zaman olduğu gibi, bu kod golf, bu yüzden standart boşluklar geçerlidir ve baytlarda en kısa cevap kazanır.

05AB1E , 19 bayt

Giriş tırnak içinde verilmiştir . Kod:

"[](){}<>"2÷)"":g2Q

Çok saçma, birçok hata ve uygulanmayan özellikler bulundu. Açıklama:

"[](){}<>"           # Push this string
          2÷         # Split into pieces of two
            )        # Wrap it into an array (which should not be needed)
             ""      # Push an empty string
               :     # Infinite replacement

Bu aslında zor bir bölüm. Sahte kodda bunun nasıl göründüğü:

input().replace(['[]', '()', '{}', '<>'], "")

Bu, 05AB1E kodunun bu bölümünde ele alınmıştır :

if type(b) is list:
    temp_string = temp_string_2 = str(a)
    while True:
        for R in b:
            temp_string = temp_string.replace(R, c)
        if temp_string == temp_string_2:
            break
        else:
            temp_string_2 = temp_string
    stack.append(temp_string)

Gördüğünüz gibi, bu sonsuz bir ikamedir (dize artık değişmeyene kadar yapılır). Bu yüzden, değiştirmeyi bir döngüye ayarlamak konusunda endişelenmeme gerek yok çünkü bu zaten yerleşiktir. Daha sonra:

                g    # Take the length of the final string
                 2Q  # Check if equal with 2 (which are the quotes at the end)

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! (Yukarıdaki sürüm onaylanmadığı için hafifçe değiştirilmiş).

Brain-Flak , 1101, 1085 , 981 bayt

{(<(({}))((((()()()()()){}){}){})({}[{}]<(())>){((<{}{}>))}{}>{({}<>)(<>)}{}<(({
}))((((()()()()()){}){}){}())({}[{}]<(())>){((<{}{}>))}{}>{({}<>)({}[{}](<()>)){
{}{}(<(())>)}{}{<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))(((((()()()()()){}){})){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()(<>)}{}<(({}))(((((()()()()()){}){})(
)){}{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((()()()){}){}()){({}[()])}{})({}[{}]<(()
)>){((<{}{}>))}{}>{<({}()()<>)>()(<>)}{}<(({}))((((((()()()()()){})){}{}())){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{<>{{
}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((((()()()()()){}){}){}())){}{})({}[{}]<(())>
){((<{}{}>))}{}>{<({}()()()<>)>()(<>)}{}<(({}))((((((()()()()()){}){}){}())()){}
{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<{}>[()]){<>{{}}(<()>)<>{{}}(<()>)}{}}<>([]<>)({}<
(())>){((<{}{}>))}{}

Çevrimiçi deneyin!

Bu 980 bayt kaynak kodudur ve +1-a ASCII girişine izin veren bayrak için (ancak ondalık çıkış)

Bu yazmak istediğim bir cevap. çok çok uzun zamandır . En az 6 ay. Bunu göndermeyi bekledim, çünkü bu zorluğa cevap vermenin beyin-lafı için çok zor olacağını biliyordum. Ancak bu çok önemli bir nedenden ötürü buna değer: Kaynak kodun kendisi, bu dilin tüm noktası olan gerçek bir girdi.

Ve burada yazdığım gibi , bu soru beynimi kırmak için bana ilham veren şeydi.

Yazdıktan kısa bir süre sonra Destekler tam olarak eşleşiyor mu ?, sadece eşleşen desteklerle ne kadar bilgi saklayabileceğinizi merak ettim. Bana göze çarpan şeylerden biri, sadece 4 "atom" türünüz olmasına rağmen:

(){}[]<>

iletmek için gerçekten 8 birim bilginiz var, çünkü bu braket türlerinin her biri boş olabilir veya aralarında temelde farklı bilgi parçaları olan başka braketler olabilir. Bu yüzden, sadece eşleşen parantezlere izin veren bir dil ve boş parantezlerin içindeki parantezlerden başka bir parantez içerdiği bir dil yazmaya karar verdim.

Bu cevabın yazılması yaklaşık iki saat sürdü. Oldukça kötü golf oynadığını itiraf edeceğim, çünkü çoğunlukla her braket tipi için bir çok kod tekrarlanıyor. Ama çoğunlukla Brain-Flak’ın verdiği bir cevap yazabildiğim için çok şaşırdım.

Kullanımı acı verici olacak şekilde tasarlanmış minimalist bir esolang

Daha sonra golf oynamaya çalışacağım, ama yine de bunu dışarı çıkarmak istedim.

Ayrıntılı bir açıklamam var ama yaklaşık 6 bin karakter uzunluğunda, bu yüzden her şeyi bu cevaba yapıştırmanın akıllıca olmadığını düşünüyorum. Bunu okuyabilirsin burada isterseniz. Burada daha kısa bir açıklama ekleyeceğim.

Temel fikir, yığındaki her karakter için aşağıdaki adımları tekrarlamamızdır:

• Her bir karaktere uyup uymadığını görmek için her karakteri kontrol ederiz. Eğer bir açılış dirseği ise, aşağıdaki haritalamaya göre bir sayıyı diğer yığına itiyoruz:

  ( = 1
  < = 2
  [ = 3
  { = 4
  

• Daha sonra kapanış dirseklerine uyup uymadığını kontrol ederiz. Varsa, eşdeğer sayıyı tıpkı açılış dirseklerinde olduğu gibi alternatif istifin üzerine itiyoruz. Sonra , ilk iki sayının eşit olup olmadığını kontrol ederiz. Eğer öyleyse, ikisi de patlar ve program normal şekilde devam eder. Olmazlarsa, her iki yığını da temizleriz (döngüyü durdurmak için) ve birini diğer yığına iteriz. Bu aslında bir "mola" ifadesidir.

• 8 braket tipini kontrol ettikten sonra, bu çalışmanın değerini döngüden geçiririz. Çoğunu sıfırladığımızdan, herhangi bir değeri olan tek parçacıklar, parantezlerle karşılaştırdığımızda şartlı olanlardır. Dolayısıyla, herhangi bir braket eşleşirse, tüm döngünün değeri 1 olur. Bunlardan hiçbiri yapmadıysa, tüm döngünün değeri 0 olur. Bu durumda, her iki yığını da temizleriz ve alternatif istifin üzerine 0 gireriz. Yine, bu bir "mola" ifadesi gibidir.

Bu ana döngü çalıştıktan sonra, geri kalan oldukça basittir. Biz (boş) ana yığındayız ve alternatif yığın boş (parantezler uygunsa) ya da boş değilse boş. Yani bunu çalıştırıyoruz:

#Toggle to the alternate stack
<>

#Push this stack-height onto main-stack
([]<>)

#Logical not
({}<(())>){((<{}{}>))}{}

Bu işlem, ana yığının üzerine 0 veya 1 değerini zorlar ve program sona erdiğinde dolaylı olarak yazdırılır.

• İyi bir yığın temizliği "eşittir" ve "mantıksal değil" snippet'iyle karşılaştığınız ve github wiki'yi düzenli olarak güncellediğiniz için @WheatWizard'a teşekkürler .

• @ ASCII-Yalnızca bu programı yazmada son derece yardımcı olan çevrimiçi bir tamsayı metagolfer yazdığınız için teşekkürler

revizyonları

• Bazı push pop artıklığı kaldırıldı

• Sıfır sayacı mantığımı değiştirdim

Brain-Flak , 204 196 190 bayt

{({}<>)<>((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())(({<({}<>[({})])>[()]{()(<{}>)}{}<>}{}()<({}<>[({})]){(<{}({}())>)}{}<>>)){(<({}{}<>[{}]{}<>)>)}{}{<>{{}}}{}}<>((){[()]<>})

Çevrimiçi deneyin!

Buğday Sihirbazı sayesinde -8 bayt. -Jo King sayesinde 6 bayt.

açıklama

Bu program, tüm kapatılmamış parantezlerin karakter kodlarını ikinci yığında saklar. Braket çifti <>, []ve {}her tam 2 oranında farklılık karakter kodları var, bu yüzden kendilerine özel kontrol etmeye gerek yoktur. Çift ()sadece 1'e kadar farklılık gösterir, bu yüzden (özel olarak kontrol ederiz ve devam etmeden önce bu baytı (aslında diğer baytları artırır) azaltır.

# While there are bytes left to process
{

 # Move byte to second stack
 ({}<>)<>

 # Push 40, 0, 40, 60, 91, 123: (, then null, then all four opening brackets
 ((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())

 ((

   # For each opening bracket type:
   {

    # Evaluate as zero
    <

     # Compute difference between bracket type and input byte
     ({}<>[({})])

    >

    # Evaluate loop iteration as -1 if equal, 0 otherwise
    [()]{()(<{}>)}{}<>

   }

   # Remove the 0 that was inserted to terminate that loop
   {}

   # Add 1 to result
   ()

   # Evaluate rest of this expression as zero
   <

    # Determine whether the byte is open parenthesis
    ({}<>[({})])

    # If not:
    {

     # Add 1 to byte and break if
     (<{}({}())>)

    }{}

    # Return to main stack
    <>

   >

 # Push result twice (0 if matched an opening bracket, 1 otherwise)
 ))

 # If byte was not an opening bracket:
 {

  # Push zero to break out of if
  (<

    # Push (open bracket + 2 - byte) below that zero
    ({}{}<>[{}]{}<>)

  >)

 }{}

 # If byte was neither an opening bracket nor the appropriate closing bracket:
 {

  # Clear alternate stack and stay there to break out of main loop early
  <>{{}}

 }{}

# End of main loop
}

# If a prefix was invalid, the top of the other stack is the same nonzero value
# that made us break out in the first place. If the string was a valid prefix,
# the other stack contains every unclosed bracket.  If the string is balanced,
# there are none of these. Thus, the other stack is empty if the
# brackets are balanced, and has a nonzero value on top otherwise.

# Push 1 on other stack if empty, and 0 on current stack otherwise
<>((){[()]<>})

JavaScript (ES6), 52 50 bayt

f=s=>(t=s.replace(/\(\)|\[]|{}|<>/,''))==s?!s:f(t)

Sonuç orijinal ile aynı olana kadar tekrar tekrar parantezleri çıkarın, ardından dizge boş olmadıkça false döndürün.

Düzenleme: @ edc65 sayesinde 2 bayt kaydedildi.

Retina, 20 bayt

+`\(\)|\[]|{}|<>

^$

Çevrimiçi deneyin

CJam, 25 24 23 21 bayt

2 bayt tasarrufu için Sp3000'e teşekkürler.
2 bayt tasarrufu için jimmy23013'e teşekkürler.

q_,{()<>}a`$2/*{/s}/!

Test odası.

Aslında diğer cevaplar aynı şekilde çalışır: Biz defalarca kaldırmak (), [], <>ve {}dizesinden ve biz boş dize ile bitirmek kontrol edin. İşimiz bitince kontrol etmek zorunda kalmamak için, çiftleri kaldırmak Nkez neredeN (biz bitti sürece her yineleme, en az iki karakter kaldırır çünkü) her zaman yeterli dize, uzunluğudur. Bunun Retina'yı yenmediğini gördüğüme sevindim. :) (Her ne kadar Pyth veya Jelly ...)

Burada eğlenceli bir golf oyunu var: ipi almak ()<>[]{}için aşağıdakileri kullanıyoruz:

{()<>}a`$

, {()<>}Sadece kodu gibi diğer parantez içeren bir bloğu (yani, bir fonksiyonu) vardır. İle abiz bir dizideki bloğu sarın. `Stringifies veren dizi, "[{()<>}]". Son olarak, $parantezleri yeniden düzenleyen dizeyi sıralarız ()<>[]{}.

Python, 67 bayt

lambda s:eval("s"+".replace('%s','')"*4%([],(),{},'<>')*len(s))==''

Şuna benzeyen bir ifade oluşturur ve geliştirir

s.replace('[]','').replace('()','').replace('{}','').replace('<>','').replace('[]','').replace('()','').replace('{}','').replace('<>','')

ve sonucun boş olup olmadığını kontrol eder.

Sp3000 [],(),{}, Python nesnesi oldukları ve iki parenin gereksiz olduğuna işaret ederek , tırnak işaretleri olmadan yerleştirilebileceklerini işaret ederek 8 bayt kurtardı .

Yacc, 119 bayt

Regex / change kullanmaz.

%%input:r;r:%empty|'['r']'r|'{'r'}'r|'('r')'r|'<'r'>'r;%%yylex(){return getchar();}main(){return yyparse();}yyerror(){}

Ungolfed

%%                              # Grammar in BNF
input:
  r;
r:
  %empty
| '['r']'r
| '{'r'}'r
| '('r')'r
| '<'r'>'r;
%%                              # Minimal parser invocation and lexer
yylex(){return getchar();}
main(){return yyparse();}
yyerror(){}

Derleme

yacc -o bracket.c bracket.y
cc -o bracket bracket.c

kullanım

~/ % echo -n "<()[]>" | ./bracket
~/ %
~/ % echo -n "{" | ./bracket
~/ 1 %                                                                         :(

Pyth, 31 25 24 bayt

FryAmTheEggMan Removed 1 byte sayesinde 25 byte'a düşürüldü

VQ=:Q"<>|\[]|{}|\(\)"k;!

Burada deneyin: Test paketi !

Hala bir Pyth acemiyim, herhangi bir yardımın takdir edilmesi gerekiyor.

açıklama

VQ                         For N in range(0, len(z)), with Q being the evaluated input.
                           Optimal solution would be to use range(0, len(z)/2) instead, but it add two bytes.
  =:Q"<>|\[]|{}|\(\)"k     assign Q without {}, [], <> nor () (regex replacement) to Q
                      ;    End of For loop
                       !   Logical NOT of Q's length (Q is the input, but has gone several times through y, and Q is implicit).
                           This last operation returns True if len(Q) is 0 (which means all brackets were matched), False otherwise

BTW, diğer Pyth cevabını tebrik ediyor (şu anda 20 bayt)

Pyth, 20 bayt

!uuscNTc"[](){}<>"2G

Çevrimiçi deneyin: Test Paketi

Tekrar tekrar oluşumlarını kaldırır [] , (), <>ve {}bölme ve yeniden birleşmesi ile. Sonuçta ortaya çıkan dizenin boş olup olmadığını kontrol eder.

Javascript ES6, 54 bayt

f=_=>_.match(x=/\(\)|\[]|{}|<>/)?f(_.replace(x,'')):!_

Özyinelemeli değiştirme uygulamasını kullanır. Yeterince basit.

Regex (PCRE lezzet), 41 37 bayt

^((<(?1)>|{(?1)}|\[(?1)]|\((?1)\))*)$

Özyinelemeli regex ile sadece standart bir çözüm.

4 byte'ı tıraş ettiğiniz için teşekkürler jimmy23013

Perl, 34 33 bayt

İçin +2 içerir -lp

STDIN'de giriş ile çalıştırın:

./brackets.pl <<< "{<>()}"

brackets.pl:

#!/usr/bin/perl -lp
s/\(\)|\[]|<>|{}//&&redo;$_=!$_

İlk parantez çiftini aralarında hiçbir şey olmadan bulur ve varsa olduğu gibi kaldırır. Sonra son dizginin boş olup olmadığını kontrol eder.

Beyin Flak , 204 bayt

(()){{}{({}<>)<>}<>({<(<(({})<>)>)(((((((([(())()()()]){}){}){}())(()))(((())()){}()){})){})(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))<>{}<>{{}({}[({})]<>({})){(<>)(<>)}{}{}(<>)}{}>{}<>}<>)}{}((){<>[()]})

Çevrimiçi deneyin!

Nitroden'in cevabı kadar kısa değil , ama çok farklı bir yaklaşım kullanıyor. Bu, giriş boyunca art arda ilerleyerek komşu parantez çiftlerini her seferinde kalan kalmayana kadar kaldırır. Yığında bir şey kalmışsa, o zaman dize tam olarak eşleşmedi.

Açıklama:

(())  Push 1 to simulate the check at the start of the loop
{  While check
	{}           Pop check
	{({}<>)<>}<> Reverse input
	({           Loop over input
		< Don't push the values of these calculations
		(<(({})<>)>)  Create a copy of the top of the input and push to the other stack
		(((((
		((([(())()()()]){}){}){}())
		(()))
		(((())()){}()){})
		){})          Push the differences in values of the end brackets 
		(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))  If the copy is the same as any of these, push the difference between the other bracket twice
		<>{}<>  Pop copy
		{  If this character is a start bracket
			{}({}[({})]<>({}))  Check if the next character is the end bracket
			{(<>)(<>)}{}          If not, push a 0 to each stack as buffer
			{}       Pop the top of the input stack, either the start bracket if they matched or the buffer 0
			(<>)     Push 0 to other stack to end check
		}{}>
		{}   Pop the top of the other stack
		         If the character was not an end bracket, pop the copy of check, which is 0
		         If it was, but didn't match the next character, pop the buffer 0
		         If the brackets matched, pop the end bracket and add it to the loop total
	<>}	Repeat with the rest of the input
	<>)	Push the loop total
		If any brackets were matched, the loop total is non zero
}{}
((){<>[()]}) If there is anything left on the stack, push 0 to the other stack, otherwise push 1

Brainfuck, 132 bayt

+>,[[<->>+>[-]<<-]<[>+>[<+<+>>>+<-]+++++[>--------<-]>[<<+>++++[>-----<-]>[<++++
+[>------<-]>-[<++++[>--------<-]>[,>]]]]<],]<<[>]>.

biçimlendirilmiş:

+>,
[
  [<-> >+>[-]<<-]
  <
  [
    not matching closing bracket
    >+>[<+<+>> >+<-]
    +++++[>--------<-]
    >
    [
      not open paren
      <<+>
      ++++[>-----<-]>
      [
        not open angle bracket
        <+++++[>------<-]>-
        [
          not open square bracket
          <++++[>--------<-]>
          [
            not open brace
            ,>
          ]
        ]
      ]
    ]
    <
  ]
  ,
]
<<[>]
>.

Sondaki yeni satır olmadan girişi bekler. Baskılar\x00False ve \x01true için .

Çevrimiçi deneyin.

Yaklaşım: Başlayarak bir yığını koruyun \x01ve bir açma braketi ile karşılaşıldığında karşılık gelen kapanış braketi itin. Geçerli karakterin bir açılış braketi olup olmadığını kontrol etmeden önce, ilk önce yığının üstündeki kapanış braketine eşit olup olmadığını kontrol edin ve eğer öyleyse pop. Ne uygun kapanış dirsek ne de bir açılma dirseği değilse, imleci sağa hareket ettirirken girişin kalan kısmını tüketin. Sonunda, işaretçinin ilk harfin yanında olup olmadığını kontrol edin \x01.

Grime v0.1, 34 bayt

M=\(M\)|\[M\]|\{M\}|\<M\>|MM|_
e`M

1Bir eşleşme için yazdırır ve 0eşleşme olmaz. Çevrimiçi deneyin!

açıklama

Grime, bu zorluk için tasarlanan 2D kalıp eşleştirme dilimim ; 1D dizeleri eşleştirmek için de kullanılabilir. Bu benim ilk cevabım. Bugün Grime'yi değiştirdim, ancak yalnızca bir sözdizimi öğesinin karakterini değiştirmek için ( `bunun yerine ,), bu yüzden puanımı etkilemiyor.

M=                         Define pattern called M that matches:
\(M\)|\[M\]|\{M\}|\<M\>      a smaller M inside matched brackets,
|MM                          or two smaller Ms concatenated,
|_                           or the empty pattern.
e`M                        Match the entire input against M.

Reng v.3.3, 137 bayt, rekabetçi olmayan

Burada dene!

aií0#zl2,q!~1ø
:"]"eq!v:"}"eq!v:">"eq!v:")"eq!v)1z+#z
ve¤[2-2<       <       <     +1<
>]?v$$$zÀ0#z >ðq!vlqv¤l2%[1Ø
   \$2+)1z+#z/   ~n1/

Yapılacak daha çok golf var, ama en azından işe yarıyor. Bunun ðuzaktan mümkün / kolay olması için bu zorluğun ardından yığınları takip etmek için bir komut ekledim . Bunu biraz sonra açıklayacağım, ancak genellikle yinelenen tüm dizeleri izler ve tekrarlar arar; tekrar varsa, dize indirgenemez. Aksi takdirde, dize boş dizeye / yığına indirgenecek ve çıkacaktır 1. Aksi takdirde, hiçbir çıktı üretilmez.

PowerShell v2 +, 63 62 bayt

param($a)for(;$a-ne$b){$a=($b=$a)-replace"\[\]|\(\)|<>|{}"}!$a

JavaScript'i tam olarak yakalayamıyorum, ancak şu anda diğer esolanger'ları kapatıyor.

Diğer cevaplar olarak benzer bir yaklaşım: madem birini kaldırmak gibi devam basit bir döngü [], ()ya <>(biz düzenli ifade özel kaçmak gerekir, çünkü birçok yabancı karakterleri). Biz kullanmak $bönceki döngü en hatırlamak için yol boyunca bir yardımcı olarak $aolarak belirlenmiştir. Başlatılmamış bir değişkendir $null, bu nedenle döngü ile ilk karşılaşıldığında $aaçıkça eşit değildir $null.

Döngünün sonunda $a, ya boş ya da boş değildir ve bu dizginin Boole değeri ya Trueya da ya False.

Örnek

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({})]"
True

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({])}"
False

C, 121 122 114 bayt

@Xsot sayesinde 8 bayt tıraş edildi!

a[99],i,k;main(c){for(;read(0,&c,!k);c%7&2?k|=a[i--]^c/9:(a[++i]=c/9))k|=!strchr("()[]{}<>",c);putchar(48+!k*!i);}

Bir yığın kullanır.

Java 7, 156 151 bayt

class A{public static void main(String[]a){for(int i=0;i<-1>>>1;++i,a[0]=a[0].replaceAll("<>|\\[]|\\(\\)|\\{}",""));System.out.print(a[0].isEmpty());}}

Bunun herhangi bir ödül kazanmasını beklemiyorum ama henüz bir Java cevabı görmedim. Ek olarak, PPCG etrafında gezinmeyi seviyorum ve diğer cevaplar hakkında oy kullanabilmeyi / yorum yapmayı çok isterim.

Giriş, program parametreleri olarak verilir. Bu, bir döngü içindeki bir regex değişimini önceden oluşturması için, buradaki diğer birçok cevapla aynı formatı izler. Başlangıçta, N'nin orijinal dizginin uzunluğunun olduğu, ancak döngünün Integer.MAX_VALUEkısaldığı N döngüsüne sahiptim :]. Bu tamam olmalı Integer.MAX_VALUE, çünkü StringJava’nın maksimum uzunluğu budur, bu nedenle girdi uzunluğunun Java tarafından idare edilebilecek bir şey olduğu kesin bir varsayım vardır. Döngü nedeniyle çalışma zamanı oldukça kötü (lappytop'ta yaklaşık 20 dakika sürdü) ancak bu konuda herhangi bir kısıtlama görmedim.

Haskell , 151 bayt

infix 1#
'(':x#y=x#')':y
'<':x#y=x#'>':y
'[':x#y=x#']':y
'{':x#y=x#'}':y
')':x#')':y=x#y
'>':x#'>':y=x#y
']':x#']':y=x#y
'}':x#'}':y=x#y
""#""=1
_#_=0

Çevrimiçi deneyin!

Python 2.7, 96 bayt

def r(s):i=max(map(s.find,['()','[]','{}','<>']));return not len(s)if i<0 else r(s[:i]+s[i+2:])

Python 2,80 bayt

def m(s,i=0):exec's=s.replace("[({<])}>"[i%4::4],"");i+=1;'*4*len(s);return"">=s

Julia, 51 bayt

~z=z==(n=replace(z,r"\(\)|\[]|{}|<>",""))?z=="":~n

Çeşitli seçeneklerin en az delisi. Şaşırtıcı olmayan bir şekilde, regex'in gücünden yararlanmak, dize eşleşmesinin en kısa yoludur, ancak bu gerçekten eşleşecek model düzenliyse geçerlidir. PCRE özyinelemeli kalıpları yapmaya çalışmak, tüm dizginin eşleşip eşleşmediğini görerek veya uçları sabitleyerek ve ardından regex özyineleme için iç gövdeyi belirtmek için bir yapı oluşturarak, kodun boyutunu şişirmekle sona erer. Hiçbiri golf kodlamak için güzel veya elverişli değildir.

Açıklama:

~z=                            # Define ~z to be the following:
    z==(                       # If z is equal to                                     
        n=replace(z,           # z with the replacement of 
            r"\(\)|\[]|{}|<>", # adjacent matching brackets ((),[],{}, or <>)
            ""                 # with empty strings
        )                      # (which is assigned to n)
    )?z==""                    # whether z is an empty string
    :~n                        # else ~ applied to the substituted string

İşlev, bitişik parantez çiftlerini tek argümanından art arda kaldırır ve bu şekilde boş bir dize türetebiliyorsa true değerini döndürür.

sed, 39 36 bayt (kod için 34, -r için 2)

:a
s/\(\)|\[]|<>|\{}//;ta
/./c0
c1

Çevrimiçi deneyin!

standart yaklaşım olarak görünen şeyin sed versiyonu. Genişletilmiş düzenli ifadeler gerektirir ( sed -r)

İnekler quack sayesinde 3 bayt kurtardı

05AB1E, 9 bayt

žu2ôõ:g2Q

Giriş tırnak içinde verilmiştir.

Çevrimiçi deneyin!

Açıklama:

žu          # Push "()<>[]{}"
  2ô        # Split into pieces of size 2
    õ       # Push empty string
            # Implicit input
      :     # Infinite replacement
       g2Q  # Is length equal to 2?
            # Implicit print

Clojure, 153 bayt

C ve Brainfuck cevaplarından bile daha uzun: o

(defn f[[s & r]](if s(let[[a b](split-at(.indexOf(reductions + 1(for[c r](get(zipmap[s({\(\)\[\]\{\}\<\>}s)][1 -1])c 0)))0)r)](and(not=()a)(f(butlast a))(f b))))1)

Regex kullanmaz, bunun yerine kapanış etiketinin ne olduğunu belirlemek için ilk karakteri kullanır ve bu parantezin dengeli olduğu ilk dizini bulur (kümülatif toplam sıfırdır). Ardından yinelemeli olarak parantezlerin içindeki ve parantezlerin geçerli olduğunu kontrol eder.

Bakalım daha iyi bir yaklaşım var mı ...

Lua , 295 bayt

f = false g = string.gsub t=table s={}b=io.read()for c in b:gmatch('.')do if c:find("[%[<{%(]")then s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")")elseif c:find("[%]>}%)]")then if t.remove(s)~=c then print(f)return end else print(f)return end end if#s>0 then print(f)else print(1)end

Ungolfed Sürümü

f = false
g = string.gsub
t=table
s={} --Define a stack of opening brackets
b=io.read() --get the input
for c in b:gmatch('.') do   --for every character
    if c:find("[%[<{%(]") then
        s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")") --if the current character is an opening bracket, push the closing bracket onto the stack
    elseif c:find("[%]>}%)]") then
        if t.remove(s)~=c then
            print(f) --if the character is a closing bracket, pop the closing bracket off the stack and test if they match, if not print false
            return
        end
    else 
        print(f) --if the character is not a bracket print false
        return
    end
end
if #s>0 then
    print(f) --if there are still brackets on the stack print false
else
    print(1) --print 1 there are no brackets on the stack
end

Çevrimiçi deneyin!

Japt v2.0a0 -!, 16 bayt

e/\[]|<>|\(\)|{}

Dene

R, 298

function(.){s=strsplit;u=paste0;.=s(.,"")[[1]];p=s("><)(}{][","")[[1]];.[!.%in%p]="§";for(i in 1:4*2){.[.==p[i]]=sprintf("S('%s',{",p[i]);.[.==p[i-1]]=sprintf("},'%s');",p[i])};S=function(H,B,T)if(H!=T)stop();r=try(eval(parse(,,u(.,collapse=""))),1);if(inherits(r,"try-error"))FALSE else TRUE}

Buradaki yaklaşım, diziyi R koduna dönüştürmek ve ardından ayrıştırıp değerlendirmeye çalışmaktır. Bu bir hata verirse geri dönün FALSE.

Fakat küçük bir problem var ... R'nin parantez kuralları farklı, <ve> parantez hiç değildir ve diğer türdeki kendi kuralları vardır. Bu, devrimci bir yaklaşımla çözülür - gıcırtılı bir işlev, tek işlevi, başı ve kuyruğu farklı şekillerde gıcırdıyorsa, bir hatayı işaret etmek içindir.

Örneğin, []transforme edilir S('[', {}, ']')S olarak tanımlanır, ...

S=function(H,B,T)if(H!=T)stop() 

Kafa gıcırtı ve kuyruk gıcırtı eşleştiği için hiçbir hata atılmaz.

Diğer birkaç örnek (sol kısım bir parantez dizisidir ve sağ kısım, değerlendirilebilecek geçerli R koduna dönüştürülmesidir):

[}     -->  S('[', {}, '}')     # squeaks an error
[()]   -->  S('[', {S('(',{},'(')}, "[")
({[]}) -->  S('(',{S('{',{S('[',{},'[');},'{');},'(');

Diğer bazı parantez dizileri ayrıştırma hatalarına neden olur:

[[)    -->   S('[',{S('[',{},'('); 

Böylece kalan kısım sadece hataları yakalar ve varsa FALSE, eğer yoksa TRUE olur.

İnsan tarafından okunabilen kod:

 sqk <- function(.){
   s=strsplit;u=paste0
   .=s(.,"")[[1]]            # break the argument up into 1-character pieces
   p=s("><)(}{][","")[[1]]   # vector of brackets
   .[!.%in%p]="§"            # replace anything besides brackets by § (--> error)
   for(i in 1:4*2){     
     .[.==p[i]]=sprintf("S('%s',{",p[i])    # '<' -->   S('<',{     ... etc
     .[.==p[i-1]]=sprintf("},'%s');",p[i])  # '>' -->   },'<');     ... etc  
   }
   S=function(H,B,T)if(H!=T)stop()          # define the working horse
   r=try(eval(parse(,,u(.,collapse=""))),1) # evaluate the sequence
   if(inherits(r,"try-error"))FALSE else TRUE   # any errors?
   }

Örnek vakalara uygulamak:

truthy<-readLines(textConnection("()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]"))
falsy<-readLines(textConnection("(
}
(<2)>
(()()foobar)
[({}<>)>
(((()))"))
> sapply(truthy,sqk)
                      ()                 [](){}<>                 (((()))) 
                    TRUE                     TRUE                     TRUE 
                ({[<>]})             [{()<>()}[]] [([]{})<{[()<()>]}()>{}] 
                    TRUE                     TRUE                     TRUE 
> sapply(falsy,sqk)
           (            }        (<2)> (()()foobar)     [({}<>)>      (((())) 
       FALSE        FALSE        FALSE        FALSE        FALSE        FALSE