บทนำ

ฉันไม่เห็นความท้าทายของ regex มากมายในที่นี้ดังนั้นฉันจึงขอเสนอวิธีง่าย ๆ ที่หลอกลวงซึ่งสามารถทำได้หลายวิธีโดยใช้รสชาติที่หลากหลายของ regex ฉันหวังว่ามันจะมอบความสนุกให้กับผู้ที่ชื่นชอบการเล่นกอล์ฟ regex

ท้าทาย

ความท้าทายคือการจับคู่สิ่งที่ฉันได้ขนานนามอย่างซีรี่ส์ "คุ้มทุน" อย่างหลวม ๆ : ชุดของตัวละครที่แตกต่างกันจำนวนเท่ากัน นี่คือตัวอย่างที่อธิบายได้ดีที่สุด

การจับคู่:

aaabbbccc
xyz 
iillppddff
ggggggoooooollllllffffff
abc
banana

ไม่ตรงกัน:

aabc
xxxyyzzz
iilllpppddff
ggggggoooooollllllfff
aaaaaabbbccc
aaabbbc
abbaa
aabbbc

ที่จะพูดคุยเราต้องการเพื่อให้ตรงกับเรื่องของรูปแบบ ( สำหรับรายชื่อใด ๆ ของตัวละครเพื่อที่ทั้งหมดc1)n(c2)n(c3)n...(ck)nc1ckci != ci+1i, k > 1, and n > 0.

ชี้แจง:

• อินพุตจะไม่ว่างเปล่า

• อักขระอาจซ้ำตัวเองในภายหลังในสตริง (เช่น "Banana")

• k > 1ดังนั้นจะมีอักขระที่แตกต่างกันอย่างน้อย 2 ตัวในสตริง

• คุณสามารถสันนิษฐานได้ว่ามีเพียงอักขระ ASCII เท่านั้นที่ถูกส่งผ่านเป็นอินพุตและไม่มีอักขระใด ๆ ที่จะเป็นตัวยุติบรรทัด

กฎระเบียบ

(ขอบคุณ Martin Ender สำหรับบล็อกกฎที่ระบุไว้อย่างยอดเยี่ยมนี้)

คำตอบของคุณควรประกอบด้วย regex เพียงหนึ่งเดียวโดยไม่มีรหัสเพิ่มเติมใด ๆ (ยกเว้นเป็นทางเลือกรายการของตัวดัดแปลง regex ที่จำเป็นสำหรับการแก้ปัญหาของคุณ) คุณต้องไม่ใช้คุณสมบัติของรสชาติ regex ของภาษาที่อนุญาตให้คุณเรียกใช้โค้ดในภาษาโฮสติ้ง (เช่นeตัวดัดแปลงของ Perl )

คุณสามารถใช้รสชาติของ regex ใด ๆ ที่มีอยู่ก่อนความท้าทายนี้ แต่โปรดระบุรสชาติ

อย่าสันนิษฐานว่า regex นั้นถูกยึดโดยปริยายเช่นถ้าคุณใช้ Python ให้ถือว่า regex ของคุณถูกใช้กับ re.search และไม่ใช่กับ re.match regex ของคุณจะต้องตรงกับสตริงทั้งหมดสำหรับสตริงที่ถูกต้องและไม่ได้ผลสำหรับสตริงที่ไม่ถูกต้อง คุณสามารถใช้กลุ่มจับภาพได้มากเท่าที่คุณต้องการ

คุณอาจสันนิษฐานว่าการป้อนข้อมูลจะเป็นสตริงที่มีอักขระ ASCII ตั้งแต่สองตัวขึ้นไปเสมอโดยไม่มีตัวคั่นบรรทัด

นี่คือสนามกอล์ฟ regex ดังนั้น regex ที่สั้นที่สุดเป็นไบต์จะเป็นผู้ชนะ หากภาษาของคุณต้องการตัวคั่น (โดยปกติ/.../) เพื่อแสดงถึงนิพจน์ทั่วไปอย่านับตัวคั่นด้วยตนเอง หากโซลูชันของคุณต้องการตัวดัดแปลงให้เพิ่มหนึ่งไบต์ต่อตัวดัดแปลง

เกณฑ์

นี่เป็นสนามกอล์ฟที่ดีดังนั้นจงลืมประสิทธิภาพและลอง regex ของคุณให้เล็กที่สุดเท่าที่จะทำได้

โปรดระบุถึงรสชาติที่คุณใช้ใน regex และถ้าเป็นไปได้ให้ใส่ลิงค์ที่แสดงตัวอย่างการแสดงออกทางออนไลน์ของคุณ

.NET รสชาติ 48 ไบต์

^(.)\1*((?<=(\5())*(.))(.)(?<-4>\6)*(?!\4|\6))+$

ลองออนไลน์! (ใช้Retina )

ปรากฎว่าการไม่ลบล้างตรรกะนั้นง่ายกว่าทั้งหมด ฉันทำให้นี่เป็นคำตอบที่แยกต่างหากเพราะทั้งสองวิธีนั้นแตกต่างกันอย่างสิ้นเชิง

คำอธิบาย

^            # Anchor the match to the beginning of the string.
(.)\1*       # Match the first run of identical characters. In principle, 
             # it's possible that this matches only half, a quarter, an 
             # eighth etc of of the first run, but that won't affect the 
             # result of the match (in other words, if the match fails with 
             # matching this as the entire first run, then backtracking into
             # only matching half of it won't cause the rest of the regex to
             # match either).
