Se le dará una cadena s. Se garantiza que la cadena tiene igual y al menos un [sy ]s. También se garantiza que los soportes estén equilibrados. La cadena también puede tener otros caracteres.

El objetivo es de salida / devolver una lista de tuplas o una lista de listas que contienen índices de cada [y ]par.

nota: la cadena está indexada a cero.

Ejemplo: !^45sdfd[hello world[[djfut]%%357]sr[jf]s][srtdg][]debería volver

[(8, 41), (20, 33), (21, 27), (36, 39), (42, 48), (49, 50)]o algo equivalente a esto. Las tuplas no son necesarias. Las listas también se pueden utilizar.

Casos de prueba:

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)]

Este es el código de golf , por lo que gana el código más corto en bytes para cada lenguaje de programación.

Brain-Flak Classic , 108 bytes

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

Pruébalo en línea!

Almacena cada apertura [en la pila correcta, y genera cada vez que golpeamos a ].

Python 2 , 74 bytes

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

Pruébalo en línea!

JavaScript, 69 62 bytes

Un poco de golf en el tren a casa. Probablemente se puede mejorar.

Toma la entrada como una matriz de caracteres y genera un objeto con las claves como los índices de [sy sus valores son los índices de sus ]s correspondientes .

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

Pruébalo en línea

Haskell , 92 79 bytes

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

Pruébalo en línea!

Explicación

Creamos una función gque toma 3 argumentos.

• a, que es la ubicación de todos los [s no coincidentes.

• n, que es el número de caracteres procesados

• x que son los caracteres sin procesar.

Si nuestro primer personaje es ]quitamos udel frente nuestro ay devolvemos (u,n)más lo que queda.

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

