Aturan

Dalam tantangan ini, saya akan sedikit mendefinisikan kembali definisi "kutipan".

• Tanda kutip ( kutipan AKA ) adalah karakter identik yang digunakan berpasangan dalam berbagai sistem penulisan untuk memicu pidato langsung, kutipan, atau frasa. Pasangan ini terdiri dari tanda kutip pembuka dan tanda kutip penutup, yang merupakan karakter yang sama (case-sensitive).

• Jika ada pasangan-pasangan yang tumpang tindih satu sama lain,

  • Jika sepasang bersarang yang lain, kedua pasangan masih valid.
  • Jika pasangan tidak bersarang, pasangan awal pertama tetap valid. Yang lain tidak lagi dianggap sebagai pasangan.

• Saat menghitung karakter yang dikutip (panjang sepasang kutipan),

  • Kutipan itu sendiri tidak masuk hitungan.
  • Panjang setiap pasangan dihitung secara independen. Tumpang tindih tidak memengaruhi yang lain.

Tujuan

Tujuan Anda adalah mencetak total panjang dari semua kutipan yang valid. Ini adalah kode golf, oleh karena itu kode dengan byte paling sedikit menang.

Contohnya

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

Jelly , 12 byte

œṡ¹¡ḢṖẈ;߀ƲS

Cobalah online!

APL (Dyalog Unicode) , 36 byte ^SBCS

Program lengkap. Meminta input dari stdin.

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

Cobalah online!

t←⍬ mendirikan sebuah akumulator t(untuk t otal)

⍞⊣ Buang yang mendukung input string dari stdin (simbol: quote in console)

{... }⍣≡ terapkan lambda anonim berikut hingga stabil (fix-point; sebelumnya ≡ berikutnya)

 ⊢⍵ pada argumen

 ... ⎕S'\2' PCRE S earch untuk yang berikut, kelompok 2 yang kembali untuk setiap pertandingan:

  (.) karakter apa pun (kami akan memanggil grup ini 1)
  (.*?) sesedikit mungkin karakter (kami akan memanggil grup ini 2)
  \1 karakter grup 1

 t,← perbarui tdengan menambahkan itu ke tnilai saat ini

t⊣ buang itu (daftar terakhir yang tidak cocok) yang mendukung t

≢ hitung jumlah karakter di dalamnya

Ruby , 49 byte

Solusi rekursif. Temukan grup kutipan, hitung panjangnya, dan kemudian secara rekursif mencari panjang sub-grup dan jumlahkan semuanya.

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

Cobalah online!

JavaScript (ES6), 64 byte

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

Cobalah online!

Berkomentar

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

Cobalah online!

Pendekatan asli (64 byte):

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

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

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

Cobalah online!

Berkomentar

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

Jelly , 17 byte

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

Cobalah online!

Program lengkap yang mengambil argumen tunggal, string input terbungkus dalam daftar, dan mengembalikan jumlah karakter kutipan sebagai integer.