这是Brain-Flak生日前的一系列挑战之一。在这里找到更多。

挑战

对于这一挑战，您的目标是在完全匹配的括号中找到第一对匹配的()[]{}<>括号。借用DJMcMayhem对完全匹配的字符串的定义：

• 出于此挑战的目的，“括号”是以下任意字符：()[]{}<>。

• 如果左括号和右括号的顺序正确且其中没有字符，则将一对括号视为“匹配”

  ()
  []{}
  

  或者，如果其中的每个子元素也都匹配。

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

  子元素也可以嵌套在几层深处。

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

• 当且仅当每对括号中的正确开/右括号正确且顺序正确时，字符串才被视为“完全匹配”。

输入项

输入将由单个非空字符串或仅包含character的char数组组成()[]{}<>，并保证完全匹配。您可以采用符合我们I / O默认值的任何合理方式进行输入。

输出量

程序或函数的输出将是括号的索引，该括号将关闭第一个括号。输出必须是0或已1索引。同样，输出可以以与我们的I / O默认值相对应的任何合理方式进行。

测试用例

Input       0-indexed   1-indexed
()          1           2
(<>)        3           4
<[]{<>}>    7           8
{}{}{}{}    1           2
[[]<>[]]    7           8

这是代码高尔夫球，最少字节获胜！

V，4个字节

%Dø.

在线尝试！

与大多数V答案不同，这使用0索引。我为这个答案以及我的语言走到多远而感到自豪。说明：

%       " Jump to the first bracket match
 D      " Delete everything under and after the cursor
  ø     " Count the number of times the following regex is matched:
   .    "   Any character

Brain-Flak，685、155、151、137字节

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

在线尝试！

136个字节的代码，再加上1个字节-a。一个索引。

击打了530个字节！那可能是我做过的最大的高尔夫球。

感谢赖利节省了14个字节！

这滥用了开/关括号的公式：如果您采用ASCII值，将其递增1，并取4为模，则开环（({[<）将始终为0或1，而闭环（)}]>）将始终为2或3。

说明：

#Push 1
(())

