Regeln

In dieser Herausforderung werde ich die Definition von "Anführungszeichen" ein wenig neu definieren.

• Anführungszeichen (AKA- Anführungszeichen ) sind identische Zeichen, die paarweise in verschiedenen Schriftsystemen verwendet werden, um direkte Sprache, ein Zitat oder eine Phrase hervorzurufen. Das Paar besteht aus einem öffnenden Anführungszeichen und einem schließenden Anführungszeichen, bei denen es sich um dasselbe Zeichen handelt (Groß- und Kleinschreibung beachten).

• Wenn sich Anführungszeichenpaare überlappen,

  • Wenn ein Paar ein anderes verschachtelt, sind beide Paare weiterhin gültig.
  • Wenn ein Paar kein anderes verschachtelt, bleibt das erste Startpaar gültig. Der andere wird nicht mehr als Paar betrachtet.

• Beim Zählen von Anführungszeichen (Länge eines Anführungszeichenpaares)

  • Die Anführungszeichen selbst zählen nicht.
  • Die Länge jedes Paares wird unabhängig gezählt. Überlappung wirkt sich nicht auf andere aus.

Tor

Ihr Ziel ist es, die Gesamtlänge aller gültigen Angebote zu drucken. Dies ist Codegolf, daher gewinnt der Code mit den wenigsten Bytes.

Beispiele

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

Gelee , 12 Bytes

œṡ¹¡ḢṖẈ;߀ƲS

Probieren Sie es online!

APL (Dyalog Unicode) , 36 Byte ^SBCS

Volles Programm. Fordert zur Eingabe von stdin auf.

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

Probieren Sie es online!

t←⍬ einen akkumulator einrichten t(für t otal)

⍞⊣ verwerfe das zugunsten der Zeichenketteneingabe von stdin (Symbol: Anführungszeichen in der Konsole)

{… }⍣≡ Wende das folgende anonyme Lambda an, bis es stabil ist (Fixpunkt; vorheriges ≡ nächstes)

 ⊢⍵ auf das Argument

 ... ⎕S'\2' PCRE S uche für die folgenden, Gruppe 2 zurück für jedes Spiel:

  (.) Jedes Zeichen (wir nennen diese Gruppe 1)
  (.*?) so wenig Zeichen wie möglich (wir nennen diese Gruppe 2)
  \1 das Zeichen der Gruppe 1

 t,← aktualisiere tindem du das an tden aktuellen Wert anhängst

t⊣ verwerfe das (die endgültige Liste ohne Übereinstimmungen) zugunsten von t

≢ Zählen Sie die Anzahl der Zeichen darin

Ruby , 49 Bytes

Rekursive Lösung. Suchen Sie nach Angebotsgruppen, zählen Sie deren Längen und suchen Sie dann rekursiv nach Untergruppenlängen und addieren Sie alles.

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

Probieren Sie es online!

JavaScript (ES6), 64 Byte

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

Probieren Sie es online!

Kommentiert

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 Byte

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

Probieren Sie es online!

Ursprünglicher Ansatz (64 Bytes):

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

Probieren Sie es online!

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

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

Probieren Sie es online!

Kommentiert

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

Gelee , 17 Bytes

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

Probieren Sie es online!

Ein vollständiges Programm, das ein einzelnes Argument, die in eine Liste eingeschlossene Eingabezeichenfolge und die Anzahl der Anführungszeichen als Ganzzahl zurückgibt.