Algoritmo de coincidencia de paréntesis de Golf A

25

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 , por lo que gana el código más corto en bytes para cada lenguaje de programación.

Galletas de molino de viento
fuente
1
¿Importa el orden de salida?
wastl
1
No, no lo hace.
Windmill Cookies
21
"nota: la cadena está indexada a cero". - Es muy común permitir que las implementaciones elijan una indexación consistente en este tipo de desafíos (pero, por supuesto, depende de usted)
Jonathan Allan
1
¿Podemos tomar la entrada como una matriz de caracteres?
Shaggy
77
Cuesta un byte ...
dylnan

Respuestas:

13

Brain-Flak Classic , 108 bytes

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

Pruébalo en línea!

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

Nitrodon
fuente
5

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

Lanudo
fuente
Me sorprende que puedas jugar golf en el móvil. : P
Oliver
2
@Oliver, sopla mi mente que puedo (casi) el tipo de pantallas táctiles en absoluto - traer de vuelta a los teclados!
Shaggy
4

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[]_[]=[]
Asistente de trigo
fuente
1
wow, esa es una buena pieza de funciones recursivas. Soy un principiante en Haskell, esto me impresionó :)
Windmill Cookies
@ gnu-nobody ¡Gracias! Esta respuesta probablemente no sea óptima, por lo que le animo a que intente superarla o espere hasta que lleguen los golfistas serios de Haskell.
Wheat Wizard
Mejor espero hasta que lleguen los golfistas serios de Haskell
Windmill Cookies
4

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í )
Jakob
fuente
Debe definir ry wcomo parte del código, no como parámetros: s->{int r=0,w=0;...}.
Olivier Grégoire
@ OlivierGrégoire tipo de ambigüedad, pero este parece que fue destinada a cubrir varias entradas vacías.
Jakob
1
La respuesta que cita explícitamente responde a la pregunta "¿Se nos permite tomar un parámetro vacío en lugar de que no lo usemos en ningún lado ?". Estás usando estas entradas. No veo ninguna ambigüedad en absoluto aquí.
Olivier Grégoire
La parte de edición de la pregunta lo hace absolutamente inequívoco acerca de la "no utilización" de la variable.
Olivier Grégoire
Correcto, pero ¿por qué la respuesta principal (1) no establece que las entradas no se usan, (2) especifica cuáles son los valores de las entradas adicionales y (3) menciona la posibilidad de abusar de las entradas adicionales? De todos modos, moveré las variables.
Jakob
4

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!

Rayo
fuente
4

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:

Como luce

wastl
fuente
Buena esa. Par de punteros: use en ?lugar de print(el compilador lo expande automáticamente print), no necesita los espacios entre las cadenas citadas y THENen la IFs, y puede soltar el iafter NEXT.
steenbergh
@steenbergh Huh, parece que olvidé eliminar el espacio en blanco ... pero eliminé el que está entre 0y to? Estoy confundido ...
Wastl
1
No estoy seguro acerca de QB64, pero creo que if c$="["puede convertirse if"["=c$, elseif c$="]"puede convertirse elseif"]"=c$, end ifpuede convertirse endify, con un ligero cambio en la salida, ?b(n),ipuede convertirse ?b(n)i(QBasic 1.1 es lo que uso, su caso podría ser diferente).
Erik the Outgolfer
@EriktheOutgolfer todo pero ?b(n)ifuncionó
wastl
3

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.

fuente
¡Agradable! Mi enfoque ingenuo era de 36 bytes, C,x"[" MQ #.e*qb\[t+lhfSI/LT"[]"._>Q. Editar: También tuve éxito jugando al golf, ahora tengo menos de 30.
Sr. Xcoder
3

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.
}
ngm
fuente
y 1:nchar(y)es más corto que seq_along(x). Muy buena solución por cierto :)
JayCe
Me pregunto si gregexpres el camino a seguir.
ngm
Originalmente había tratado de aprovechar este enfoque, pero no estoy seguro de si esta es la forma correcta aquí.
JayCe
La solución JayCe es defectuosa (verifique el resultado, regresa en 22 28 22lugar de 22 28 21) probablemente el uso (ab) de T / F no es realmente seguro: D. Esto es más corto y parece funcionar -> ¡ Pruébelo en línea!
digEmAll
2

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
reffu
fuente
2

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

Neil
fuente
2

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]]
Jonathan Allan
fuente
Estaba tratando de usar œ¿y son parientes, pero no pude encontrar una solución. Esto fue lo más cerca que tuve.
dylnan
Sí, puede ser más corto, pero solo logré un byte miserable , no la mitad de los bytes. Todavía se siente demasiado tiempo. :(
Erik the Outgolfer
@EriktheOutgolfer, aquí también fue fácil guardar 1 byte
Jonathan Allan
2

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 
Jan Drozen
fuente
1

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!

Jonathan Frech
fuente
1

Jalea , 20 bytes

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

Pruébalo en línea!

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

Erik el Outgolfer
fuente
Es reutilizable, así que creo que está bien. Las respuestas de BF no suelen dejar la cinta en blanco
dylnan
1

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

Bubbler
fuente
1

Lisp común, 95 bytes

(lambda(u &aux s)(dotimes(p(length u))(case(elt u p)(#\[(push p s))(#\](print`(,(pop s),p))))))
Versión larga
(defun par (string &aux stack)
  (dotimes (pos (length string))
    (case (char string pos)
      (#\[ (push pos stack))
      (#\] (print (list (pop stack) pos))))))
Pruebas
((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)
volcado de memoria
fuente
1

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

ngn
fuente
1

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]]
ETHproducciones
fuente
1

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.
Fruta Esolanging
fuente
0

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.
Sr. Xcoder
fuente
{I#.e,t+lhfSI/LT`Y._>Q casi funciona para 22 bytes ...
Sr. Xcoder
0

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.

Silvio Mayolo
fuente
0

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

recursivo
fuente
0

Carbón de leña , 20 bytes

FLθ≡§θι[⊞υι]«I⊟υ,Iι⸿

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

FLθ

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.

]«I⊟υ,Iι⸿

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: ]I⟦⊟υιωahorra 2 bytes pero imprime cada índice en una línea separada, con doble espacio entre los pares de índices; ]I⟦⊟υιsimplemente imprime los índices en líneas separadas, lo que dificulta distinguirlos.

Neil
fuente