สำหรับจุดประสงค์ของการท้าทายนี้เราบอกว่ารูปแบบ regex จับคู่กับสตริงหากสตริงทั้งหมดถูกจับคู่กับรูปแบบไม่ใช่แค่สตริงย่อย

ด้วยรูปแบบ regex สองรูปแบบ  A  และ  Bเราบอกว่า  A  นั้นมีความเชี่ยวชาญมากกว่า  B   หากสตริงทุกอันที่จับคู่โดย  A  นั้นถูกจับคู่โดยBด้วย    แต่ไม่ใช่วิธีอื่น ๆ เราบอกว่า   เป็นเทียบเท่าเพื่อ  B  ถ้ารูปแบบทั้งตรงกับชุดเดียวกันของสตริง หากรูปแบบไม่เป็นความเชี่ยวชาญมากขึ้นกว่าที่อื่น ๆ หรือพวกเขาเทียบเท่าเราบอกว่า   และ  B  เป็นที่เปรียบมิได้

ตัวอย่างเช่นรูปแบบHello, .*!มีความเชี่ยวชาญมากกว่า.*, .*!; รูปแบบ(Hello|Goodbye), World!และHello, World!|Goodbye, World!เทียบเท่า; และรูปแบบHello, .*!และ.*, World!หาที่เปรียบมิได้

ความสัมพันธ์ "พิเศษกว่า" กำหนดลำดับบางส่วนที่เข้มงวดในชุดของรูปแบบ regex โดยเฉพาะอย่างยิ่งสำหรับรูปแบบ  A  และ  Bทั้งหมดหนึ่งในสิ่งต่อไปนี้เป็นจริง:

• A  มีความเชี่ยวชาญมากกว่า  B  ( A < B )
• B  มีความเชี่ยวชาญมากกว่า  A  ( A > B )
• A  และ  B  เทียบเท่า ( A = B )
• A  และ  B  หาที่เปรียบมิได้ ( A ∥ B )

เมื่อ  A  และ  B เปรียบเทียบ  กันไม่ได้เราสามารถแยกแยะความแตกต่างระหว่างสองกรณีต่อไปนี้:

• A  และ  B  เป็นdisjoint ( A ∥ B ) ซึ่งหมายความว่าทั้งคู่ไม่มีสตริงที่ตรงกัน
• A  และ  B  กำลังตัดกัน ( A ≬ B ) ซึ่งหมายความว่ามีการจับคู่สตริงบางตัว

ท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้คู่ของรูปแบบ regex และเปรียบเทียบพวกเขาโดยใช้ลำดับข้างต้น นั่นคือถ้าทั้งสองรูปแบบมี   และ  B , โปรแกรมควรตรวจสอบว่า  < B ,  > B , = B  หรือ  ∥ B

× 92% โบนัสโบนัส  เพิ่มเติมจะมอบให้หากเมื่อรูปแบบที่เปรียบมิได้โปรแกรมจะพิจารณาว่าพวกเขากำลังตัดกันหรือแยกกัน

อินพุตและเอาต์พุต

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

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

รสชาติ Regex

คุณอาจสนับสนุนคุณสมบัติใด ๆ ของ regex ที่คุณต้องการ แต่คุณต้องรองรับคุณสมบัติต่อไปนี้:

