당신은 문자열이 제공 s됩니다. 문자열은 적어도 하나 이상의 [s와 ]s를 갖습니다 . 브래킷이 균형을 이루도록 보장됩니다. 문자열은 다른 문자를 가질 수도 있습니다.

목적은 출력 인 / 튜플리스트 또는 각각의 지표 함유리스트 목록을 반환 [하고 ]한쌍.

참고 : 문자열은 인덱스가 0입니다.

예 : !^45sdfd[hello world[[djfut]%%357]sr[jf]s][srtdg][]반환해야합니다

[(8, 41), (20, 33), (21, 27), (36, 39), (42, 48), (49, 50)]또는 이것과 동등한 것. 튜플은 필요하지 않습니다. 리스트도 사용할 수 있습니다.

테스트 사례 :

input:[[asdf][][td([)ty54g% ]hg[[f]u][f[[jhg][gfd]sdf]sdfs]ghd]fr43f]
output:[(0, 62),(1, 6), (7, 8), (9, 56), (13, 22), (25, 30), (26, 28), (31, 52), (33, 47), (34, 38), (39, 43)]
input:[[][][][]][[][][][[[[(]]]]]))
output:[(0, 9), (1, 2), (3, 4), (5, 6), (7, 8), (10,26),(11, 12), (13, 14), (15, 16), (17, 25), (18, 24), (19, 23), (20, 22)]
input:[][][[]]
output:[(0, 1), (2, 3), (4, 7), (5, 6)]
input:[[[[[asd]as]sd]df]fgf][][]
output:[(0, 21), (1, 17), (2, 14), (3, 11), (4, 8), (22, 23), (24, 25)]
input:[]
output:[(0,1)]
input:[[(])]
output:[(0, 5), (1, 3)]

이것은 code-golf 이므로 각 프로그래밍 언어에 대한 가장 짧은 바이트 단위의 코드가 이깁니다.

Brain-Flak Classic , 108 바이트

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

온라인으로 사용해보십시오!

각 개구부 [를 오른쪽 스택에 저장하고에 도달 할 때마다 출력합니다 ].

파이썬 2 , 74 바이트

s=[];i=0
for c in input():
 if'['==c:s+=i,
 if']'==c:print s.pop(),i
 i+=1

온라인으로 사용해보십시오!

자바 스크립트, 69 62 바이트

기차의 집에서 골프의 빠른 비트. 아마 향상 될 수 있습니다.

입력을 문자의 배열로 취하여 키가 [s의 인덱스이고 값이 해당 ]s 의 인덱스 인 객체를 출력합니다 .

a=>a.map((x,y)=>x==`]`?o[a.pop()]=y:x==`[`&&a.push(y),o={})&&o

온라인으로 사용해보십시오

하스켈 , 92 79 바이트

g(u:a)n(']':x)=(u,n):g a(n+1)x
g a n(s:x)=g([n|s=='[']++a)(n+1)x
g[]_[]=[]
g[]0

온라인으로 사용해보십시오!

설명

우리 g는 3 개의 인수를 취하는 함수 를 만듭니다 .

• a일치하지 않는 모든의 위치입니다 [.

• n처리되는 문자 수

• x 처리되지 않은 문자입니다.

첫 번째 캐릭터라면 앞면에서 ]제거 u하고 남은 것은 그대로 a반환 (u,n)합니다.

g(u:a)n(']':x)=(u,n):g a(n+1)x

