กฎระเบียบ

ในความท้าทายนี้ฉันจะนิยามนิยามของ "คำพูด" อีกเล็กน้อย

• เครื่องหมายอัญประกาศ ( อัญประกาศ AKA ) เป็นอักขระที่เหมือนกันที่ใช้เป็นคู่ในระบบการเขียนต่าง ๆ เพื่อตั้งค่าการพูดโดยตรงใบเสนอราคาหรือวลี ทั้งคู่ประกอบด้วยเครื่องหมายคำพูดเปิดและเครื่องหมายคำพูดปิดซึ่งเป็นตัวละครเดียวกัน

• หากมีคู่คำพูดทับซ้อนกัน

  • หากทั้งคู่ซ้อนกันทั้งคู่จะยังคงใช้งานได้
  • หากทั้งคู่ไม่ได้ซ้อนกันคู่ใหม่ที่เริ่มต้นยังคงใช้งานได้ อีกคู่ไม่ถือว่าเป็นคู่อีกต่อไป

• เมื่อทำการนับตัวอักษรที่ยกมา (ความยาวของคู่ของคำพูด)

  • คำพูดนั้นไม่นับรวม
  • ความยาวของแต่ละคู่ถูกนับอย่างอิสระ การซ้อนทับไม่ส่งผลกระทบต่ออีก

เป้าหมาย

เป้าหมายของคุณคือการพิมพ์ความยาวทั้งหมดของคำพูดที่ถูกต้องทั้งหมด นี่คือรหัสกอล์ฟดังนั้นโค้ดที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

ตัวอย่าง

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

เยลลี่ 12 ไบต์

œṡ¹¡ḢṖẈ;߀ƲS

ลองออนไลน์!

APL (Dyalog Unicode) , 36 ไบต์^SBCS

โปรแกรมเต็มรูปแบบ พร้อมต์สำหรับอินพุตจาก stdin

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

ลองออนไลน์!

t←⍬ ตั้งค่าแอคคิวมูเลเตอร์t(สำหรับt otal)

⍞⊣ ยกเลิกสิ่งนั้นในความโปรดปรานของอินพุตสตริงจาก stdin (สัญลักษณ์: quote in console)

{… }⍣≡ ใช้แลมบ์ดานิรนามต่อไปนี้จนกระทั่งเสถียร (จุดแก้ไข; ก่อนหน้า≡ถัดไป)

 ⊢⍵ ในการโต้แย้ง

 … ⎕S'\2' PCRE S earch สำหรับสิ่งต่อไปนี้คืนกลุ่ม 2 สำหรับการแข่งขันแต่ละครั้ง:

  (.) ตัวละครใด ๆ (เราจะเรียกกลุ่มนี้ 1)
  (.*?) ตัวละครน้อยที่สุด (เราจะเรียกกลุ่มนี้ 2)
  \1 ตัวละครกลุ่ม 1

 t,← อัปเดตtโดยต่อท้ายที่tเป็นค่าปัจจุบัน

t⊣ ยกเลิกนั้น (รายการสุดท้ายของการแข่งขันที่ไม่มี) เพื่อ t

≢ นับจำนวนตัวอักษรในนั้น

Ruby , 49 ไบต์

โซลูชันแบบเรียกซ้ำ ค้นหากลุ่มคำพูดนับความยาวจากนั้นค้นหาความยาวกลุ่มย่อยซ้ำและรวมทุกอย่างเข้าด้วยกัน

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

ลองออนไลน์!

JavaScript (ES6), 64 ไบต์

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

ลองออนไลน์!

แสดงความคิดเห็น

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 ไบต์

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

ลองออนไลน์!

วิธีดั้งเดิม (64 ไบต์):

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

ลองออนไลน์!

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 ไบต์

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

ลองออนไลน์!

แสดงความคิดเห็น

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

เยลลี่ขนาด 17 ไบต์

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

ลองออนไลน์!

โปรแกรมเต็มรูปแบบที่รับอาร์กิวเมนต์เดี่ยวสตริงอินพุตที่ล้อมรอบในรายการและส่งคืนจำนวนอักขระเครื่องหมายคำพูดเป็นจำนวนเต็ม