Vous recevrez une chaîne s. Il est garanti que la chaîne a égal et au moins un [s et ]s. Il est également garanti que les supports sont équilibrés. La chaîne peut également avoir d'autres caractères.

L'objectif est de sortir / retourner une liste de tuples ou une liste de listes contenant des indices de chacun [et de la ]paire.

remarque: la chaîne est indexée zéro.

Exemple: !^45sdfd[hello world[[djfut]%%357]sr[jf]s][srtdg][]devrait revenir

[(8, 41), (20, 33), (21, 27), (36, 39), (42, 48), (49, 50)]ou quelque chose d'équivalent à cela. Les tuples ne sont pas nécessaires. Des listes peuvent également être utilisées.

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

Il s'agit de code-golf , donc le code le plus court en octets pour chaque langage de programmation l'emporte.

Brain-Flak Classic , 108 octets

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

Essayez-le en ligne!

Stocke chaque ouverture [dans la bonne pile et sort chaque fois que nous frappons a ].

Python 2 , 74 octets

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

Essayez-le en ligne!

JavaScript, 69 62 octets

Un peu de golf sur le train de retour. Peut probablement être amélioré.

Prend l'entrée comme un tableau de caractères et sort un objet avec les clés étant les indices des [s et leurs valeurs étant les indices de leurs ]s correspondants .

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

Essayez-le en ligne

Haskell , 92 79 octets

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

Essayez-le en ligne!

Explication

Nous créons une fonction gqui prend 3 arguments.

• a, qui est l'emplacement de tous les [art.

• n, qui est le nombre de caractères traités

• x qui est les caractères non traités.

Si notre premier personnage est que ]nous retirons udu front notre aet revenons (u,n)plus tout ce qui reste.

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