Si nuestro primer personaje no es ], eso es uno [u otro, incrementamos ny agregamos [n|s=='[']al frente de a. [n|s=='[']será [n]si s=='['y de lo []contrario.

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

Si no tenemos caracteres, devolvemos la lista vacía.

g[]_[]=[]

Java 10, 95 bytes

Un lambda vacío que toma la cadena de entrada como un int[]punto de código Unicode.

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

Pruébalo en línea

Sin golf

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

Expresiones de gratitud

• Gracias a Jonathan Frech por la idea de usar la cadena de entrada como una pila ( aquí )

vim, 89 bytes

: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

Anotado

: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>es 0x16. <C-M>es 0x0d. <C-X>es 0x18.

Pruébalo en línea!

QBasic (QB64), 137 127 112 bytes

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

Necesitamos cuatro dos bytes porque el desafío requiere indexación 0. Mi primera publicación de QBasic, agradecemos sus comentarios.

• 10 bytes gracias a steenbergh
• 3 bytes gracias a Erik the Outgolfer
• 12 bytes guardando en formato de archivo unix ( \r\n-> \n)

Se ve así cuando se ejecuta:

Pyth, 26 bytes

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

Pruébalo aquí

Explicación

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 , 141133115115108 bytes

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

Pruébalo en línea!

Nada especial. 1 indexado, porque lo dije. R realmente no tiene pilas, por lo que utiliza un principio c, heady tailpara conseguir el mismo efecto literal. Versión original sin golf (las actualizaciones se utilizan utf8ToIntpara eliminar algunos bytes, el inicio del vector como la parte superior de la pila Ty el uso Findebido e integrado para evitar la inicialización de las pilas):

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

Adelante (gforth) , 75 bytes

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

Pruébalo en línea!

Abusa de la pila de punto flotante, pero permite usar un do loopdado que el código no toca (manualmente) la pila de retorno.

Explicación

1. Recorrer caracteres en cadena
2. Comprueba cada personaje
   1. Si es igual a [, poner en la pila de coma flotante
   2. si es igual al ]pop de la pila de coma flotante y la salida con la posición actual

Explicación del código

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

Retina , 36 bytes

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

Pruébalo en línea! Explicación:

L

Genera una lista a partir de los resultados del partido.

$

Use la siguiente sustitución para generar la lista en lugar de las coincidencias.

v`

Permita que las coincidencias se superpongan.

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

Esta es una aplicación de los grupos de equilibrio de .NET. El [coincide literalmente, luego se consumen tantos caracteres como sea posible. A medida que [se empareja cada subsiguiente , la coincidencia se agrega a la $2pila. Si esa pila no está vacía, podemos hacer coincidir a ], eliminando la coincidencia de la pila. De lo contrario, podemos hacer coincidir cualquier cosa que no sea un ]( [ya se hizo coincidir anteriormente). La coincidencia se detiene cuando se encuentra con la coincidencia ]para el [, ya que la $2pila está (ahora) vacía en ese punto.

$.`,$.>`

La sustitución consta de dos variables separadas por una coma. El .indica que la longitud de la variable, en lugar de su valor, ser utilizado. El >indica que la variable debe ser evaluado en términos del separador de la derecha en lugar de partido. La $`variable se refiere al prefijo de la coincidencia, lo que significa $.`da la posición de [; el >modificador modifica esto al prefijo del separador derecho de la coincidencia, que proporciona la posición de la coincidencia ].

Jalea ,  22 21 20  19 bytes

^{Sin duda, es posible en Jelly en la mitad de este conteo de bytes: p ...}

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

Un enlace monádico que acepta una lista de caracteres que devuelve una lista de listas de enteros.
Como programa completo, acepta una cadena e imprime una representación de dicha lista.

Pruébalo en línea!

¿Cómo?

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-Prolog 254 bytes

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

Ejemplo:

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

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

Pruébalo en línea!

Explicación

Para realizar un seguimiento de los índices de cadena del paréntesis de apertura, la cadena de entrada se sobrescribe y se usa como una pila.

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

Pruébalo en línea!

Jalea , 20 bytes

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

Pruébalo en línea!

Tiene un efecto secundario en el registro, espero que sea una función.

Japt v1.4.5, 23 bytes

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

Pruébalo en línea!

Desempaquetado y cómo funciona

;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

La salida es una matriz aplanada de [closing index, opening index]. Si no se desea el orden inverso, agregar wal final hace el trabajo (+1 bytes).

Lisp común, 95 bytes

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

huellas dactilares:

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

K (ngn / k) , 38 37 bytes

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

Pruébalo en línea!

{ } funcionar con argumento x

"[]"=\:xdos listas booleanas para las ocurrencias de "["y"]"

a: asignar a a

|/ booleano "o" de las dos listas

& ¿Dónde (en qué índices) están los corchetes?

b: asignar a b

-/una lista con 1 para "[", -1 para "]"y 0 en todas partes

+\ sumas parciales

|': máximo en pares (cada elemento maximizado con el anterior, el elemento inicial permanece igual)

Esto representa la profundidad del soporte para cada personaje. Lo indexamos con b(la yuxtaposición es indexación) y obtenemos la profundidad del paréntesis solo para los paréntesis.

= "agrupar por": un diccionario que asigna las profundidades a los índices en los que ocurren

,/ concatenar los valores en el diccionario, ignorando las claves

0N 2# remodelar a una matriz de 2 columnas (lista de listas)

b@indice bcon cada elemento de la matriz

Jalea , 20 18 bytes

Guardado 1 byte gracias a @ user202729 que me informa que µ€es)

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

Pruébalo en línea!

Después de luchar con esto durante varias horas solo para que funcione ... Estoy sinceramente sorprendido de que se haya vuelto tan corto :-)

Explicación

ẹⱮØ[µ³ḣċþØ[_/Ụị)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 bytes

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

Sorprendentemente competitivo: pierde solo ante Japt y Jelly [ Editar : y Carbón y Stax :(]

Pruébalo en línea!

Explicación

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.

Python 2 , 109 bytes

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

Pruébalo en línea!

Pyth ,  28  26 bytes

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

Banco de pruebas.

Por el momento es más largo que el enfoque de Mnemonic , pero siento que puedo jugar golf un poco y, afortunadamente, tampoco utiliza estructuras de pitón imperativo comoV . La versión inicial era de 36 bytes y también tenía numerosos errores.

Cómo funciona

{I # .e, t + lhfSI / LT`Y + ._> Qk \] - Programa completo. Toma una cadena Q entre comillas de STDIN.
   .e - Mapa enumerado. k = índice de iteración, b = elemento actual.
                     > Qk: obtiene los elementos de Q en índices mayores que k.
                   ._ - Genera todos los prefijos de esto.
                  + \] - Y agrega un "]" (para manejar algunos casos extremos).
          f - Filtrar sobre esta lista, con T = elemento actual.
              L `Y - Para cada carácter en str ([])," [] "...
             / T - ... Cuenta las ocurrencias en T.
           SI: y compruebe si los valores se ordenan cada vez más.
         h - Cabeza. Recupera el primer elemento.
       + l - Obtenga la longitud de este + k.
      t - Disminución (en 1).
     , - Y empareja este valor con k. Devuelve [i, k] donde estoy
                             el índice del correspondiente] yk es el de [.
  # - Filtra esta lista por:
{I - El par es invariante sobre la deduplicación.

Perl 5, 53 bytes

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

Corre como perl -nE '<above code snippet>'. Toma entrada a través de stdin.

Como de costumbre, la solución Perl óptima para el problema es una expresión regular. Intentamos hacer coincidir cualquier par de paréntesis que no contenga ningún par dentro de él usando una clase de personaje bastante tonta ( s/\[[^][]*\]/.../). Si la coincidencia es exitosa, reemplazamos el texto coincidente con el dígito 1una y otra vez para que no coincidamos accidentalmente con esos corchetes e imprimimos los índices de la coincidencia. Enjuague y repita.

Stax , 13 bytes

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

Ejecutar y depurarlo

Utiliza la pila de entrada para rastrear pares de llaves abiertas. Aquí está el programa desempaquetado, sin golf y comentado.

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

Ejecute este

Carbón de leña , 20 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

ＦＬθ

Recorra el rango implícito de la longitud de la cadena de entrada.

≡§θι

Enciende el personaje actual.

[⊞υι

Si es un, [entonces empuje el índice actual a la variable de matriz predefinida.

]«Ｉ⊟υ,Ｉι⸿

Si es un a ]continuación, haga estallar el último índice de la variable de matriz e imprímalo junto con el índice actual separados por una coma y comience una nueva línea. Los formatos de salida alternativos, si son aceptables, ahorrarían algunos bytes: ]Ｉ⟦⊟υιωahorra 2 bytes pero imprime cada índice en una línea separada, con doble espacio entre los pares de índices; ]Ｉ⟦⊟υιsimplemente imprime los índices en líneas separadas, lo que dificulta distinguirlos.