(            # Match this part one or more times. Each instance matches one
             # run of identical letters.
  (?<=       #   We start with a lookbehind to record the length
             #   of the preceding run. Remember that the lookbehind
             #   should be read from the bottom up (and so should
             #   my comments).
    (\5())*  #     And then we match all of its adjacent copies, pushing an
             #     empty capture onto stack 4 each time. That means at the
             #     end of the lookbehind, we will have n-1 captures stack 4, 
             #     where n is the length of the preceding run. Due to the 
             #     atomic nature of lookbehinds, we don't have to worry 
             #     about backtracking matching less than n-1 copies here.
    (.)      #     We capture the character that makes up the preceding
             #     run in group 5.
  )
  (.)        #   Capture the character that makes up the next run in group 6.
  (?<-4>\6)* #   Match copies of that character while depleting stack 4.
             #   If the runs are the same length that means we need to be
             #   able to get to the end of the run at the same time we
             #   empty stack 4 completely.
  (?!\4|\6)  #   This lookahead ensures that. If stack 4 is not empty yet,
             #   \4 will match, because the captures are all empty, so the
             #   the backreference can't fail. If the stack is empty though,
             #   then the backreference will always fail. Similarly, if we
             #   are not at the end of the run yet, then \6 will match 
             #   another copy of the run. So we ensure that neither \4 nor
             #   \6 are possible at this position to assert that this run
             #   has the same length das the previous one.
)+
$            # Finally, we make sure that we can cover the entire string
             # by going through runs of identical lengths like this.

. NET รส 54 ไบต์

^(?!.*(?<=(\2)*(.))(?!\2)(?>(.)(?<-1>\3)*)(?(1)|\3)).+

ลองออนไลน์! (ใช้Retina )

ฉันค่อนข้างแน่ใจว่านี่เป็นสิ่งที่ไม่คุ้มค่า แต่มันเป็นสิ่งที่ดีที่สุดที่ฉันจะได้รับเมื่อเทียบกับกลุ่มที่สมดุลในตอนนี้ ฉันมีตัวเลือกหนึ่งตัวที่จำนวนไบต์เดียวกันซึ่งส่วนใหญ่เหมือนกัน:

^(?!.*(?<=(\3())*(.))(?!\3)(?>(.)(?<-2>\4)*)(\2|\4)).+

คำอธิบาย

ความคิดหลักคือการคว่ำปัญหาจับคู่สตริงที่ไม่คุ้มทุนและวางสิ่งทั้งหมดไว้ในหัวเชิงลบเพื่อลบล้างผลลัพธ์ ประโยชน์คือเราไม่ต้องติดตามnตลอดทั้งสาย (เนื่องจากลักษณะของกลุ่มที่สมดุลคุณมักจะใช้nเมื่อตรวจสอบ) เพื่อตรวจสอบว่าการวิ่งทั้งหมดมีความยาวเท่ากัน แต่เราเพียงแค่มองหาคู่วิ่งที่อยู่ติดกันคู่เดียวที่ไม่มีความยาวเท่ากัน ด้วยวิธีนี้ฉันต้องใช้nครั้งเดียวเท่านั้น

นี่คือรายละเอียดของ regex

^(?!.*         # This negative lookahead means that we will match
               # all strings where the pattern inside the lookahead
               # would fail if it were used as a regex on its own.
               # Due to the .* that inner regex can match from any
               # position inside the string. The particular position
               # we're looking for is between two runs (and this
               # will be ensured later).

  (?<=         #   We start with a lookbehind to record the length
               #   of the preceding run. Remember that the lookbehind
               #   should be read from the bottom up (and so should
               #   my comments).
    (\2)*      #     And then we match all of its adjacent copies, capturing
               #     them separately in group 1. That means at the
               #     end of the lookbehind, we will have n-1 captures
               #     on stack 1, where n is the length of the preceding
               #     run. Due to the atomic nature of lookbehinds, we
               #     don't have to worry about backtracking matching
               #     less than n-1 copies here.
    (.)        #     We capture the character that makes up the preceding
               #     run in group 2.
  )
  (?!\2)       #   Make sure the next character isn't the same as the one
               #   we used for the preceding run. This ensures we're at a
               #   boundary between runs.
  (?>          #   Match the next stuff with an atomic group to avoid
               #   backtracking.
    (.)        #     Capture the character that makes up the next run
               #     in group 3.
    (?<-1>\3)* #     Match as many of these characters as possible while
               #     depleting the captures on stack 1.
  )
               #   Due to the atomic group, there are three two possible
               #   situations that cause the previous quantifier to stopp
               #   matching. 
               #   Either the run has ended, or stack 1 has been depleted.
               #   If both of those are true, the runs are the same length,
               #   and we don't actually want a match here. But if the runs
               #   are of different lengths than either the run ended but
               #   the stack isn't empty yet, or the stack was depleted but
               #   the run hasn't ended yet.
  (?(1)|\3)    #   This conditional matches these last two cases. If there's
               #   still a capture on stack 1, we don't match anything,
               #   because we know this run was shorter than the previous
               #   one. But if stack 1, we want to match another copy of 
               #   the character in this run to ensure that this run is 
               #   longer than the previous one.
)
.+             # Finally we just match the entire string to comply with the
               # challenge spec.