Reglas

En este desafío, voy a redefinir un poco la definición de "citas".

• Las comillas ( comillas AKA ) son caracteres idénticos utilizados en pares en varios sistemas de escritura para activar el discurso directo, una cita o una frase. El par consta de una comilla de apertura y una comilla de cierre, que es el mismo carácter (distingue entre mayúsculas y minúsculas).

• Si hay pares de comillas superpuestos entre sí,

  • Si un par anida a otro, ambos pares siguen siendo válidos.
  • Si un par no anida a otro, el primer par inicial sigue siendo válido. El otro ya no se considera como un par.

• Al contar los caracteres entre comillas (longitud de un par de comillas),

  • Las citas en sí mismas no cuentan.
  • La longitud de cada par se cuenta de forma independiente. La superposición no afecta a otro.

Objetivo

Su objetivo es imprimir la longitud total de todas las cotizaciones válidas. Este es el código de golf, por lo tanto, gana el código con la menor cantidad de bytes.

Ejemplos

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

Jalea , 12 bytes

œṡ¹¡ḢṖẈ;߀ƲS

Pruébalo en línea!

APL (Dyalog Unicode) , ^{SBCS de} 36 bytes

Programa completo Solicita la entrada de stdin.

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

Pruébalo en línea!

t←⍬ configurar un acumulador t(para t otal)

⍞⊣ descartar eso a favor de la entrada de cadena desde stdin (símbolo: cita en la consola)

{… }⍣≡ Aplique la siguiente lambda anónima hasta que sea estable (punto fijo; anterior ≡ siguiente)

 ⊢⍵ en el argumento

 … ⎕S'\2' PCRE S earch para lo siguiente, devolviendo el grupo 2 para cada partido:

  (.) cualquier carácter (llamaremos a este grupo 1)
  (.*?) tan pocos caracteres como sea posible (llamaremos a este grupo 2)
  \1 el carácter del grupo 1

 t,← actualizar tagregando eso al tvalor actual de

t⊣ descartar eso (la lista final de no coincidencias) a favor de t

≢ contar el número de caracteres en ese

Ruby , 49 bytes

Solución recursiva. Encuentre grupos de citas, cuente sus longitudes y luego busque recursivamente las longitudes de los subgrupos y sume todo.

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

Pruébalo en línea!

JavaScript (ES6), 64 bytes

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

Pruébalo en línea!

Comentado

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 bytes

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

Pruébalo en línea!

Enfoque original (64 bytes):

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

Pruébalo en línea!

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 bytes

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

Pruébalo en línea!

Comentado

# 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.)
}{}})

Jalea , 17 bytes

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

Pruébalo en línea!

Un programa completo que toma un solo argumento, la cadena de entrada envuelta en una lista, y devuelve el número de comillas como un entero.