Vous devez écrire un programme ou une fonction qui prend une chaîne de crochets et indique si cette chaîne correspond ou non. Votre programme doit imprimer une valeur de vérité ou de fausseté et IO peut être dans n'importe quel format raisonnable .

Règles et définitions:

• Pour les besoins de ce défi, un "crochet" est l’un des caractères suivants ()[]{}<>:.

• Une paire de crochets est considérée comme "appariée" si les crochets d’ouverture et de fermeture sont dans le bon ordre et qu’ils ne contiennent aucun caractère, tel que

  ()
  []{}
  

  Ou si chaque sous-élément à l'intérieur de celui-ci est également assorti.

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

  Les sous-éléments peuvent également être imbriqués sur plusieurs couches.

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

• Une chaîne est considérée comme "Complètement compatible" si et seulement si:

  1. Chaque personnage est une parenthèse,

  2. Chaque paire de supports a les supports d’ouverture et de fermeture corrects et dans le bon ordre, et

  3. Chaque support est assorti.

• Vous pouvez supposer que l'entrée ne contiendra que de l' ASCII imprimable .

Test IO

Voici quelques entrées qui devraient renvoyer une valeur de vérité:

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

Et voici quelques sorties qui devraient renvoyer une valeur de fausseté:

(               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.

Comme d'habitude, c'est du code-golf, donc les échappatoires standard s'appliquent, et la réponse la plus courte en octets l'emporte.

05AB1E , 19 octets

L'entrée est donnée entre guillemets . Code:

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

De la merde, de nombreux bugs et des fonctionnalités non implémentées ont été trouvés. Explication:

"[](){}<>"           # 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

C'est en fait une partie délicate. Voici à quoi cela ressemble dans le pseudocode:

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

Ceci est couvert par cette partie du code 05AB1E :

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)