첫 번째 문자가 아닌 경우 ], 즉 앞 [또는 뒤에 n추가 [n|s=='[']됩니다 a. [n|s=='[']될 것입니다 [n]경우 s=='['와 []그렇지 않은 경우.

g a n(s:x)=g([n|s=='[']++a)(n+1)x

문자가 없으면 빈 목록을 반환합니다.

g[]_[]=[]

자바 10, 95 바이트

입력 문자열 int[]을 유니 코드 코드 포인트 로 사용하는 void 람다 .

s->{int r=0,w=0;for(var c:s){if(c==91)s[w++]=r;if(c==93)System.out.println(s[--w]+","+r);r++;}}

온라인으로 사용해보십시오

언 골프

s -> {
    int r = 0, w = 0;
    for (var c : s) {
        if (c == 91)
            s[w++] = r;
        if (c == 93)
            System.out.println(s[--w] + "," + r);
        r++;
    }
}

감사의 말

• 입력 문자열을 스택으로 사용한다는 아이디어를 얻은 Jonathan Frech에게 감사드립니다 ( here )

vim, 89 바이트

:s/\(.\)/\1<C-V><C-M>/g|g/^\[/ :norm %mm%:pu! =line('.').','.line(\"'m\")<C-V><C-M><C-X>$<C-X>J
:v/\[/d|%s/\[//g

주석이 달린

:s/\(.\)/\1<C-V><C-M>/g            " one character per line
|g/^\[/                            " for each opening square bracket:
  :norm %mm%                       "   mark the line with the matching bracket
  :pu! =line('.').','.line(\"'m\") "   write the line numbers to preceeding line
  <C-V><C-M><C-X>$<C-X>J           "   convert to 0-based counting and join lines
:v/\[/d                            " remove all non-opening bracket lines
|%s/\[//g                          " remove brackets

<C-V>0x16입니다. <C-M>0x0d입니다. <C-X>0x18입니다.

온라인으로 사용해보십시오!

QBASIC (QB64), 137 (127) 112 바이트

INPUT a$
for i=0to len(a$)
c$=mid$(a$,i+1,1)
if"["=c$then
b(n)=i
n=n+1
elseif"]"=c$then
n=n-1
?b(n),i
endif
next

챌린지에 0 인덱싱이 필요하기 때문에 4 개의 2 바이트 가 필요 합니다. 내 첫 번째 QBasic 게시물, 피드백에 감사드립니다.

• steenbergh 덕분에 10 바이트
• Outgolfer Erik 덕분에 3 바이트
• 유닉스 파일 형식 ( \r\n-> \n) 으로 저장하여 12 바이트

실행될 때 다음과 같이 보입니다.

Pyth, 26 바이트

VQIqN\[=+YZ)IqN\],.)YZ)=hZ

여기 사용해보십시오

설명

VQIqN\[=+YZ)IqN\],.)YZ)=hZ
VQ                     =hZ   For each character in the input (indexed by Z)...
  IqN\[=+YZ)                 ... if the character is [, add the index to Y...
            IqN\],.)YZ)      ... if the character is ], output the previous index
                             and current index.

R , 141133115112108 바이트

function(y,x=utf8ToInt(y)){for(i in seq(x)){if(x[i]==91)F=c(i,F);if(x[i]==93){T=c(T,F[1],i);F=F[-1]}};T[-1]}

온라인으로 사용해보십시오!

특별한 것은 없습니다. 내가 말했기 때문에 1- 색인. R 내가 원래 사용, 그래서 정말, 스택이없는 c, head그리고 tail같은 문자 그대로의 효과를 얻을 수 있습니다. ungolfed 원본 버전 ( utf8ToInt벡터의 시작을 스택의 맨 처음으로 사용하고 스택 을 초기화하지 않도록 학대 T및 F내장을 사용하여 일부 바이트를 제거 하는 데 사용 하는 업데이트 ) :

f <- function(y, x=el(strsplit(y,""))) {
  p <- l <- NULL
  for(i in seq_along(x)) {
    if(x[[i]]=='[') {
      p <- c(p, i)
    }
    if(x[[i]]==']') {
      l <- c(l, tail(p, 1), i)
      p <- head(p, -1)
    }
  }
  l # Because I said so. Change to l-1 if you want to check the test cases.
}

넷째 (gforth) , 75 바이트

: f 0 do dup i + c@ dup 91 = if i s>f then 93 = if f>s . i . cr then loop ;

온라인으로 사용해보십시오!

부동 소수점 스택을 남용하지만 do loop코드가 수동으로 리턴 스택을 건드리지 않기 때문에를 사용할 수 있습니다 .

