Règles

Dans ce défi, je vais redéfinir un peu la définition de "guillemets".

• Les guillemets (AKA quotes ) sont des caractères identiques utilisés par paires dans divers systèmes d'écriture pour déclencher la parole directe, une citation ou une phrase. La paire se compose d'un guillemet d'ouverture et d'un guillemet de fermeture, qui est le même caractère (sensible à la casse).

• S'il y a des paires de devis qui se chevauchent,

  • Si une paire en imbrique une autre, les deux paires sont toujours valides.
  • Si une paire n'en imbrique pas une autre, la première paire de départ reste valide. L'autre n'est plus considéré comme une paire.

• Lors du comptage des caractères entre guillemets (longueur d'une paire de guillemets),

  • Les citations elles-mêmes ne comptent pas.
  • La longueur de chaque paire est comptée indépendamment. Le chevauchement n'en affecte pas un autre.

Objectif

Votre objectif est d'imprimer la longueur totale de tous les devis valides. C'est le code golf, donc le code avec le moins d'octets gagne.

Exemples

Legend:
    <foo>: Valid quotes
    ^    : Cannot be paired character

Input   : ABCDDCBA
`A`  (6): <BCDDCB>
`B`  (4):  <CDDC>
`C`  (2):   <DD>
`D`  (0):    <>
Output  : 12

Input   : ABCDABCD
`A`  (3): <BCD>
`B`  (0):  ^   ^
`C`  (0):   ^   ^
`D`  (0):    ^   ^
Output  : 3

Input   : AABBBBAAAABA
`A`  (0): <>    <><> ^
`B`  (0):   <><>    ^
Output  : 0

Input   : ABCDE
Output  : 0

Input   : Print the total length of all "quoted" characters
`r` (40):  <int the total length of all "quoted" cha>
`n` (14):    <t the total le>
`t` (15):     < >   <o>       <h of all "quo>
` `  (7):      ^   <total>      <of>   ^        ^
`h`  (0):        ^             ^                  ^
`e`  (8):         < total l>                 ^          ^
`o`  (0):            ^           ^         ^
`a`  (0):              ^            ^              ^ ^
`l`  (0):               ^ ^          <>
`"`  (0):                               ^      ^
`c`  (0):                                        ^    ^
Output  : 84

Input   : Peter Piper picked a peck of pickled peppers
`P`  (5): <eter >
`e`  (9):  <t>     ^      <d a p>           <d p>  ^
`r`  (0):     ^     ^
` `  (3):      ^     ^      <a>    <of>       ^
`i`  (5):        <per p>
`p`  (3):         <er >        ^       ^       ^ <>
`c`  (8):               <ked a pe>       ^
`k`  (7):                ^        < of pic>
`d`  (0):                  ^                 ^
Output  : 40

Input   : https://www.youtube.com/watch?v=dQw4w9WgXcQ
`h` (27): <ttps://www.youtube.com/watc>
`t`  (0):  <>            ^          ^
`/`  (0):       <>               ^
`w` (14):         <><.youtube.com/>         <4>
`.`  (7):            <youtube>
`o`  (0):              ^       ^
`u`  (1):               <t>
`c`  (0):                     ^      ^             ^
`Q`  (8):                                  <w4w9WgXc>
Output  : 57

Gelée , 12 octets

œṡ¹¡ḢṖẈ;߀ƲS

Essayez-le en ligne!

APL (Dyalog Unicode) , 36 octets ^SBCS

Programme complet. Demande l'entrée de stdin.

≢∊t⊣{t,←'(.)(.*?)\1'⎕S'\2'⊢⍵}⍣≡⍞⊣t←⍬

Essayez-le en ligne!

t←⍬ mettre en place un accumulateur t(pour t otal)

⍞⊣ jetez cela en faveur de l'entrée de chaîne de stdin (symbole: citation dans la console)

{… }⍣≡ Appliquer le lambda anonyme suivant jusqu'à ce qu'il soit stable (point fixe; précédent ≡ suivant)

 ⊢⍵ sur l'argument

 ... ⎕S'\2' PCRE S Earch pour le suivant, le groupe 2 de retour pour chaque match:

  (.) n'importe quel caractère (nous appellerons ce groupe 1)
  (.*?) aussi peu de caractères que possible (nous appellerons ce groupe 2)
  \1 le caractère du groupe 1

 t,← mettre tà jour en ajoutant cela à tla valeur actuelle de

t⊣ jeter cela (la liste finale de non-correspondances) en faveur de t

≢ compter le nombre de caractères dans ce

Rubis , 49 octets

Solution récursive. Recherchez des groupes de devis, comptez leurs longueurs, puis recherchez récursivement les longueurs de sous-groupe et additionnez le tout.

f=->s{s.scan(/(.)(.*?)\1/).sum{|a,b|b.size+f[b]}}

Essayez-le en ligne!

JavaScript (ES6), 64 octets

f=([c,...a],i=a.indexOf(c))=>c?(~i&&i+f(a.splice(0,i+1)))+f(a):0

Essayez-le en ligne!

Commenté

f = (                       // f is a recursive function taking either the input string
                            // or an array of characters, split into
  [c, ...a],                // c = next character and a[] = all remaining characters
  i = a.indexOf(c)          // i = index of the 1st occurrence of c in a[] (-1 if not found)
) =>                        //
  c ?                       // if c is defined:
    ( ~i &&                 //   if i is not equal to -1:
      i +                   //     add i to the final result
      f(a.splice(0, i + 1)) //     remove the left part of a[] up to i (included) and
    )                       //     do a recursive call on it
    + f(a)                  //   add the result of a recursive call on a[]
  :                         // else:
    0                       //   stop recursion

JavaScript (Node.js) , 65 64 62 octets

f=s=>(s=/(.)(.*?)\1(.*)/.exec(s))?f(s[3])+f(s=s[2])+s.length:0

Essayez-le en ligne!

Approche originale (64 octets):

f=(s,r=/(.)(.*?)\1/g,t=r.exec(s))=>t?f(t=t[2])+t.length+f(s,r):0

Essayez-le en ligne!

f=s=>                              // Main function:
 (s=/(.)(.*?)\1(.*)/.exec(s))?     //  If a "quoted" segment can be found:
  f(s[3])                          //   Return the recursive result outside this segment,
  +f(s=s[2])                       //   plus the recursive result of this segment,
  +s.length                        //   plus the length of this segment
 :0                                //  If not: no quoted segment, return 0.

Brain-Flak , 100 octets

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

Essayez-le en ligne!

Commenté

# Loop over each character in input and sum iterations:
({{

  # Evaluate matching quote search as zero
  <

    # Move opening "quote" to right stack
    ({}<>)<>

    # Until match or end of search string found:
    # Note that the character to search for is stored as the sum of the top two entries in the right stack.
    (

      ({

        <>((

          # Character to search for
          {}({})

          # Subtract and move next character
          <>[({}<>)]

        # Push difference twice
        ))

        # Add 1 to evaluation of this loop
        ()

        # If no match, cancel out both 1 and pushed difference to evaluate iteration as zero (keep one copy of difference for next iteration)
        # (compare to the standard "not" snippet, ((){[()](<{}>)}{}) )
        # Then move to other stack
        {[{}()](<>)}{}

        # If a match was found, this will instead pop a single zero and leave a zero to terminate the loop, evaluating this iteration as 0+1=1.

      # Push 1 if match found, 0 otherwise
      }{})

      # If match found, move to left stack and push 0 denote end of "quoted" area.
      {(<>)}

    # Push the same 1 or 0 as before
    )

    # Remove representation of opening "quote" searched for
    # The closing quote is *not* removed if there is a match, but this is not a problem because it will never match anything.
    <>{}

  >

  # Move searched text back to left stack, evaluating each iteration as either the 1 or 0 from before.
  # This counts characters enclosed in "quotes" if a match is found, and evaluates as 0 otherwise.
  {<>({}<<>({}<>)>)<>}

  # Remove 0/1 from stack; if 1, cancel out the 1 added by the closing "quote"
  <>[{}]

# Repeat until two consecutive zeroes show up, denoting the end of the stack.
# (Because closing quotes are not removed, it can be shown that all other zeroes are isolated on the stack.)
}{}})

Gelée , 17 octets

œṡḢẈṖ$Ḣ+ɼṛƲ)Ẏ$F¿®

Essayez-le en ligne!

Un programme complet qui prend un seul argument, la chaîne d'entrée enveloppée dans une liste et retourne le nombre de guillemets sous forme d'entier.