#While true
({<

    #Pop stack height
    {}

    #Compute (TOS + 1) % 4
    ({}()<(()()()())>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

    #Decrement if positive
    (({})){{}({}[()])(<()>)}{}

    #Push 0 onto alternate
    (<>)

    #Toggle back
    <>

    #Pop two zeros from alternate if closer
    {{}<>{}({}<>)}{}

    #Push height of alternate stack
    (<>[]<>)

#Make each time through evaluate to 1
>()

#Endwhile
}

#Push the number of loops onto the offstack
<>)

05AB1E，17 16 10字节

-1感谢carusocomputing

-6感谢Adnan的惊人见解：“递增后，倒数第二个是左括号为0，右括号为1”

Ç>2&<.pO0k

在线尝试！

Ç          # Get input as ASCII values
 >         # Increment
  2&       # And with 2 (0 for open and 2 for close brackets)
    <      # decrement 
     .p    # prefixes
       O   # Sum
        0k # Print the index of the first 0

Vim，23个字节

:se mps+=<:>
%DVr<C-a>C1<esc>@"

在线尝试！

我对这个答案感到非常难过。该解决方案非常优美且简短，但是，默认情况下，vim不会考虑<并>加以匹配，因此我需要13个字节的样板代码。否则，这将只是10个字节。

我会发布一个V答案，但这只会短一个字节，即更改Vr为Ò，因为这Vr是常见的vim习惯用法。

这是1-索引但是可以平凡修改为通过改变0索引1到一个0。

:se mps+=<:>        " Stupid boilerplate that tells vim to consider `<` and `>` matched
%                   " Jump to the bracket that matches the bracket under the cursor
 D                  " Delete everything from here to the end of the line
  V                 " Visually select this whole line
   r<C-a>           " Replace each character in this selection with `<C-a>`
                    " This conveniently places the cursor on the first char also
         C          " Delete this whole line into register '"', and enter insert mode
          1<esc>    " Enter a '1' and escape to normal mode
                @"  " Run the text in register '"' as if typed. Since the `<C-a>` command
                    " Will increment the number currently under the cursor

果冻，11 10 9字节

O’&2’+\i0

在线尝试！

说明

这里的想法是找到一个可以区分开括号和闭括号的“魔术公式”。我最初使用O%7&2（即“采用ASCII码，取模7，按位和2”），但是建议O’&2使用@ETHproductions （用减量替换模7）。两者都返回0表示一种括号，返回2表示另一种。减去1（’）将使结果变成-1和1。

其余代码为+\。+\产生累计和。如果一组括号正确匹配，它将包含相同数量的-1和1，即其累加总和为0。然后，我们只需要返回结果列表中前0的索引即可；我们可以用做到这一点i0。

视网膜，26 24字节

M!`^.(?<-1>([[({<])*.)*

在线尝试！

结果基于1。

说明

完全不同的Retina解决方案，该解决方案基本上基于单个（且易读...）正则表达式。这使用了我昨天发现的一种新技术，用于使用平衡组匹配平衡的字符串。

M!`^.(?<-1>([[({<])*.)*

查找（M）并返回（!）正则表达式的所有匹配项^.(?<-1>([[({<])*.)*。该正则表达式会跳过字符串的第一个字符，然后使用平衡组来跟踪嵌套深度。任何的[({<增加的深度（保持在由组的轨道1），以及任何其他字符减小的深度（在原则上，.允许深度通过开口括号以及被降低，但是由于正则表达式是贪婪地匹配时，backtracker将永远不会尝试该）。怪异的窍门是(?<-1>...)封闭的组1起作用，因为从平衡组弹出的事件发生在该组的末尾。与标准方法相比，此格式节省了两个字节((open)|(?<-2>close))*。比赛一定会停在第一个括号附近，因为我们跳过了它，因此它不在堆栈深度中考虑（堆栈深度不能为负）。

匹配的长度是我们要查找的括号的从0开始的索引。

只需计算此字符串中的空匹配数即可。空的正则表达式总是匹配一次，而不是字符串中有任何字符，因此这为我们提供了要查找的括号的从1开始的索引。

视网膜，24字节

.(([[({<])|(?<-2>.))*$

在线尝试！

这是受到Martin Ender解决方案的启发。

说明

第一行是一个正则表达式，它与一个字符匹配，后跟一个平衡字符串，一直到主字符串的末尾（有关此正则表达式中如何使用平衡组的详细说明，请参见Martin的回答）。由于正则表达式从左到右查找匹配项，因此它将找到最长的平衡适当子前缀，即在关闭第一个括号的括号之后的所有内容，再加上括号本身。

下一行是空的，因此我们将匹配替换为空字符串，这意味着我们现在只需要计算其余字符即可获得（索引为0的）所需结果。

最后一个空行计算字符串中的空字符串的匹配数，该数量比字符串中的字符数多一个，等于1索引的结果。

Perl 5，28个字节

用Martin Ender的Retina answer中的 just .代替保存了6个字节。[>})\]]

27个字节的代码+ -p标志。

/([<{([](?0)*.)+?/;$_=$+[0]

在线尝试！

递归正则表达式，多么美丽的发明。
正则表达式将查找左括号（[<{([]），然后是递归调用（?0），然后是右括号（.）。所有这些非贪婪（+?），因此从一开始就匹配尽可能短的内容。比赛结束的索引就是答案，碰巧的是，它可以在中找到$+[0]。

JavaScript（ES6），55 53 52字节

@Adnan节省了1个字节

f=([c,...s],i=1)=>(i-=-c.charCodeAt()&2)&&1+f(s,++i)

对于每个左括号，采用其字符代码mod 4得出0或3；对于右括号，它给出1或2。因此，我们可以通过对括号的字符代码求反（将位翻转并减去1）并取第二个最低有效位来区分开括号和闭括号。即n&2。

C，75 72 56 55 54 45字节

a;f(char*s){return(a-=(-*s++&2)-1)?1+f(s):0;}

看到它在网上工作。

如果你想输出为1索引，而不是0索引，替换最后0用1。

Python 2.7 + Numpy，85 79字节

我第一次尝试打高尔夫球：

from numpy import*
lambda s:list(cumsum([(ord(x)+1&2)-1for x in s])).index(0)

Brain-Flak，97个字节（代码96个，标志1个）

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

与-a标志一起运行。

在线尝试！

说明：

#Skip the first open bracket 
{}

#Place a 1 on stack B, representing the nesting depth
<>(())

#Start a loop, until the depth is 0
({<

 #Divide the ASCII code by 2, rounding up
 (<()>)<>({<({}[()])><>([{}]())<>}{})<>

 #Replace TOS B with a 1
 (<{}>())

 #Swap back to stack A
 <>

 #Negate the 1 on stack B n times (n = ASCII value+1/2)
 {({}[()])<>([{}])<>}{}

 #Swap back to stack B
 <>

 #Add the 1/-1 (depending on Open/close bracket) to the nesting depth accumulator
 ({}{})

 #Count loop cycles
 >()

#end loop, print result implicitly by pushing to the stack 
}{}) 

就是这样，好的。

视网膜，34字节

^.
!
T`([{}])`<<<>
+T`p`!`<!*>
\G!

在线尝试！

结果是从0开始的。

说明

^.
!

将第一个字符替换为!。这将导致我们要查找的括号不匹配。

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

将括号，方括号和大括号转换为尖括号。由于可以保证字符串完全匹配，因此我们根本不在乎实际的类型，并且在下一步中节省了一些字节。

+T`p`!`<!*>

重复（+）中的所有匹配替换每个字符<!*>用!秒。也就是说，我们匹配不包含其他未处理括号的成对括号，并将它们变成进一步的感叹号。这会将除不匹配的右括号之外的整个字符串变成感叹号。

\G!

计算前导感叹号的数量，该数量等于第一个非感叹号（即不匹配的括号）从0开始的位置。该\G锚每场比赛前一个，这就是为什么这种不计!上述支架后秒。

PHP，116字节

for($l=["("=>")","["=>"]","{"=>"}","<"=>">"][$f=$argn[0]];;$d>0?$i++:die("$i"))$d+=$f!=($n=$argn[$i])?$n==$l?-1:0:1;

在线版本

Python，76个字节

f=lambda s,r=[],i=0:(i<1or sum(r))and f(s[1:],r+[(ord(s[0])+1&2)-1],i+1)or i

递归函数，使用序数第二个LSB作为Adnan（甚至可能是其他人）发现的许多技巧使用的打开与关闭技巧的标志。当-1打开和1关闭的累积总和达到零时，将命中尾巴。与使用相比len(r)，索引保留在变量中，因为它比字节更便宜，索引基于1。

在线尝试！

Ruby，35个 34字节

p$_[/[<{(\[](\g<0>)*[>})\]]/].size

基于Dada的Perl5答案。输出为1索引。要求使用-n选项（隐式）调用Ruby解释器。while gets循环）。

编辑：这也是35 34字节，但这是进一步减少此答案的另一个可能的起点。

p$_[/[<{(\[](\g<0>)*[>})\]]/]=~/$/

Edit2：在之后删除了不必要的空格p。

Edit3：还有更多的34字节答案。

~/[<{(\[](\g<0>)*[>})\]]/;p$&.size
p~/[<{(\[](\g<0>)*[>})\]]/+$&.size

Python 3中，59个 55 50 49字节

f=lambda s,n=1:n and-~f(s[1:],n+1-(-ord(s[1])&2))

输出为0索引。确定括号方向的公式最早由@ETHProductions发现，并由@Adnan改进。

在线尝试！

批次，172个字节

@set/ps=
@set/ai=d=0
:l
@set/ai+=1,d-=1
@set c="%s:~,1%"
@set "s=%s:~1%
@for %%a in ("<" "(" "[" "{")do @if %%a==%c% set/ad+=2&goto l
@if %d% gtr 0 goto l
@echo %i%

1个索引。<>s当然是批处理中的特殊字符，因此，不仅必须全引号，而且甚至不能做一些使它们成为goto标签的技巧。

R，126字节

s=readline();i=0;r=0;for(c in strsplit(s,"")[[1]]){if(grepl("[\\[\\(\\{<]",c))i=i+1 else i=i-1;if(i==0){print(r);break};r=r+1}

C，127个字节

在线尝试

c(x){x-40&x-60&x-91&x-123?-1:1;}
f(i,t)char*t;{return i?f(i+c(*t),t+1):t;}
s(char*t){return f(c(*t),t+1)-t;}

输出量

2   ()
4   (<>)
8   <[]{<>}>
2   {}{}{}{}
8   [[]<>[]]