Quy tắc

Trong thử thách này, tôi sẽ định nghĩa lại định nghĩa của "trích dẫn" một chút.

• Dấu ngoặc kép ( trích dẫn AKA ) là bất kỳ ký tự giống hệt nhau được sử dụng theo cặp trong các hệ thống chữ viết khác nhau để đặt ra lời nói trực tiếp, trích dẫn hoặc cụm từ. Cặp này bao gồm một dấu ngoặc kép mở và dấu ngoặc kép đóng, là cùng một ký tự (phân biệt chữ hoa chữ thường).

• Nếu có cặp trích dẫn chồng chéo lẫn nhau,

  • Nếu một cặp lồng nhau, cả hai cặp vẫn còn hiệu lực.
  • Nếu một cặp không lồng nhau, cặp bắt đầu đầu tiên vẫn còn hiệu lực. Người kia không còn được coi là một cặp.

• Khi đếm các ký tự được trích dẫn (độ dài của một cặp dấu ngoặc kép),

  • Các trích dẫn không được tính.
  • Mỗi chiều dài của mỗi cặp được tính độc lập. Chồng chéo không ảnh hưởng đến khác.

Mục tiêu

Mục tiêu của bạn là in tổng chiều dài của tất cả các trích dẫn hợp lệ. Đây là mã golf, do đó mã có ít byte nhất sẽ thắng.

Ví dụ

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

Thạch , 12 byte

œṡ¹¡ḢṖẈ;߀ƲS

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 36 byte ^SBCS

Chương trình đầy đủ. Nhắc nhở cho đầu vào từ stdin.

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

Hãy thử trực tuyến!

t←⍬ thiết lập một bộ tích lũy t(cho t otal)

⍞⊣ loại bỏ rằng có lợi cho đầu vào chuỗi từ stdin (ký hiệu: quote trong console)

{... }⍣≡ áp dụng lambda anonymous sau cho đến khi ổn định (sửa chữa điểm; trước ≡ tiếp theo)

 ⊢⍵ về lập luận

 Phần mềm ⎕S'\2' PCRE S tìm kiếm các mục sau, trả về nhóm 2 cho mỗi trận đấu:

  (.) bất kỳ ký tự nào (chúng tôi sẽ gọi nhóm 1 này)
  (.*?) càng ít ký tự càng tốt (chúng tôi sẽ gọi nhóm này 2)
  \1 là ký tự nhóm 1

 t,← cập nhật tbằng cách nối thêm vào tgiá trị hiện tại

t⊣ loại bỏ (danh sách cuối cùng không có trận đấu) có lợi cho t

≢ đếm số lượng ký tự trong đó

Hồng ngọc , 49 byte

Giải pháp đệ quy. Tìm nhóm trích dẫn, đếm độ dài của chúng và sau đó tìm đệ quy độ dài của nhóm phụ và tổng hợp mọi thứ lại với nhau.

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

Hãy thử trực tuyến!

JavaScript (ES6), 64 byte

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

Hãy thử trực tuyến!

Đã bình luận

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

Hãy thử trực tuyến!

Cách tiếp cận ban đầu (64 byte):

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

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Đã bình luận

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

Thạch , 17 byte

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

Hãy thử trực tuyến!

Một chương trình đầy đủ có một đối số duy nhất, chuỗi đầu vào được bọc trong một danh sách và trả về số lượng ký tự trích dẫn dưới dạng một số nguyên.