설명

1. 문자열에서 문자를 반복
2. 각 문자를 확인
   1. 같으면 [부동 소수점 스택
   2. ]부동 소수점 스택에서 팝 과 같고 현재 위치로 출력하는 경우

코드 설명

0 do                 \ start a loop from 0 to string-length
  dup                \ duplicate the starting address to avoid losing it
  i + c@             \ get the address of the current position and retrieve the character
  dup                \ duplicate the character, to allow checking twice
  91 = if            \ if char = [
    i s>f            \ store the current address on the floating point stack
  then               \ end the if-statement
  93 = if            \ if char = ]
    f>s .            \ pop the starting position from the float-stack and print
    i .              \ print the current position
    cr               \ output a newline
  then               \ end the if-statement
loop                 \ end the loop

레티 나 , 36 바이트

L$v`\[((\[)|(?<-2>])|[^]])*
$.`,$.>`

온라인으로 사용해보십시오! 설명:

L

일치 결과에서 목록을 생성하십시오.

$

일치하는 대신 목록을 생성하려면 다음 대체를 사용하십시오.

v`

일치하는 항목을 겹치게합니다.

\[((\[)|(?<-2>])|[^]])*

이것은 .NET 밸런싱 그룹의 응용 프로그램입니다. 이 [그대로 일치, 가능한 한 많은 문자가 소비되고 다음으로. 각 후속 항목 [이 일치하면 일치 항목이 $2스택에 추가됩니다 . 해당 스택이 비어 있지 않으면를 ]일치시켜 스택에서 일치 항목을 제거 할 수 있습니다 . 그렇지 않으면, 우리는 ]( [이미 이전에 일치했던) 것이 아닌 것을 일치시킬 수 있습니다 . 스택이 현재 시점에서 비어 있기 때문에 일치하는가에 대한 일치 ]를 충족하면 중지됩니다 .[$2

$.`,$.>`

대체는 쉼표로 구분 된 두 개의 변수로 구성됩니다. 는 .가변의 길이, 값보다는 사용될 것을 나타낸다. 는 >변수 우측 분리기보다는 매치의 관점에서 평가 될 것을 나타낸다. $`가변 수단에 매치의 프리픽스를 말한다 $.`의 위치를 제공한다 [; >매칭의 위치를 제공하는 매치 오른쪽 세퍼레이터의 프리픽스 수정이 달라져 ].

젤리 ,  22 21 20  19 바이트

^{의심 할 여지없이 Jelly 에서이 바이트 수의 절반으로 가능합니다 : p ...}

n€Ø[ḅ-µMịÄÐƤi€0ĖƊ’Ä

정수 목록을 리턴하는 문자 목록을 승인하는 모나드 링크.
전체 프로그램으로서 문자열을 받아서 상기리스트의 표현을 인쇄합니다.

온라인으로 사용해보십시오!

방법?

n€Ø[ḅ-µMịÄÐƤi€0ĖƊ’Ä - Link: list of characters    e.g. "[f[o]o!]"
  Ø[                - list of characters = ['[', ']']
n€                  - not equal? for €ach              [[0,1],[1,1],[0,1],[1,1],[1,0],[1,1],[1,1],[1,0]]
                    -     ...relating to the characters:  [     f     [     o     ]     o     !     ]
    ḅ-              - convert from base -1             [1,0,1,0,-1,0,0,-1]
                    -     ...i.e.: 1 where '['; -1 where ']'; and 0 elsewhere
      µ             - start a new monadic chain with that as the argument, say V
                Ɗ   - last 3 links as a monad (function of V):
          ÐƤ        -   for post-fixes:
         Ä          -     cumulative sum               [[1,1,2,2,1,1,1,0],[0,1,1,0,0,0,-1],[1,1,0,0,0,-1],[0,-1,-1,-1,-2],[-1,-1,-1,-2],[0,0,-1],[0,-1],-1]
            i€0     -   1st index of 0 in €ach (or 0)  [8,1,3,1,0,1,1,0]
               Ė    -   enumerate                      [[1,8],[2,1],[3,3],[4,1],[5,0],[6,1],[7,1],[8,0]]
       M            - maximal indices of V             [1,3]
        ị           - index into                       [[1,8],[3,3]]
                 ’  - decrement                        [[0,7],[2,2]]
                  Ä - cumulative sum (vectorises)      [[0,7],[2,4]]

SWI- 프롤로그 254 바이트

d([']'|T],I,[S|Z],M,R):-J is I+1,d(T,J,Z,[',','(',S,',',I,')'|M],R).
d(['['|T],I,S,M,R):-J is I+1,d(T,J,[I|S],M,R).
d([_|T],I,S,M,R):-J is I+1,d(T,J,S,M,R).
d(_,_,_,R,R).
m(X):-atom_chars(X,A),d(A,0,[],[']'],[_|R]),atomic_list_concat(['['|R],S),print(S).

예:

?- m('!^45sdfd[hello world[[djfut]%%357]sr[jf]s][srtdg][]').
'[(49,50),(42,48),(8,41),(36,39),(20,33),(21,27)]'
true 

C (gcc) , 87 바이트

f(char*Z){for(char*z=Z,*q=z;*z;*z++-93||printf("%d,%d;",*--q,z-1-Z))*z-91||(*q++=z-Z);}

온라인으로 사용해보십시오!

설명

여는 괄호의 문자열 색인을 추적하기 위해 입력 문자열을 겹쳐 쓰고 스택으로 사용합니다.

f(char*Z){          // take mutable input string
 for(char*z=Z,*q=z; // copy pointer to current string index, current stack index
 *z;                // loop through the entire string
 *z++-93||          // if z == ']'
   printf("%d,%d;", // decrement stack pointer,
    *--q,z-1-Z))    //  write bracket pair position
  *z-91||           // if z == '['
   (*q++=z-Z);}     // write bracket position onto stack, increment stack pointer

온라인으로 사용해보십시오!

젤리 , 20 바이트

=©ⱮØ[_/aÄ$+®ŻĠḊẎ_2s2

온라인으로 사용해보십시오!

레지스터에 부작용이 있으므로 기능이 허용되기를 바랍니다.

Japt v1.4.5, 23 바이트

;Ë¥']?ApENo):D¥'[©NpE
A

온라인으로 사용해보십시오!

포장 풀기 및 작동 방식

;UmDE{D==']?ApENo):D=='[&&NpE
A

;                              Use alternative set of initial variables
                               A = [] is used here
 UmDE{                         Map over each char of input string...
      D==']?                     If the char is closing bracket...
            ApENo)                 Push the current index and N.pop() to A
                  :D=='[&&       Otherwise, if the char is opening bracket...
                          NpE      Push the current index to N

A     Output A

출력은의 전개 배열입니다 [closing index, opening index]. 반대 순서를 원하지 않는 경우 w끝에 추가 하면 작업이 수행됩니다 (+1 바이트).

공통 리스프, 95 바이트

(lambda(u &aux s)(dotimes(p(length u))(case(elt u p)(#\[(push p s))(#\](print`(,(pop s),p))))))

(defun par (string &aux stack)
  (dotimes (pos (length string))
    (case (char string pos)
      (#\[ (push pos stack))
      (#\] (print (list (pop stack) pos))))))

((lambda(u &aux s)(dotimes(p(length u))(case(elt u p)(#\[(push p s))(#\](print`(,(pop s),p))))))
 "!^45sdfd[hello world[[djfut]%%357]sr[jf]s][srtdg][] ")

인쇄물:

(21 27) 
(20 33) 
(36 39) 
(8 41) 
(42 48) 
(49 50)

K (ngn / k) , 38 37 바이트

{b@0N 2#,/=(|':+\-/a)b:&|/a:"[]"=\:x}

온라인으로 사용해보십시오!

{ } 인수 기능 x

"[]"=\:x"["and 의 발생에 대한 두 개의 부울리스트"]"

a: 할당하다 a

|/ 두 목록 중 부울 "또는"

& 대괄호는 어디에 있습니까 (어떤 인덱스에서)?

b: 할당하다 b

-/에 대해 1 "[", -1에 대한 목록 "]"및 0이 있는 목록

+\ 부분 합계

|': 한 쌍의 최대 값 (각 요소는 이전 요소와 최대 값이며 초기 요소는 동일 함)

각 문자의 대괄호 깊이를 나타냅니다. 우리는 b(juxtaposition is indexing)으로 색인을 작성하고 대괄호에 대해서만 대괄호 깊이를 얻습니다.

= "group by"-사전이 발생하는 인덱스에 깊이를 맵핑

,/ 키를 무시하고 사전에 값을 연결

0N 2# 2 열 행렬로 재구성 (목록 목록)

b@b행렬의 각 요소와 색인

젤리 , 20 18 바이트

@ user202729 1 개 바이트 덕분에 저장된 것을 저를 알리는 µ€것입니다)

ẹⱮØ[µ³ḣċþØ[_/Ụị)Z’

온라인으로 사용해보십시오!

몇 시간 동안이 문제를 해결하기 위해 이와 씨름 한 후 ... 정말로이 짧은 것을 얻었습니다.

설명

ẹⱮØ[µ³ḣċþØ[_/Ụị)Z’   Main link. Argument: s (string)  '[a[b]c[]][d]'
  Ø[                 Shortcut for the string "[]".
 Ɱ                   For each char in the "[]":
ẹ                      Find the indices of each occurrence in the input.
                     For our example, this gives the array [[1, 3, 7, 10], [5, 8, 9, 12]].

    µ                Begin a new monadic chain, with said array as its argument.
               )     For each of the two sub-arrays q within the array:
                         [[1, 3, 7, 10], [5, 8, 9, 12]]
     ³ḣ                For each item n in q, take the first n chars of the input.
                         [['[',     '[a[',      '[a[b]c[',   '[a[b]c[]]['],
                          ['[a[b]', '[a[b]c[]', '[a[b]c[]]', '[a[b]c[]][d]']]
        þØ[            For each string s in this, and each char c in "[]":
       ċ                 Count the occurrences of c in s.
                         [[[1, 0],  [2, 0],     [3, 1],      [4, 3]],
                          [[2, 1],  [3, 2],     [3, 3],      [4, 4]]]
           _/          Reduce each pair by subtraction. This is the number of open brackets
                         at each position.
                         [[1, 2, 2, 1], [1, 1, 0, 0]]
             U         Sort the indices by their values, using position as a tiebreaker.
                         [[1, 4, 2, 3], [3, 4, 1, 2]]
              ị        Index these values back into q.
                         [[1, 10, 3, 7], [9, 12, 5, 8]]

               )     Start a new monadic chain with the result as its argument.
                Z    Zip; transpose rows and columns.
                         [[1, 9], [10, 12], [3, 5], [7, 8]]
                 ’   Decrement; switch to 0-indexing.
                         [[0, 8], [9, 11], [2, 4], [6, 7]]

CJam , 25 바이트

0q{"[]"#"_ \p_p "S/=~)}/;

놀랍게도 경쟁-Japt와 Jelly에게만 패배 [ 편집 : and Charcoal and Stax :(]

온라인으로 사용해보십시오!

설명

0                          Push 0.
 q                         Push the input.
  {                   }/   For each character in the input:
   "[]"#                     Find index of this character in the string "[]" (or -1 if not found).
                   =         Use this index to choose
        "       "S/            one of the following snippets
                    ~          and execute it:
         _                       If it was 0 ('['), duplicate the number on the stack.
           \p_p                  If it was 1 (']'), print the current number and the one under it.
                                 If it was -1, do nothing.
                     )       Increment the number on top of the stack.
                        ;  Delete the number.

파이썬 2 , 109 바이트

def a(s,r=[],i=0):
 o=[]
 while i<len(s):exec["r+=[i]","o+=[(r.pop(),i)]",'']['[]'.find(s[i])];i+=1
 return o

온라인으로 사용해보십시오!

Pyth ,  28  26 바이트

{I#.e,t+lhfSI/LT`Y+._>Qk\]

테스트 스위트.

현재 Mnemonic의 접근 방식보다 깁니다. , 이것을 조금만 골라 내면 운 좋게도 마찬가지로 파이썬과 같은 구조를 사용하지 않습니다 V. 초기 버전은 36 바이트였으며 수많은 버그가있었습니다.

작동 원리

{I # .e, t + lhfSI / LT`Y + ._> Qk \] – 전체 프로그램. STDIN에서 인용 된 문자열 Q를 가져옵니다.
   .e – 열거 된 맵. k = 반복 인덱스, b = 현재 요소.
                     > Qk – k보다 큰 지수에서 Q의 원소를 구합니다.
                   ._ –이 접두사를 모두 생성합니다.
                  + \] – "]"를 추가합니다 (일부 대소 문자 처리).
          f – T = 현재 요소를 사용하여이 목록을 필터링합니다.
              L`Y – str ([])의 각 문자마다 "[]"...
             / T – ... T에서 발생 횟수를 센다.
           SI – 값이 점차 정렬되는지 확인하십시오.
         h – 머리. 첫 번째 요소를 검색하십시오.
       + l –이 + k의 길이를 얻습니다.
      t – 감소 (1 씩).
     , –이 값을 k와 쌍을 이룹니다. 여기서 i는 [i, k]를 반환합니다.
                             대응하는] 및 k의 지수는 [.
  # –이 목록을 다음 기준으로 필터링하십시오.
{I – 페어가 중복 제거에 대해 일정하지 않습니다.

펄 5, 53 바이트

say"$-[0] ".($+[0]-1)while s/\[[^][]*\]/1x length$&/e

로 실행하십시오 perl -nE '<above code snippet>'. stdin을 통해 입력을받습니다.

일반적으로 문제에 대한 최적의 Perl 솔루션은 정규식입니다. 다소 어리석은 문자 클래스 ( s/\[[^][]*\]/.../)를 사용하여 괄호 안에 포함되지 않은 괄호 쌍을 찾습니다 . 일치하는 경우 일치하는 텍스트를 1반복 해서 숫자로 반복 해서 바꾸어 실수로 해당 대괄호를 다시 일치시키지 않고 일치하는 인덱스를 인쇄합니다. 헹구고 반복하십시오.

Stax , 13 바이트

é√p(l▓1½\á²ë(

실행 및 디버깅

입력 스택을 사용하여 열린 버팀대 쌍을 추적합니다. 다음은 압축을 풀고 포장을 풀고 주석이 달린 프로그램입니다.

F       iterate over input characters
 .][I   get the index of the character in the string "[]", or -1
 ^|cv   skip the rest of this iteration if index was -1
 i~     push the current iteration index to the input stack
 C      skip the rest of this iteration if index was 0
 \      form a pair with the top two items from the input stack
 JP     join with space, and print

이것을 실행

숯 , 20 바이트

ＦＬθ≡§θι[⊞υι]«Ｉ⊟υ,Ｉι⸿

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

ＦＬθ

입력 문자열 길이의 암시 적 범위를 반복합니다.

≡§θι

현재 문자를 켭니다.

[⊞υι

이 경우 [현재 색인을 사전 정의 된 배열 변수로 푸시하십시오.

]«Ｉ⊟υ,Ｉι⸿

그렇다면 ]배열 변수에서 최신 색인을 팝하고 쉼표로 구분하여 현재 색인을 인쇄하고 새 줄을 시작하십시오. 허용되는 경우 대체 출력 형식으로 일부 바이트를 ]Ｉ⟦⊟υιω절약 할 수 있습니다. 2 바이트를 절약하지만 각 인덱스를 별도의 줄에 인쇄하여 인덱스 쌍을 두 배 간격으로 표시합니다. ]Ｉ⟦⊟υι색인을 별도의 행에 인쇄하기 때문에 구분하기가 어렵습니다.