Si notre premier caractère ne l'est pas ], que ce soit l'un [ou l'autre, nous incrémentons net ajoutons [n|s=='[']au début de a. [n|s=='[']sera [n]si s=='['et []sinon.

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

Si nous n'avons plus de caractères, nous renvoyons la liste vide.

g[]_[]=[]

Java 10, 95 octets

Un lambda vide prenant la chaîne d'entrée comme un int[]des points de code 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++;}}

Essayez-le en ligne

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

Remerciements

• merci à Jonathan Frech pour l'idée d'utiliser la chaîne d'entrée comme pile ( ici )

vim, 89 octets

: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

Annoté

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

Essayez-le en ligne!

QBasic (QB64), 137 127 112 octets

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

Nous avons besoin de quatre deux octets car le défi nécessite une indexation 0. Mon premier article QBasic, les commentaires sont appréciés.

• 10 octets grâce à steenbergh
• 3 octets grâce à Erik l'Outgolfer
• 12 octets en enregistrant au format de fichier unix ( \r\n-> \n)

Ressemble à ceci une fois exécuté:

Pyth, 26 octets

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

Essayez-le ici

Explication

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 112 108 octets

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

Essayez-le en ligne!

Rien de spécial. 1 indexé, parce que je l'ai dit. R n'a pas vraiment de piles, donc j'ai utilisé à l'originec , headet tailpour obtenir le même effet littéral. Ungolfed version originale (mises à jour à l' aide utf8ToIntde supprimer certains octets, en utilisant le début du vecteur en haut de la pile, et en abusant Tet Fbuiltins pour éviter l' initialisation des piles.):

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 octets

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

Essayez-le en ligne!

Abuse la pile à virgule flottante, mais permet d'utiliser un do loopcar le code ne touche pas (manuellement) à la pile de retour.

Explication

1. Parcourez les caractères en chaîne
2. Vérifiez chaque personnage
   1. Si égal à [ , mettre sur une pile à virgule flottante
   2. si égal à ]pop de la pile à virgule flottante et sortie avec la position actuelle

Explication du code

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

Rétine , 36 octets

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

Essayez-le en ligne! Explication:

L

Générez une liste à partir des résultats de la correspondance.

$

Utilisez la substitution suivante pour générer la liste au lieu des correspondances.

v`

Autoriser les correspondances à se chevaucher.

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

Il s'agit d'une application des groupes d'équilibrage de .NET. Le [correspond littéralement, puis autant de caractères que possible sont consommés. Comme chaque suivant [est mis en correspondance, la correspondance est ajoutée à la $2pile. Si cette pile n'est pas vide, nous pouvons alors faire correspondre a ], en supprimant la correspondance de la pile. Sinon, nous pouvons faire correspondre tout ce qui n'est pas un ](le [a déjà été mis en correspondance plus tôt). La correspondance s'arrête lorsqu'elle rencontre la correspondance ]pour le [, car la $2pile est (maintenant) vide à ce stade.

$.`,$.>`

La substitution se compose de deux variables séparées par une virgule. Le .indique que la longueur de la variable, plutôt que sa valeur, doit être utilisée. Le >indique que la variable doit être évaluée en fonction du séparateur droit plutôt que de la correspondance. La $`variable fait référence au préfixe de la correspondance, ce qui signifie $.`donne la position du [; le >modificateur le modifie en préfixe du séparateur droit de la correspondance, ce qui donne la position de la correspondance ].

Gelée ,  22 21 20  19 octets

^{Sans doute, il est possible dans Jelly dans la moitié de ce nombre d'octets: p ...}

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

Un lien monadique acceptant une liste de caractères qui renvoie une liste de listes d'entiers.
En tant que programme complet, il accepte une chaîne et imprime une représentation de ladite liste.

Essayez-le en ligne!

Comment?

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 octets

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

Exemple:

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

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

Essayez-le en ligne!

Explication

Pour garder une trace de l'ouverture des index de chaîne du crochet, la chaîne d'entrée est remplacée et utilisée comme une pile.

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

Essayez-le en ligne!

Gelée , 20 octets

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

Essayez-le en ligne!

Cela a un effet secondaire sur le registre, j'espère que cela peut être une fonction.

Japt v1.4.5, 23 octets

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

Essayez-le en ligne!

Déballé et comment cela fonctionne

;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 sortie est un tableau aplati de [closing index, opening index]. Si l'ordre inversé n'est pas souhaité, l'ajout wà la fin fait le travail (+1 octet).

Lisp commun, 95 octets

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

impressions:

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

K (ngn / k) , 38 37 octets

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

Essayez-le en ligne!

{ } fonction avec argument x

"[]"=\:xdeux listes booléennes pour les occurrences de "["et"]"

a: affecter à a

|/ booléen "ou" des deux listes

& où (à quels indices) se trouvent les parenthèses?

b: affecter à b

-/une liste avec 1 pour "[", -1 pour"]" et 0 partout ailleurs

+\ sommes partielles

|': maxima par paire (chaque élément est au maximum avec le précédent, l'élément initial reste le même)

Cela représente la profondeur du crochet pour chaque caractère. Nous l'indexons avecb (la juxtaposition est l'indexation) et nous obtenons la profondeur des crochets uniquement pour les crochets.

= «group by» - un dictionnaire mappant les profondeurs aux indices auxquels elles se produisent

,/ concaténer les valeurs dans le dictionnaire, en ignorant les clés

0N 2# remodeler en une matrice à 2 colonnes (liste de listes)

b@index bavec chaque élément de la matrice

Gelée , 20 18 octets

1 octet enregistré grâce à @ user202729 m'informant que µ€c'est)

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

Essayez-le en ligne!

Après avoir lutté avec cela pendant plusieurs heures juste pour le faire fonctionner ... Je suis honnêtement surpris que ça soit si court :-)

Explication

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

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

Étonnamment compétitif - ne perd que face à Japt et Jelly [ Edit : and Charcoal and Stax :(]

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Pyth ,  28  26 octets

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

Suite de tests.

Pour le moment, c'est plus long que l'approche de Mnemonic , mais je sens que je peux jouer au golf un peu et heureusement, cela n'utilise pas non plus des structures impératives de Python V. La version initiale était de 36 octets et comportait également de nombreux bogues.

Comment ça marche

{I # .e, t + lhfSI / LT`Y + ._> Qk \] - Programme complet. Prend une chaîne entre guillemets Q de STDIN.
   .e - Carte énumérée. k = indice d'itération, b = élément courant.
                     > Qk - Obtenez les éléments de Q à des indices supérieurs à k.
                   ._ - Génère tous les préfixes de ceci.
                  + \] - Et ajoutez un "]" (pour gérer certains cas marginaux).
          f - Filtrer sur cette liste, avec T = élément courant.
              L `Y - Pour chaque caractère de str ([])," [] "...
             / T - ... Comptez les occurrences de celui-ci dans T.
           SI - Et vérifiez si les valeurs sont triées de plus en plus.
         h - Tête. Récupérez le premier élément.
       + l - Obtenez la longueur de ce + k.
      t - Décrémenter (de 1).
     , - Et associez cette valeur à k. Renvoie [i, k] où i est
                             l'indice du correspondant] et k est celui de [.
  # - Filtrer cette liste par:
{I - La paire est invariante par rapport à la déduplication.

Perl 5, 53 octets

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

Exécuter en tant que perl -nE '<above code snippet>'. Prend l'entrée via stdin.

Comme d'habitude, la solution Perl optimale au problème est une expression régulière. Nous essayons de faire correspondre n'importe quelle paire de crochets qui ne contient aucune paire à l'intérieur en utilisant une classe de caractères plutôt stupide ( s/\[[^][]*\]/.../). Si la correspondance est réussie, nous remplaçons le texte correspondant par le chiffre 1encore et encore afin de ne plus correspondre accidentellement à ces crochets, et nous imprimons les indices de la correspondance. Rincez et répétez.

Stax , 13 octets

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

Exécuter et déboguer

Il utilise la pile d'entrée pour suivre les paires d'accolades ouvertes. Voici le programme décompressé, non golfé et commenté.

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

Exécutez celui-ci

Fusain , 20 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

ＦＬθ

Boucle sur la plage implicite de la longueur de la chaîne d'entrée.

≡§θι

Activez le caractère actuel.

[⊞υι

Si c'est un, [poussez l'index en cours vers la variable de tableau prédéfinie.

]«Ｉ⊟υ,Ｉι⸿

Si c'est un, ]puis pop le dernier index de la variable de tableau et imprimez-le et l'index en cours séparés par une virgule et commencez une nouvelle ligne. D'autres formats de sortie, s'ils sont acceptables, permettraient d'économiser quelques octets: ]Ｉ⟦⊟υιωenregistre 2 octets mais imprime chaque index sur une ligne distincte, en double-espaçant les paires d'index; ]Ｉ⟦⊟υιimprime simplement les index sur des lignes séparées, ce qui rend difficile leur distinction.