• สลับ|กับ
• ปริมาณ*ด้วย
• การจัดกลุ่มด้วยและ()
• จับคู่ตัวอักษรใด ๆ (อาจจะไม่รวมการขึ้นบรรทัดใหม่) .ด้วย
• (ตัวเลือก: โบนัส× 80%)  จับคู่คลาสตัวละครที่เรียบง่ายและไม่ตรงกับ[…]และ[^…]ตามลำดับ คุณไม่จำเป็นต้องสนับสนุนคลาสอักขระที่กำหนดไว้ล่วงหน้า (เช่น[:digit:]) แต่คุณควรสนับสนุนช่วงอักขระ
• ตัวละครหนีออกมา\ด้วย อย่างน้อยก็ควรจะเป็นไปได้ที่จะ esacpe อักขระพิเศษ (เช่น|*().[^-]\) และโดยเฉพาะอย่างยิ่งตัวละครพิเศษทั่วไปในรสชาติอื่น ๆ (เช่น{}) แต่พฤติกรรมเมื่อหนีออกมาจากตัวละครที่ไม่ระบุตัวตนไม่ได้ระบุ โดยเฉพาะอย่างยิ่งคุณไม่จำเป็นต้องสนับสนุนลำดับการยกเว้นพิเศษเช่น\nสำหรับการขึ้นบรรทัดใหม่และรายการที่คล้ายกัน การนำไปใช้ที่เป็นไปได้คือการใช้อักขระ\ตามตัวอักษร

คุณอาจสมมติว่าตัวอักษรอินพุตที่ไม่สามารถจับคู่กับตัวอักษรใด ๆ ได้ (เช่นสามารถจับคู่โดย.และคลาสอักขระที่ถูกทำให้เป็นโมฆะ)

กฎเพิ่มเติม

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

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟ คะแนนของคุณเป็นผลิตภัณฑ์ของรหัสขนาดในไบต์และใด ๆ ของโบนัส ต่ำสุดคะแนนชนะ

กรณีทดสอบ

รูปแบบของกรณีทดสอบมีดังนี้:

<Test ID>
<Pattern A>
<Ordering>
<Pattern B>

<Test ID>
<Pattern A>
<Ordering>
<Pattern B>

...

<Test ID>ตัวบ่งชี้สำหรับกรณีทดสอบอยู่ที่ไหน<Pattern A>และ<Pattern B>เป็นรูปแบบ regex และ<Ordering>เป็นการเรียงลำดับระหว่างกันและเป็นหนึ่งใน:

• <: มีความเชี่ยวชาญมากกว่า<Pattern A><Pattern B>
• >: มีความเชี่ยวชาญมากกว่า<Pattern B><Pattern A>
• =: รูปแบบเทียบเท่า
• |: รูปแบบที่เปรียบมิได้และแยกจากกัน
• X: รูปแบบไม่มีที่เปรียบและตัดกัน

ค่าพิเศษ<empty pattern>หมายถึงรูปแบบที่ว่างเปล่า

A. รูปแบบพื้นฐาน

A1
Hello
=
Hello

A2
Hello
|
World

A3
Hell(|o)
=
Hell|Hello

A4
x
<
.

A5
.
>
x

A6
\.
<
.

A7
x|y
=
y|x

A8
x|y
X
y|z

A9
x|y
|
a|b

A10
x|y|z
>
x|z

A11
x.
X
.x

A12
.*
>
<empty pattern>

A13
()*
=
<empty pattern>

A14
x*
>
xxxx

A15
x*
>
x|xx|xxxx*

A16
x*
=
|x|xx|xxxx*

A17
x*
<
.*

A19
(.|..)*
=
.*

A20
(...)*
X
(..)*

A21
...*
X
(..)*

A22
...*
<
..*

A23
(...)*
|
Four

A24
a*
X
a.*

A25
a*
|
b.*

A26
x*
=
(x|)*

A27
(((.*)*)*)*
=
.*

B. รูปแบบที่ซับซ้อน

B1
aaa*
=
aa*a

B2
aa*a
=
a*aa

B3
a*
X
aaax||a|aa|aaa

B4
aaaaaaaaaaaaaa*
X
(aa)*|(aaa)*

B5
a*b*
<
(a|b)*

B6
((a|b)(a|b))*
>
(ab|ba)*

B7
((a|b)(a|b))*
=
(aa|ab|ba|bb)*

B8
.*.*
=
.*

B9
(x*y*z*)*
=
(x|y|z)*

B10
(...|.....)*
>
.........*

