Ti verrà data una stringa s. È garantito che la stringa abbia uguale e almeno uno [s e ]s. È inoltre garantito che le staffe siano bilanciate. La stringa può anche avere altri caratteri.

L'obiettivo è produrre / restituire un elenco di tuple o un elenco di elenchi contenenti indici di ciascuno [e ]coppia.

nota: la stringa è indicizzata a zero.

Esempio: !^45sdfd[hello world[[djfut]%%357]sr[jf]s][srtdg][]dovrebbe tornare

[(8, 41), (20, 33), (21, 27), (36, 39), (42, 48), (49, 50)]o qualcosa di equivalente a questo. Le tuple non sono necessarie. Le liste possono anche essere usate.

Casi test:

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

Questo è code-golf , quindi vince il codice più breve in byte per ciascun linguaggio di programmazione.

Brain-Flak Classic , 108 byte

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

Provalo online!

Memorizza ogni apertura [nello stack giusto e genera ogni volta che colpiamo a ].

Python 2 , 74 byte

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

Provalo online!

JavaScript, 69 62 byte

Un po 'di golf sul treno verso casa. Probabilmente può essere migliorato.

Prende l'input come una matrice di caratteri e genera un oggetto con le chiavi che sono gli indici delle se [i loro valori sono gli indici delle loro corrispondenti ].

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

Provalo online

Haskell , 92 79 byte

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

Provalo online!

Spiegazione

Creiamo una funzione g che accetta 3 argomenti.

• a, ovvero le posizioni di tutti senza pari [ s .

• n, che è il numero di caratteri elaborati

• x che sono i personaggi non elaborati.

Se il nostro primo personaggio è ], rimuoviamo udalla parte anteriore il nostro ae ritorniamo (u,n)più tutto ciò che rimane.

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

