งานของคุณคือการรวบรวม regexes ... โดยการระบุการทดแทนสำหรับแต่ละตัวละครใน regex

regexes

regexes สนับสนุนสิ่งเหล่านี้

REGEX       = (LITERAL REGEX / GROUP REGEX / STAR REGEX / ALTERNATIVE)
LITERAL     = 1 / 0
GROUP       = '(' REGEX ')'
STAR        = (LITERAL / GROUP) '*'
ALTERNATIVE = '('REGEX ('|' REGEX)*')'

ทำไมเพียง 1 หรือ 0 มันเป็นเรื่องง่าย regex มีตัวอักษรต่อไปนี้เท่านั้น:

*()|10

มันถูกตีความดังนี้:

1. * คือ Kleene star (ทำซ้ำกลุ่มซ้ายหรือตัวอักษร 0 หรือมากกว่านั้น)
2. | เป็นทางเลือก (จับคู่หาก regex ไปทางซ้ายหรือ regex ไปทางขวา)
3. () กำลังจัดกลุ่ม
4. 1 ตรงกับตัวละคร 1
5. 0 ตรงกับตัวละคร 0

วิธีการรวบรวม

คุณระบุข้อมูลโค้ดหกชุด: หนึ่งชุดเพื่อแทนที่อักขระ regex แต่ละตัว ตัวอย่างเช่นหากคำตอบของคุณคือ:

*: FSAGFSDVADFS
|: GSDGSAG
(: GSDG
): GDSIH
1: RGIHAIGH
0:GIHEBN

จากนั้นคุณแทนที่แต่ละ regex ด้วยข้อมูลโค้ดดังนั้น:

(0|11)*

เปลี่ยนเป็น:

GSDGGIHEBNGSDGSAGRGIHAIGHRGIHAIGHGDSIHFSAGFSDVADFS

โปรแกรมผลลัพธ์ควรทำอย่างไร

โปรแกรมของคุณจะ:

1. รับอินพุต
2. ส่งออกค่าความจริงถ้า regex ตรงกับการป้อนข้อมูลทั้งหมด
3. เอาท์พุทเป็นค่าเท็จ

อินพุตภายนอก01ถูกพิจารณาพฤติกรรมที่ไม่ได้กำหนด ข้อมูลที่ป้อนว่างเปล่า

กฎเพิ่มเติม

1. สำหรับอักขระ regex ที่กำหนดตัวอย่างข้อมูลที่ได้จะต้องเหมือนกันเสมอ
2. ไม่มีตัวอักษรนำหน้าหรือคำต่อท้ายเพิ่มหลังจากนั้น
3. regex รับประกันว่าจะไม่มีข้อยกเว้น

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

ตัวอย่างข้อมูลที่รวมกันน้อยที่สุดคือผู้ชนะ ดังนั้นคะแนนสำหรับกรณีตัวอย่างจะถูกคำนวณดังนี้:

FSAGFSDVADFS+ GSDGSAG+ GSDG+ GDSIH+ RGIHAIGH+GIHEBN

12 + 7 + 4 + 5 + 8 + 6 = 42

หอยทาก 48 ไบต์