Comme vous pouvez le constater, le remplacement est infini (jusqu'à ce que la chaîne ne change plus). Donc, je n'ai pas à m'inquiéter de la définition du remplacement dans une boucle, car cela est déjà intégré. Après ça:

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

Utilise le codage CP-1252 . Essayez-le en ligne! (légèrement modifié car la version ci-dessus est obsolète).

Flak cérébrale , 1101, 1085 , 981 octets

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

Essayez-le en ligne!

Il s’agit de 980 octets de code source, et +1pour l’ -aindicateur permettant une entrée ASCII (mais une sortie décimale)

C'est une réponse que je voulais écrire depuis très très longtemps. Au moins 6 mois. J'attendais de poster ceci parce que je savais que répondre à ce défi serait extrêmement difficile en cas de flak cérébrale. Mais cela en vaut la peine pour une raison très importante: le code source lui-même est une entrée de vérité, ce qui est le but même de ce langage.

Et comme je l'ai écrit ici , cette question m'a inspiré pour écrire cerveau-flak.

Peu de temps après avoir écrit Les supports sont-ils parfaitement appariés?, Je me suis demandé combien d'informations vous pouvez stocker avec uniquement des supports correspondants. Une chose qui m'a frappé, c'est que même si vous n'avez que 4 "atomes":

(){}[]<>

vous avez réellement 8 unités d’information à transmettre, puisque chacun de ces types de support peut être vide ou avoir entre eux des supports, qui sont des informations fondamentalement différentes. J'ai donc décidé d'écrire un langage qui n'autorisait que les crochets correspondants, et où les crochets vides véhiculent quelque chose de différent des crochets avec d'autres crochets à l'intérieur.

Cette réponse a pris environ deux heures pour écrire. J'admets que le jeu est assez médiocre, principalement parce qu'une grande partie du code est répétée pour chaque type de support. Mais je suis surtout étonné d’avoir pu écrire une réponse, surtout que Brain-Flak est

Un esolang minimaliste conçu pour être douloureux à utiliser

Je vais essayer de jouer au golf plus tard, mais je voulais quand même le faire savoir.

J'ai une explication détaillée, mais elle compte environ 6 000 caractères, je pense donc qu'il ne serait pas sage de coller le tout dans cette réponse. Vous pouvez le lire ici si vous voulez. Je vais ajouter une explication plus courte ici.

L'idée de base est que nous répétions les étapes suivantes pour chaque personnage de la pile:

• Nous vérifions chaque caractère pour voir s'il correspond à un support. S'il s'agit d'un crochet d'ouverture, nous plaçons un nombre sur l'autre pile conformément au mappage suivant:

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

• Ensuite, nous vérifions si cela correspond à un crochet de fermeture. Si tel est le cas, nous plaçons le nombre équivalent dans la pile de secours, comme pour les crochets d’ouverture. Ensuite , nous vérifions si les deux premiers nombres sont égaux. S'ils le sont, ils sont tous les deux effondrés et le programme se poursuit normalement. Si ce n'est pas le cas, nous effaçons les deux piles (pour arrêter la boucle) et plaçons une pile sur l'autre pile. Ceci est essentiellement une déclaration "break".

• Après avoir vérifié les 8 types de support, nous transmettons la valeur de ce cycle dans la boucle. Puisque nous mettons la plupart du temps à zéro, les seuls extraits qui ont une valeur sont les conditions conditionnelles lorsque nous comparons des parenthèses. Ainsi, si un crochet est apparié, la boucle entière a la valeur 1. Si aucun d'entre eux ne l'a fait, la boucle entière a la valeur 0. Dans ce cas, nous allons effacer les deux piles et appliquer un 0 sur l'autre pile. Encore une fois, cela ressemble à une déclaration "break".

Une fois cette boucle principale lancée, le reste est assez simple. Nous sommes sur la pile principale (vide) et la pile alternative est vide (si les parenthèses ont été comparées) ou non vide si elles ne l'étaient pas. Donc nous courons ceci:

#Toggle to the alternate stack
<>

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

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

Cela poussera un 0 ou un 1 sur la pile principale et, à la fin du programme, il sera implicitement imprimé.

• Merci à @WheatWizard d'avoir mis au point un bon extrait de code "égal à" et "pas logique" et d'avoir mis à jour régulièrement le wiki github avec des exemples utiles.

• Merci à @ ASCII-only pour l’écriture d’un méta-transfert d’entiers en ligne qui a grandement contribué à l’écriture de ce programme.

révisions

• Suppression de la redondance push pop

• Modification de la logique du compteur zéro

Brain-Flak , 204 196 190 octets

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

Essayez-le en ligne!

-8 octets grâce à Wheat Wizard. -6 octets grâce à Jo King.

Explication

Ce programme stocke les codes de caractères de tous les crochets actuels non fermés sur la deuxième pile. Les paires de support <>, []et {}chacun ont des codes de caractères qui diffèrent par exactement 2, donc il n'y a pas besoin de vérifier pour eux spécifiquement. La paire ()ne diffère que de 1, nous vérifions donc (spécifiquement et décrémentons cet octet (incrémentons en fait tous les autres octets) avant de continuer.

# 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 octets

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

Supprimez à plusieurs reprises les crochets jusqu'à ce que le résultat soit identique à l'original, puis renvoyez la valeur false sauf si la chaîne est maintenant vide.

Edit: 2 octets enregistrés grâce à @ edc65.

Rétine, 20 octets

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

^$

Essayez-le en ligne

CJam, 25 24 23 21 octets

Merci à Sp3000 pour la sauvegarde de 2 octets.
Merci à jimmy23013 pour la sauvegarde de 2 octets.

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

Suite de tests.

Fonctionne essentiellement les mêmes que les autres réponses: nous enlevons à plusieurs reprises (), [], <>et {}de la chaîne et vérifier si nous nous retrouvons avec la chaîne vide. Pour éviter d'avoir à vérifier lorsque nous avons terminé, nous supprimons les paires de Ntemps où Nest la longueur de la chaîne, ce qui est toujours suffisant (puisque chaque itération supprimera au moins deux caractères, sauf si nous avons terminé). Je suis content de voir que cela ne bat pas Retina. :) (Bien que Pyth ou Jelly puisse ...)

Il y a une astuce de golf amusante ici: pour obtenir la chaîne, ()<>[]{}nous utilisons les éléments suivants:

{()<>}a`$

Le, {()<>}n'est qu'un bloc (c'est-à-dire une fonction), qui contient les autres crochets sous forme de code. Avec anous enveloppons le bloc dans un tableau. Le `stringifie ce tableau, ce qui donne "[{()<>}]". Enfin, nous trions la chaîne avec $, qui réorganise les crochets ()<>[]{}.

Python, 67 octets

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

Génère et évalue une expression qui ressemble à

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

et vérifie si le résultat est vide.

Sp3000 a sauvegardé 8 octets en indiquant qu'il [],(),{}est possible de créer un sous-lit sans guillemets, car ce sont des objets Python et que deux parenthèses étaient inutiles.

Yacc, 119 octets

N'utilise pas regex / replace.

%%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(){}

Compilation

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

Usage

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

Pyth, 31 25 24 octets

Golfé jusqu'à 25 octets grâce à FryAmTheEggMan Supprimé 1 octet

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

Essayez-le ici: suite de tests !

Je suis toujours un débutant Pyth, toute aide est appréciée.

Explication

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, félicitations à l'autre réponse Pyth (qui est actuellement de 20 octets)

Pyth, 20 octets

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

Essayez-le en ligne: Test Suite

Supprime les occurrences de façon répétée [], (), <>et {}par clivage et re-fusion. Vérifie si la chaîne résultante est vide ou non.

Javascript ES6, 54 octets

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

Utilise une implémentation de remplacement récursive. Assez simple.

Regex (saveur PCRE), 41 37 octets

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

Juste une solution standard avec regex récursive.

Merci jimmy23013 pour avoir rasé 4 octets

Perl, 34 33 octets

Comprend +2 pour -lp

Exécuter avec entrée sur STDIN:

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

brackets.pl:

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

Trouve la première paire de crochets sans rien entre eux et la supprime tant qu'il y en a. Puis vérifie si la dernière chaîne est vide.

Brain-Flak , 204 octets

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

Essayez-le en ligne!

Pas aussi court que la réponse de Nitroden , mais utilise une approche très différente. Celui-ci parcourt l'entrée de manière répétée, en supprimant les paires de crochets correspondants voisins jusqu'à ce qu'il n'en reste plus. À ce stade, s'il reste quelque chose sur la pile, la chaîne ne correspond pas complètement.

Explication:

(())  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 octets

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

Formaté:

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

Attend une entrée sans fin de ligne. Imprime \x00pour faux et \x01pour vrai.

Essayez-le en ligne.

Approche: Maintenir une pile en commençant par \x01, et appuyer sur le support de fermeture correspondant chaque fois qu’un support d’ouverture est rencontré. Avant de vérifier si le caractère actuel est un crochet d’ouverture, commencez par vérifier s’il est égal au crochet de fermeture situé en haut de la pile et, le cas échéant, supprimez-le. S'il ne s'agit ni du support de fermeture approprié ni du support d'ouverture, utilisez le reste de l'entrée tout en déplaçant le pointeur vers la droite. A la fin, vérifiez si le pointeur est à côté de l'initiale \x01.

Grime v0.1, 34 octets

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

Imprime 1pour un match et 0pour aucun match. Essayez-le en ligne!

Explication

Grime est mon langage de filtrage de motifs 2D conçu pour ce défi . il peut également être utilisé pour faire correspondre des chaînes 1D. Ceci est ma première réponse avec elle. J'ai modifié Grime aujourd'hui, mais seulement pour changer le caractère d'un élément de syntaxe ( `au lieu de ,), afin que cela n'affecte pas ma partition.

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 octets, sans compétition

Essayez-le ici!

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/

Il y a un peu plus de golf à faire, mais au moins ça marche. J'ai ajouté une commande ðpour garder une trace des piles après ce défi afin que cela soit possible / facilement à distance. Je vais expliquer cela un peu plus tôt, mais il garde généralement une trace de toutes les chaînes itérées et cherche des répétitions; s'il y a une répétition, la chaîne est irréductible. Sinon, la chaîne sera réduite à la chaîne / pile vide et sera sortie 1. Sinon, aucune sortie ne sera produite.

PowerShell v2 +, 63 62 octets

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

Ne peut pas tout à fait attraper JavaScript, mais est actuellement en train de réduire les autres non-esolangs.

Une approche similaire que d' autres réponses: une simple boucle qui continue tant que nous pouvons supprimer l' un des [], ()ou <>(avec plusieurs caractères étrangers car nous avons besoin pour échapper aux promotions regex). En $bcours de route, nous nous en servons pour nous rappeler comment notre boucle précédente a $aété définie. Une variable non initialisée est évidemment différente de $nullla première fois que la boucle est rencontrée .$a$null

À la fin de la boucle, $aest vide ou non, et le booléen-non de cette chaîne est l'un Trueou l' autre False.

Exemple

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 octets

Rasé de 8 octets grâce à @xsot!

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);}