B11
(...|.....)*
=
|...|.....|......|.........*

B12
(...|......)*
<
|...|.......*

B13
(...|....|.....)*
=
|....*

B14
(...|x...............|x..x)*
>
(...|x..............|x..x)*

B15
(...|x...............|x..x)*
<
(..|...|x..............|x..x)*

B16
(____)*_x__(____)*
|
(____)*x___(____)*

B17
(____)*_x__(____)*
X
(_____)*x_____(_____)*

B18
(____)*_x__(____)*
|
(______)*x______(______)*

B19
(____)*_x__(____)*
<
_*x__*

C. รูปแบบพื้นฐานพร้อมคลาสอักขระ

C1
[x]
=
x

C2
[xy]
|
xy

C3
[abc]
=
a|b|c

C4
[abc]
>
[ab]

C5
[abc]
<
[abcd]

C6
[ab]
X
[bc]

C7
[ab]
|
[cd]

C8
[abc]*
>
(a|b)*

C9
[^xyz]
>
a

C10
[^xyz]
|
x

C11
[^xyz]
|
[xyz]

C12
[^xyz]
X
[wxyz]

C13
[^xyz]
X
[^abc]

C14
[0-9]
=
[0123456789]

C15
[a-z]
>
[b-y]

C16
[a-z]
=
a|[b-y]|z

C17
[^0-9]*
>
Hello, World!

C18
[^0-9]*
|
123

C19
[^abc]
<
.

C20
[^abc]*
X
.

C21
[^a]|a
=
.

C22
[^abcd]|[a-c]|d
=
.

C23
[^a]*
X
b[^c]*

C24
[^a]*
|
a[^c]*

D. ลวดลายที่ซับซ้อนพร้อมคลาสของตัวละคร

D1
http://[^/][^/]*/.*
>
http://(www\.|)google\.com/.*