0 -> )0(\0!(l.)(~

1 -> )0(\1!(l.)(~

( -> )0({{(

) -> )0}}(~

| -> )0}|{(

* -> )0),(~

หากเราต้องค้นหาการจับคู่บางส่วนแทนที่จะจับคู่เฉพาะการป้อนข้อมูลเต็มรูปแบบมันจะง่ายมาก 0จะกลายเป็น\0, 1จะกลายเป็น\1, *จะกลายเป็น,และคนอื่น ๆ จะ map เพื่อตัวเอง แทนที่จะมีผู้เล่นหลายคนที่ป้องกันไม่ให้การแข่งขันเริ่มต้นที่อื่นนอกเหนือจากการเริ่มต้นหรือสิ้นสุดที่อื่นที่ไม่ใช่ตอนจบ !(l.)เป็นการยืนยันที่จะล้มเหลวหากการเริ่มต้นของการแข่งขันไม่ได้อยู่ที่จุดเริ่มต้นของการป้อนข้อมูล ~จับคู่เซลล์นอกอินพุตดังนั้นจะถูกเพิ่มในอักขระทั้งหมดที่ได้รับอนุญาตให้อยู่ที่ส่วนท้ายของ regex หากมีตัวละคร regex อื่นตามมามันจะถูกยกเลิกโดยตัวนับตัวเลข0ซึ่งต้องการให้จับคู่ 0 ครั้งโดยแสดงความคิดเห็นเป็นหลัก ในการอนุญาตให้*( ,) ทำงานอย่างถูกต้องแม้จะมีการทดสอบแบบหลอก ๆ ขอบเขตการใช้กฎการจับคู่วงเล็บของภาษาจะถูกใช้อย่างมาก จากเอกสาร:

การจับคู่วงเล็บ()หรือวงเล็บปีกกา{}จะทำงานตามที่คาดไว้ (เช่นวงเล็บใน regex) แต่ก็เป็นไปได้เช่นกันที่จะปล่อยครึ่งหนึ่งของคู่และสรุปไว้ตามกฎต่อไปนี้ )หรือ}จัดกลุ่มทุกอย่างทางซ้ายจนกว่าคำสั่งการเปิดกลุ่มที่ไม่ปิดผนึกที่ใกล้ที่สุดซึ่งเป็นประเภทเดียวกัน ( (หรือ{ตามลำดับ) หรือจุดเริ่มต้นของรูปแบบหากไม่มีอยู่ มันปิดคำแนะนำการเปิด unclosed ใด ๆ ของประเภทตรงข้ามในช่วงกลางของช่วงนี้ มิฉะนั้นจะไม่มีใครเทียบ(หรือ{ถูกปิดในตอนท้ายของรูปแบบ

ชัดเจนว่าเป็นโคลนใช่ไหม

CJam, 151 ไบต์

{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM0sa`T
{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM1sa`T
M{{+:M];eas!}:T}|U):UM'[T
MN`T
U(:UM'JT
M\"S+ea`,m*\"T

บรรทัดสอดคล้องกับอักขระ01(|)*(ตามลำดับนั้น) ลองออนไลน์!

สิ่งนี้ใช้ไม่มีการแสดงออกปกติในตัวหรือการจับคู่รูปแบบอื่น ๆ ในความเป็นจริง CJam ไม่มีคุณสมบัติเหล่านี้ แต่จะเริ่มจากนิพจน์ทั่วไปที่แสดงและสร้างสตริงที่เป็นไปได้ทั้งหมดที่อาจตรงกันเพื่อตรวจสอบในที่สุดว่าการป้อนข้อมูลผู้ใช้เป็นหนึ่งในนั้นหรือไม่

ทดสอบการทำงาน

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

$ cat regex.cjam
l"01(|)*""

{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM0sa`T
{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM1sa`T
M{{+:M];eas!}:T}|U):UM'[T
MN`T
U(:UM'JT
M\"S+ea`,m*\"T

"N%ers~
$ cjam regex.cjam '' <<< '(|)'
1
$ cjam regex.cjam '0' <<< '(|)'
0
$ cjam regex.cjam '' <<< '0(|)'
0
$ cjam regex.cjam '0' <<< '0(|)'
1
$ cjam regex.cjam '' <<< '(0|11)*'
1
$ cjam regex.cjam '0' <<< '(0|11)*'
1
$ cjam regex.cjam '11' <<< '(0|11)*'
1
$ cjam regex.cjam '011011000' <<< '(0|11)*'
1
$ cjam regex.cjam '1010' <<< '(0|11)*'
0

น่าเสียดายที่นี่ไม่เร็วมาก มันจะหายใจไม่ออกเร็วหากมีอักขระมากกว่า 9 ตัวในอินพุทหรือมากกว่าหนึ่งดาว Kleene ใน regex

ด้วยค่าใช้จ่ายเพิ่มเติม 5 ไบต์ - รวมเป็น156 ไบต์ - เราสามารถสร้างสตริงที่สั้นกว่าเพื่อจับคู่อินพุตที่มีศักยภาพกับและขจัดข้อมูลซ้ำซ้อน สิ่งนี้จะไม่เปลี่ยนวิธีการทำงานของรหัส มันทำให้มีประสิทธิภาพมากขึ้น

$ cat regex-fast.cjam 
l"01(|)*""

{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM0sa`T
{]Na/Saf+{:m*:sSf-~}%}:J{+:MU{]W=~Jea&,}|}:TM1sa`T
M{{+:M];eas!}:T}|U):UM'[T
MN`T
U(:UM'JT
M\"S+eas,)m*:sSf-L|\"T

"N%ers~
$ cjam regex-fast.cjam '0101001010' <<< '(01|10)*'
0
$ cjam regex-fast.cjam '011001101001' <<< '(01|10)*'
1
$ cjam regex-fast.cjam '0' <<< '(0*1)*'
0
$ time cjam regex-fast.cjam '101001' <<< '(0*1)*'
1