Utilise une pile.

Java 7, 156 151 octets

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());}}

Je ne m'attends pas à ce que cela remporte de prix, mais je n'ai pas encore vu de réponse en Java. De plus, j'aime bien me promener dans PPCG et j'aimerais pouvoir voter / commenter d'autres réponses.

L'entrée est donnée en tant que paramètres du programme. Cela suit le même format que beaucoup d'autres réponses ici, en ce sens qu'il préforme un remplacement de regex dans une boucle. A l'origine, je l'ai eu boucle N fois, où N est la longueur de la chaîne d'origine, mais la boucle Integer.MAX_VALUEest plus courte:]. Cela devrait être correct car Integer.MAX_VALUEc'est la longueur maximale d'un Stringen Java, donc il y a une hypothèse implicite que la longueur de l'entrée est quelque chose que Java peut gérer. La durée d'exécution est assez mauvaise (cela a pris environ 20 minutes sur mon lappytop) à cause de la boucle, mais je ne voyais aucune restriction à cela.

Haskell , 151 octets

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

Essayez-le en ligne!

Python 2.7, 96 octets

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 octets

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

Julia, 51 octets

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

Le moins fou de plusieurs options. Sans surprise, tirer parti de la puissance de regex est le chemin le plus court vers la correspondance de chaînes, mais cela ne s'applique vraiment que si le motif à comparer est régulier. Essayer de faire des motifs PCRE récursifs finit par gonfler la taille du code, soit en vérifiant si la chaîne entière est la correspondance, soit en ancrant les extrémités, puis en créant une construction pour spécifier le corps interne de la récursion regex. Ni de ce qui sont jolies ou propice à coder le golf.