D2
http://[A-Za-z][A-Za-z]*\.wikipedia\.org/
X
(http://|)en\.wikipedia\.org/(|wiki(|/.*))

D3
[A-Za-z0-9._%+\-][A-Za-z0-9._%+\-]*@[A-Za-z0-9.\-][A-Za-z0-9.\-]*\.[A-Za-z][A-Za-z](|[A-Za-z]|[A-Za-z][A-Za-z])
X
email@address.com

D4
[A-Za-z0-9._%+\-][A-Za-z0-9._%+\-]*@[A-Za-z0-9.\-][A-Za-z0-9.\-]*\.[A-Za-z][A-Za-z](|[A-Za-z]|[A-Za-z][A-Za-z])
>
email@address\.com

D5
[A-Za-z0-9._%+\-][A-Za-z0-9._%+\-]*@[A-Za-z0-9.\-][A-Za-z0-9.\-]*\.[A-Za-z][A-Za-z](|[A-Za-z]|[A-Za-z][A-Za-z])
>
[A-Za-z0-9._%+\-][A-Za-z0-9._%+\-]*@gmail\.com

D6
JohnDoe@[A-Za-z0-9.\-][A-Za-z0-9.\-]*\.[A-Za-z][A-Za-z](|[A-Za-z]|[A-Za-z][A-Za-z])
<
[A-Za-z0-9._%+\-][A-Za-z0-9._%+\-]*@[A-Za-z0-9.\-][A-Za-z0-9.\-]*\.[A-Za-z][A-Za-z](|[A-Za-z]|[A-Za-z][A-Za-z])

D7
[A-Za-z0-9._%+\-][A-Za-z0-9._%+\-]*@gmail\.com
X
JohnDoe@[A-Za-z0-9.\-][A-Za-z0-9.\-]*\.[A-Za-z][A-Za-z](|[A-Za-z]|[A-Za-z][A-Za-z])

D8
[^, a-z][^,]*(|(, [^, ][^,]*)* and [^, ][^,]*)\.
>
One, two and three\.

D9
[^, a-z][^,]*(|(, [^, ][^,]*)* and [^, ][^,]*)\.
|
one, two and three\.

D10
[^, a-z][^,]*(|(, [^, ][^,]*)* and [^, ][^,]*)\.
|
One, two\.

D11
[^, a-z][^,]*(|(, [^, ][^,]*)* and [^, ][^,]*)\.
<
(.*(,|))*

D12
[A-Z][^,]*(|(, [a-z][^,]*)* & [a-z][^,]*)\.
<
[^, a-z][^,]*(|(, [^, ][^,]*)* (and|et|[&+]) [^, ][^,]*)\.

โปรแกรมทดสอบ

ตัวอย่างต่อไปนี้สามารถใช้ในการเปรียบเทียบรูปแบบ regex:

<style>#main {display: none;}#main[loaded] {display: inline;}.pattern_container {position: relative;}.pattern_underlay, .pattern {font: 12pt courier, monospace;overflow: hidden;white-space: pre;padding: 7px;box-sizing: border-box;}.pattern_underlay {background-color: #dddddd;color: #707070;border-radius: 4px;box-shadow: 0.5px 0.5px 2.5px #aaaaaa;}.pattern_underlay[error] {background-color: #ffccbb;}.pattern {position: absolute;left: 0px;top: 0px;background: none;border: none;width: 100%;height: 100%;resize: none;white-space: normal;}#ordering {min-width: 28pt;text-align: center;font-size: 16pt;}#status {padding: 5px;background-color: #fffdce;box-shadow: 1.5px 1.5px 3.5px #aaaaaa;font-size: 10pt;white-space: pre;display: none;}#status[error] {display: inline;background-color: #ffe8df;}#status[loading] {display: inline;}.inline_code {background-color: #dddddd;font: 12pt courier, monospace;padding: 2px;}.placeholder {visibility: hidden;}.error_text {background-color: #fffcb7};</style><span id="main"><table><tr><td><div class="pattern_container"><div class="pattern_underlay" id="pattern1_underlay"></div><textarea class="pattern" id="pattern1" oninput="compare()">Hello, .*!</textarea></div></td><td id="ordering"></td><td><div class="pattern_container"><div class="pattern_underlay" id="pattern2_underlay"></div><textarea class="pattern" id="pattern2" oninput="compare()">.*, .*!</textarea></div></td></tr></table><br></span><span id="status" loading>Loading...</span><script type='text/javascript'>var Module = {setStatus: function (status) {document.getElementById("status").innerHTML = status;if (status == "") {compare();document.getElementById("status").removeAttribute("loading");document.getElementById("main").setAttribute("loaded", 1);}}};function underlay_chars(str) {if (/^\n*$/.exec(str))return str.split("\n").map(function () { return '<span class="placeholder"> \n</span>'; });if (str.indexOf("\n") >= 0)str = str.replace(/\s*$/gm, function (m) { return m.replace(/[^\n]/g, "\0"); });return (str + "\n").split("").map(function (c) {if (c == "\0") return "·";else return '<span class="placeholder">' + c + '</span>';});}function underlay_str(str) {return underlay_chars(str).join("");}function str_to_array32(str) {a = [];for (c of str) {n = c.charCodeAt(0);a.push(n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, n >> 24);}a.push(0, 0, 0, 0);return a;}function compare() {try {for (e of ["pattern1_underlay", "pattern2_underlay", "status"])document.getElementById(e).removeAttribute("error");for (e of ["pattern1", "pattern2"])document.getElementById(e + "_underlay").innerHTML = underlay_str(document.getElementById(e).value);c = Module.ccall("regex_compare", "number", ["array", "array"], [str_to_array32(document.getElementById("pattern1").value),str_to_array32(document.getElementById("pattern2").value)]);if (c >= 0)document.getElementById("ordering").innerHTML = "∥≬<>="[c];else {i = Module.ccall("regex_error_index", "number", [], []);l = Module.ccall("regex_error_length", "number", [], []);e = document.getElementById("pattern" + -c + "_underlay");t = underlay_chars(document.getElementById("pattern" + -c).value);e.setAttribute("error", 1);e.innerHTML =t.slice(0, i).join("") +'<span class="error_text">' + t.slice(i, i + l).join("") + "</span>" +t.slice(i + l).join("");e.setAttribute("error", 1);throw "Pattern error: " + Module.ccall("regex_error", "string", [], []).replace(/`(.*?)'/g, '<span class="inline_code">$1</span>');}} catch (e) {document.getElementById("ordering").innerHTML = "??";document.getElementById("status").innerHTML = e;document.getElementById("status").setAttribute("error", 1);}}</script><script async type="text/javascript" src="https://gist.githack.com/anonymous/91f27d6746566c7b4e4c/raw/c563bf84a01c3a1c6e5f021369a3e730a2e74a1a/rpo.js"></script>

Python 2, 522 ไบต์ * .92 = 480.24 537.28

แก้ไข 2 : -60 ไบต์

แก้ไข : เพิ่มคำอธิบาย

กำหนดเป็นฟังก์ชั่นfซึ่งจะใช้เวลาสองสตริงรูปแบบเป็นข้อโต้แย้งและผลตอบแทน'<', '=', '>', หรือ'|' 'X'ใช้เวลาน้อยกว่าหนึ่งนาทีในการประมวลผลกรณีทดสอบทั้งหมด

รหัสประกอบด้วยดังต่อไปนี้ แต่ด้วย \r , \n \tและหนีฐานสิบหก ( แต่ไม่\0) แทนที่ด้วยค่าไบต์จริงของพวกเขา

#encoding=Latin
exec"""x\xda]RMo\xdb0\x0c\xbd\xe7Wx\'K\x96\x92\xc5mOR\xb8\xdf1@%|\x98%X\x80a\x19\x96\x02\x03n\xf2\xdfG:i;\xec$\x92z|\x8f_\x1b\x84%m~\xca\xbe\x1c\x0e\xbd\x0fU\x10Agi\x0e\x87\xea\n\x1f\xf9n{=\xea\0\x93\x08\xd2\xaez\xd0\x99\xcc,m\x07g\xbb\x80s\x9b\x08\xee\x8cRo"\xf3\x8bHy!-\x95\xd7\xa9\x8aS\xb50O5\xc3&\xb68\x0b\xe7\xb1\x19t\x92\x8a\x1d\xaf]\xc2f\x94\x92\x111T\xf3\xf1j\xba\x1b\x081r\xa2\x97\xea\xa5\x11\x03\x9bI\xca\xe6\xed\xe7\xab\xbd\xde`\xb6\x8b"\xd1\xc5\xf7\xd7?^l\xa7\xaeKK\xd7i\x91\x92\x8b\xaaE\x16\x8e\x9c\x12#3\x86\xe0"\xc6\xc9\x15\xfd\x86\xae\\\xde\xcc^\xa7\x94;,\xea\x94t\x08\x84\xa6J\x82\xee%\xb1\xe8\xacW\xb9\xb3\x14f\xd9\x84\xeb\x89\xe1\x8b\xd5\xa3r\xeb\xbf\x81D\rS\xf5\x8b/\xd7e\xaao\xf0\xeb\xf2\xbbv\xdd\xf1\x15\x1f\x93\xe4Aq\xff\x19\xc6\x98\x8b\xa8E\xad\xb2\xaae-m\x843\xc5\xd7!\x8e\xbe\xca.\x1a4\x01\xe8E;@-\xe4\xad9\xd5\xa7\x10\xa7\x9eg\xcea\x10\x83\x0e\xd2\r\x973\xb2o\xb8\xd7\x06\xc2\x0f\xa8\xdf\xdfk\x1b\x15\xb4v\x84H\xc9\xad]\xc1\x83C;\x03m\xc3\x16p\x1f\xe3\x1d\xbf\xa4\xe2\xbe\x8d\x1eX)\x1e\t\x9dv\xf3\xa9\xcd\xe8xGU\x9e\x0b\t\x97\xd6\x0c\x8c\xf2\nxa\xa9\x19u\xaf\xf2iN3\r\xd1\xae\x0f\xe3\x13\x0c@h\xb5W\xb0\xaad3\xef\t\x91s]R=~\xc3^Lv\xc7\x16\x15\xf4\xfb\xa7\x88ze_~B\x06\x80\x99\x03\x86\x7f\x0bY\x06U\xd2.\xeaV\x95\x87$\xd1\xce\xff\x8b\xbf\x9a\x99\xe0\x03u\xa1 =o0<n\xd0\xef]s`b\xb7\x98\x89\xael\xd2\x85\xceO:>\x80j\xfa\xdeb\x95\x95k\x91N\xbe\xfc'5\xac\xe7\xe8\x15""".decode('zip')

คำสั่งดังกล่าวทำให้รหัสต่อไปนี้จะถูกดำเนินการ:

z=frozenset
def f(f,s):
 u={s};d,l,f=n(f);w,h,s=n(s);_=0;r=[[z(f[0]),z(s[0])]]
 for e,o in r:
  p=z(zip([e]*h,o)+zip(e,[o]*l))
  if p-u:_|=((l in e)+2*(h in o))*4/3;u|=p;r+=[[reduce(z.__or__,(oo[i+1]for i in ii if ff[i]in[t,4][t<4:]),z())for ii,oo,ff in(e,f,d),(o,s,w)]for t in z([d[i]for i in e]+[w[i]for i in o])]
 return'|=><X'[_-3]
def n(s):
 s=list('('+s+')');i=0
 while s[i:]:f=s[i];h='()|*.'.find(f);s[i]=(h,f)[h<0];s[i:i+1]*=f!='\\';i+=1;l=i;h=1;w=e=[];p=[0];t=[{l}]
 while i:
  d=[i];i-=1;o=[i];f=s[i];t=[{i}]+t
  if f<1:h-=1;e+=zip(o*l,d+s.pop());w.pop()
  if f==1:h+=1;w=w+o;s+=[[]];e+=[o+d]
  if f==2:s[-1]+=d;e+=[(i,w[-1])]
  if h==p[-1]:e+=[t[-1:]+o,[i,1+t.pop()]];p.pop()
  if f==3:p+=[h];t+=o
 for f,o in e:
  for n in t:n|=(n,t[o])[f in n]
 return s+[1],l,t

หากตัวอย่างโค้ดที่สองถูกเก็บไว้ในสตริงsสิ่งที่คล้ายกับตัวอย่างแรกสามารถสร้างได้โดยนิพจน์'#encoding=Latin\nexec"""%s"""'%__import__('zlib').compress(s)สิ่งที่คล้ายกับคนแรกที่สามารถผลิตได้โดยการแสดงออก อาจจำเป็นต้องแก้ไขอักขระบางตัวเช่น null null หรือ backslashes รหัสซิปเกือบ1000 800 ไบต์ดังนั้นบางทีมันจะยุ่งเหยิงมากกว่าแข็งแรงเล่นกอล์ฟ ... แต่อย่างน้อยฉันจัดการเพื่อกอล์ฟเข้ารหัสบิต: จากไปLatin1Latin

คำอธิบาย

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

ฟังก์ชั่นหลักทำ BFS ผ่านสายป้อนข้อมูลที่เป็นไปได้ มันติดตามชุดของดัชนีที่เป็นไปได้ทั้งหมดสำหรับส่วนใด ๆ ของสตริงที่กำลังพิจารณา สิ่งที่เราสนใจในการค้นหาคือสถานะที่ทั้งสองยอมรับโดย regexes หรือโดยหนึ่งและไม่ใช่อื่น ๆ เพื่อแสดงว่ายอมรับ regex มีความจำเป็นต้องค้นหาเส้นทางที่เป็นไปได้ของการเปลี่ยนผ่านไปยังจุดสิ้นสุดของรูปแบบ แต่เพื่อแสดงว่ามีใครถูกปฏิเสธจำเป็นต้องวิเคราะห์เส้นทางที่เป็นไปได้ทั้งหมด ดังนั้นเพื่อพิจารณาว่าชุดของสถานะที่เป็นไปได้สำหรับรูปแบบ A และรูปแบบ B นั้นได้รับการครอบคลุมโดยคนที่ได้รับการวิเคราะห์มาก่อนแล้วคู่ของรัฐเดี่ยวในหนึ่ง regex และชุดของสถานะที่เป็นไปได้ทั้งหมดในอีกรัฐหนึ่ง หากไม่มีรายการใหม่แสดงว่าคุณสามารถย้อนกลับได้ แน่นอนว่ามันจะเป็นไปได้และมีตัวละครน้อยลง

Haskell, 560 553 618

อาจได้รับโบนัสบางอย่างที่ทำในอนาคต

นี่ยังไม่สมบูรณ์นัก

import Data.List
c%j|'\\':h:s<-j=[s|c==h]|(a,b):_<-[(a,b)|x<-[0..length j],(a,'|':b)<-[splitAt x j],snd(k b)==[]]=c%a++c%b|'(':s<-j,(a,_:'*':b)<-k s=map(++j)(c%a)++c%b|'(':s<-j,(a,_:b)<-k s=map(++b)(c%a)|h:'*':s<-j=map(++j)(c%[h])++c%s
c%"."=[""|c>'\0']
c%s@[_]=c%('\\':s)
c%(a:b)=map(++b)(c%[a])
c%s=[""|c>'\0']
a&b=nub[(x,nub$b>>=(c%))|c<-[' '..'~'],x<-c%a]
g e(k@(a,l):r)|j<-a&l\\e=g(k:e)(j++r)
g e[]=e
a#b=or[all(null.('\0'%))m|(x,m)<-g[][(a,[b])],""<-'\0'%x]
a!b|a#b,b#a='x'|a#b='>'|b#a='<'|0<1='='
k"("=("","(")
k(c:s)|'('<-c,(x,y)<-k$tail b=('(':a++')':x,y)|')'<-c=("",')':s)|0<1=(c:a,b)where(a,b)=k s
k j=(j,j)

คำอธิบายของอัลกอริทึมแบบคลื่นมือ:

reg!reg' ส่งกลับถ่านที่ต้องการหนึ่งใน "= <> x"

a#bเป็น IFF จริงไม่สตริงที่ทุกแมตช์นอกจากนี้ยังมีการจับคู่โดยab

c%regเป็นรายการของการแสดงออกปกติดังกล่าวที่regตรงกับc:sIFF หนึ่ง regexps sในการแข่งขันการส่งออก ฉันเป็นพื้นตรงกับ regex บางส่วน ยกเว้นถ้าเป็นc '\0'แล้วมันบังคับregไม่ได้รับข้อมูลใด ๆ เพิ่มเติมกลับ[]ถ้าregจะต้องได้รับข้อมูลมากขึ้นในการจับคู่และ[""]เป็นอย่างอื่น

#ทำงานโดยการสร้างรายการที่ จำกัด ของ "regex-state" ที่เป็นไปได้ทั้งหมด regexps ทั้งสองจะอยู่ในหลังจากสตริงที่กำหนดเอง จากนั้นเพื่อตรวจสอบว่าa<bเราตรวจสอบสภาพอากาศหรือไม่นั้นมี "สถานะ regex" ซึ่งaมีการจับคู่อย่างสมบูรณ์ แต่bไม่ได้จับคู่อย่างสมบูรณ์