Se il nostro primo personaggio non lo è ], ovvero uno [o qualcos'altro, incrementiamo ne aggiungiamo [n|s=='[']in primo piano a. [n|s=='[']sarà [n]se s=='['e[] altrimenti.

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

Se siamo a corto di caratteri restituiamo la lista vuota.

g[]_[]=[]

Java 10, 95 byte

Un lambda vuoto che prende la stringa di input come uno int[]dei punti di codice 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++;}}

Provalo online

Ungolfed

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

Ringraziamenti

• grazie a Jonathan Frech per l'idea di usare la stringa di input come stack ( qui )

vim, 89 byte

: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

commentata

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

Provalo online!

QBasic (QB64), 137 127 112 byte

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

Abbiamo bisogno di quattro due byte perché la sfida richiede l'indicizzazione 0. Il mio primo post su QBasic, il feedback è apprezzato.

• 10 byte grazie a steenbergh
• 3 byte grazie a Erik the Outgolfer
• 12 byte salvando in formato file unix ( \r\n-> \n)

Assomiglia a questo quando eseguito:

Pyth, 26 byte

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

Provalo qui

Spiegazione

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 , 141 133 115 112 108 byte

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

Provalo online!

Niente di speciale. 1-indicizzato, perché l'ho detto. R in realtà non hanno le pile, quindi ho usato in origine c, heade tailper ottenere lo stesso effetto letterale. Versione originale non golfata (si aggiorna usando utf8ToIntper rimuovere alcuni byte, usando l'inizio del vettore come la parte superiore dello stack, e abusando Te Fincorporando per evitare l'inizializzazione degli stack.):

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

Forth (gforth) , 75 byte

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

Provalo online!

Abusa dello stack in virgola mobile, ma consente l'utilizzo di a do looppoiché il codice non tocca (manualmente) lo stack di ritorno.

Spiegazione

1. Passa attraverso i caratteri nella stringa
2. Controlla ogni personaggio
   1. Se uguale a [, metti in pila a virgola mobile
   2. se uguale a ]pop dallo stack in virgola mobile e output con la posizione corrente

Spiegazione del codice

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 byte

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

Provalo online! Spiegazione:

L

Genera un elenco dai risultati della partita.

$

Utilizzare la seguente sostituzione per generare l'elenco anziché le corrispondenze.

v`

Consenti alle partite di sovrapporsi.

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

Questa è un'applicazione dei gruppi di bilanciamento di .NET. Il [è abbinato alla lettera, poi come numero di caratteri possibili sono consumati. Man mano che ogni successivo [viene abbinato, l'incontro viene aggiunto alla $2pila. Se quella pila non è vuota, possiamo quindi abbinare a ], rimuovendo la corrispondenza dalla pila. Altrimenti, possiamo abbinare tutto ciò che non è un ]( [era già stato abbinato in precedenza). La partita si interrompe quando incontra la corrispondenza ]per il [, dal momento che il$2 pila è (ora) vuota a quel punto.

$.`,$.>`

La sostituzione consiste di due variabili separate da una virgola. Il .indica che la lunghezza della variabile, piuttosto che il suo valore, essere utilizzato. Il >indica che la variabile deve essere valutato in termini di separatore di destra piuttosto che la partita. La $`variabile si riferisce al prefisso della corrispondenza, il che significa che indica $.`la posizione di [; il >modificatore lo altera al prefisso del separatore destro della corrispondenza, che indica la posizione della corrispondenza ].

Gelatina ,  22 21 20  19 byte

^{Senza dubbio è possibile in Jelly la metà di questo conteggio dei byte: p ...}

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

Un collegamento monadico che accetta un elenco di caratteri che restituisce un elenco di elenchi di numeri interi.
Come programma completo accetta una stringa e stampa una rappresentazione di tale elenco.

Provalo online!

Come?

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 byte

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

Esempio:

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

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

Provalo online!

Spiegazione

Per tenere traccia degli indici di stringa della parentesi aperta, la stringa di input viene sovrascritta e utilizzata come stack.

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

Provalo online!

Gelatina , 20 byte

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

Provalo online!

Ha un effetto collaterale sul registro, spero che possa essere una funzione.

Japt v1.4.5, 23 byte

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

Provalo online!

Disimballato e come funziona

;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

L'output è un array appiattito di [closing index, opening index]. Se l'ordine inverso non è desiderato, l'aggiunta walla fine fa il lavoro (+1 byte).

Lisp comune, 95 byte

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

stampe:

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

K (ngn / k) , 38 37 byte

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

Provalo online!

{ } funzione con argomento x

"[]"=\:xdue elenchi booleani per le occorrenze di "["e"]"

a: assegnato a a

|/ booleano "o" delle due liste

& dove (a quali indici) sono le parentesi?

b: assegnato a b

-/un elenco con 1 per "[", -1 per "]"e 0 ovunque

+\ somme parziali

|': massimi a coppie (ogni elemento massimo con il precedente, l'elemento iniziale rimane lo stesso)

Ciò rappresenta la profondità della parentesi per ogni personaggio. Lo indicizziamo con b(la giustapposizione sta indicizzando) e otteniamo la profondità della parentesi solo per le parentesi.

= "raggruppa per" - un dizionario che mappa le profondità agli indici in cui si verificano

,/ concatenare i valori nel dizionario, ignorando le chiavi

0N 2# rimodellare in una matrice a 2 colonne (elenco di elenchi)

b@indice bcon ogni elemento della matrice

Gelatina , 20 18 byte

Salvato 1 byte grazie a @ user202729 che mi informa che lo µ€è)

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

Provalo online!

Dopo aver lottato con questo per diverse ore solo per farlo funzionare ... Sono sinceramente sorpreso che sia diventato così corto :-)

Spiegazione

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

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

Sorprendentemente competitivo - perde solo per Japt e Jelly [ Modifica : e Carbone e Stax :(]

Provalo online!

Spiegazione

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 byte

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

Provalo online!

Pyth ,  28  26 byte

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

Suite di test.

Al momento è più lungo dell'approccio di Mnemonic , ma mi sento come se potessi giocare un po 'verso il basso e questo fortunatamente non usa strutture pitonicamente imperative comeV . La versione iniziale era di 36 byte e presentava anche numerosi bug.

Come funziona

{I # .e, t + lhfSI / LT`Y + ._> Qk \] - Programma completo. Prende una stringa tra virgolette Q da STDIN.
   .e - Mappa elencata. k = indice di iterazione, b = elemento corrente.
                     > Qk - Ottieni gli elementi di Q in indici maggiori di k.
                   ._ - Genera tutti i prefissi di questo.
                  + \] - E aggiungi un "]" (per gestire alcuni casi limite).
          f - Filtra su questo elenco, con T = elemento corrente.
              L `Y - Per ogni carattere in str ([])," [] "...
             / T - ... conta le occorrenze in T.
           SI - E controlla se i valori sono ordinati in modo crescente.
         h - Testa. Recupera il primo elemento.
       + l - Ottieni la lunghezza di questo + k.
      t - Decremento (di 1).
     , - E abbina questo valore a k. Restituisce [i, k] dove sono
                             l'indice del corrispondente] e k è quello di [.
  # - Filtra questo elenco per:
{I - La coppia è invariante rispetto alla deduplicazione.

Perl 5, 53 byte

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

Esegui come perl -nE '<above code snippet>'. Accetta input tramite stdin.

Come al solito, la soluzione Perl ottimale al problema è un'espressione regolare. Cerchiamo di abbinare qualsiasi coppia di parentesi che non contenga alcuna coppia al suo interno usando una classe di caratteri piuttosto sciocca ( s/\[[^][]*\]/.../). Se la corrispondenza ha esito positivo, sostituiamo il testo corrispondente con la cifra 1più e più volte in modo da non abbinare nuovamente accidentalmente quelle parentesi e stampiamo gli indici della corrispondenza. Risciacqua e ripeti.

Stax , 13 byte

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

Esegui ed esegui il debug

Utilizza lo stack di input per tenere traccia delle coppie di controventi aperte. Ecco il programma decompresso, ungolf e commentato.

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

Esegui questo

Carbone , 20 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

ＦＬθ

Passa sopra l'intervallo implicito della lunghezza della stringa di input.

≡§θι

Attiva il personaggio attuale.

[⊞υι

Se è un [quindi spingere l'indice corrente alla variabile di matrice predefinita.

]«Ｉ⊟υ,Ｉι⸿

Se è un, ]quindi pop l'ultimo indice dalla variabile array e stamparlo e l'indice corrente separato da una virgola e iniziare una nuova riga. Formati di output alternativi, se accettabili, salverebbero alcuni byte: ]Ｉ⟦⊟υιωsalva 2 byte ma stampa ciascun indice su una riga separata, spaziando due volte le coppie di indici; ]Ｉ⟦⊟υιstampa semplicemente gli indici su linee separate, rendendo difficile distinguerli.