Explication:

~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

La fonction supprime à plusieurs reprises les paires de parenthèses adjacentes de son seul argument et renvoie true si elle peut dériver une chaîne vide de cette façon.

sed, 39 36 octets (34 pour le code, 2 pour -r)

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

Essayez-le en ligne!

version sed de ce qui semble être l’approche standard. Requiert des expressions régulières étendues ( sed -r)

3 octets sauvés grâce au charlatan des vaches

05AB1E, 9 octets

žu2ôõ:g2Q

L'entrée est donnée entre guillemets.

Essayez-le en ligne!

Explication:

ž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 octets

Plus long que même C et Brainfuck répond: 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)

N'utilise pas de regex, utilise plutôt le premier caractère pour déterminer la balise de fermeture et recherche le premier index où l'équerre est équilibrée (la somme cumulée est égale à zéro). Ensuite, vérifie de manière itérative que ce qui est entre crochets et après est correct.

Il faut voir s'il y a une meilleure approche ...

Lua , 295 octets

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

Version non-golfée

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

Essayez-le en ligne!

Japt v2.0a0 -!, 16 octets

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

L'essayer

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}

L’approche consiste ici à convertir la séquence en code R, puis à l’analyser et à l’évaluer. Si cela donne une erreur, alors revenez FALSE.

Mais il y a un problème mineur ... Les règles de R pour les supports sont différents, <et >ne sont pas du tout entre parenthèses, et les autres types ont leurs propres règles. Ceci est résolu par une approche révolutionnaire - une fonction de grincement, dont la seule fonction est de signaler une erreur si sa tête et sa queue grincent de différentes manières.

Par exemple, []est transformé en S('[', {}, ']'), où S est défini comme ...

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

Parce que la tête et la queue correspondent, aucune erreur n’est commise.

Quelques autres exemples (la partie gauche est une séquence de crochets et la partie droite est sa transformation en code R valide pouvant être évalué):

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

Certaines autres séquences de crochets entraîneront des erreurs d'analyse:

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

Ainsi, la partie restante ne fait qu'attraper les erreurs et renvoie FALSE s'il y en a et VRAI s'il n'y en a pas.

Le code lisible par l'homme:

 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?
   }

En l'appliquant à des échantillons de cas:

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