คำถามติดแท็ก regular-expressions

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

115 algorithms  formal-languages  finite-automata  regular-expressions  reference-question 

เท่าที่เห็นในแถบ XKCD ที่ผ่านมานี้และโพสต์บล็อกล่าสุดนี้จาก Peter Norvig (และ Slashdot เนื้อเรื่องหลัง), "regex golf" (ซึ่งอาจเรียกได้ว่าเป็นปัญหาการแยกนิพจน์ทั่วไป) เป็นปริศนาของการกำหนดนิพจน์ปกติที่สั้นที่สุดที่เป็นไปได้ที่ยอมรับทุกคำในเซต A และไม่มีคำใน โพสต์ของ set B. Norvig มีอัลกอริธึมสำหรับการสร้างผู้สมัครที่มีเหตุผลสั้น ๆ และเขาสังเกตว่าวิธีการของเขาเกี่ยวข้องกับการแก้ปัญหาชุด NP-complete แต่เขาก็ระมัดระวังที่จะชี้ให้เห็นว่าวิธีการของเขานั้น และแน่นอนว่าเขาไม่จำเป็นต้องเป็นอัลกอริธึมเท่านั้นดังนั้นวิธีแก้ปัญหาของเขาจึงไม่รับประกันว่าจะดีที่สุดและเป็นไปได้ว่าอัลกอริธึมแบบพหุนามเวลาอื่น ๆ สามารถหาวิธีแก้ปัญหาที่เทียบเท่าหรือดีกว่าได้ เพื่อประโยชน์ของ concreteness และเพื่อหลีกเลี่ยงการแก้ไขคำถามการปรับให้เหมาะสมฉันคิดว่าสูตรที่เป็นธรรมชาติที่สุดของการแยกนิพจน์ปกติคือ: ให้สอง (จำกัด ) ชุดและBของสายอักขระบางตัวΣ , มีการแสดงออกปกติของความยาว≤ kที่ยอมรับทุกสายในAและปฏิเสธทุกสายในB ?AAABBBΣΣ\Sigma≤ k≤k\leq kAAABBB มีความรู้เกี่ยวกับความซับซ้อนของปัญหาการแยกนี้หรือไม่? (โปรดทราบว่าเนื่องจากฉันได้ระบุและBเป็นชุด จำกัด ของสตริงความคิดตามธรรมชาติของขนาดสำหรับปัญหาคือความยาวทั้งหมดของสตริงทั้งหมดในAและBซึ่งจะเพิ่มการสนับสนุนจากk ) ดูเหมือนว่าเป็นไปได้สูงที่ฉันจะใช้ NP-Complete (และในความเป็นจริงฉันคาดว่าการลดลงของปัญหาการปกปิดบางส่วน) แต่การค้นหาบางอย่างไม่ได้เปิดใช้งานอะไรที่มีประโยชน์เป็นพิเศษAAABBBAAABBBkkk

27 complexity-theory  np-complete  regular-expressions 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Computer Science Stack Exchange อพยพ 7 ปีที่ผ่านมา ฉันสร้างนิพจน์ทั่วไปอย่างง่าย lexer และ parser เพื่อทำนิพจน์ปกติและสร้างแผนภูมิการแยกวิเคราะห์ การสร้างออโตเมติกอัน จำกัด ที่ไม่ได้กำหนดค่าจากต้นไม้การแยกวิเคราะห์นี้ค่อนข้างง่ายสำหรับนิพจน์ทั่วไปขั้นพื้นฐาน อย่างไรก็ตามฉันไม่สามารถคาดศีรษะได้ว่าจะทำอย่างไรในการจำลองการอ้างอิงย้อนกลับ, Lookaheads และ Lookbehinds จากสิ่งที่ฉันอ่านในหนังสือมังกรสีม่วงฉันเข้าใจว่าการจำลอง lookahead ซึ่งนิพจน์ปกติrถูกจับคู่ถ้าหากการจับคู่ตามด้วยการจับคู่ของนิพจน์ทั่วไปคุณสร้างขอบเขตที่ไม่ จำกัด รัฐหุ่นยนต์ที่/จะถูกแทนที่ด้วยε เป็นไปได้หรือไม่ที่จะสร้างออโตเมติกอัน จำกัด ที่กำหนดได้ซึ่งทำเช่นเดียวกัน?r / sr/sr/sRrrsss///εε\varepsilon สิ่งที่เกี่ยวกับการจำลอง lookaheads เชิงลบและ lookbehinds? ฉันจะขอบคุณถ้าคุณจะเชื่อมโยงฉันไปยังแหล่งข้อมูลที่อธิบายวิธีการทำอย่างละเอียด

26 automata  finite-automata  regular-expressions 

นี่คือการคาดเดาสำหรับนิพจน์ทั่วไป: สำหรับการแสดงออกปกติให้ความยาวเป็นจำนวนของสัญลักษณ์ในนั้นละเว้นเครื่องหมายวงเล็บและตัวดำเนินการ เช่นRRR|R||R||R||0∪1|=|(0∪1)∗|=2|0∪1|=|(0∪1)∗|=2|0 \cup 1| = |(0 \cup 1)^*| = 2 การคาดเดา:ถ้าและมีความยาวทุกสตริงหรือน้อยกว่านั้น *|R|>1|R|>1|R| > 1L(R)L(R)L(R)|R||R||R|L(R)=Σ∗L(R)=Σ∗L(R) = \Sigma^* นั่นคือถ้าคือ 'หนาแน่น' ถึงยาว 's แล้วจริงสร้างทุกอย่างL(R)L(R)L(R)RRRRRR บางสิ่งที่อาจเกี่ยวข้อง: ต้องการเพียงส่วนเล็ก ๆ ของเพื่อสร้างสตริงทั้งหมด ยกตัวอย่างเช่นในไบนารีจะทำงานใด ๆSRRRR=(0∪1)∗∪SR=(0∪1)∗∪SR = (0 \cup 1)^* \cup SSSS จะต้องมีดาว Kleene ในในบางจุด หากไม่มีอยู่มันจะพลาดสตริงที่มีขนาดน้อยกว่า.RRR|R||R||R| มันจะเป็นการดีที่ได้เห็นหลักฐานหรือตัวอย่าง มีบางกรณีที่ฉันผิดพลาดหรือไม่? มีใครเห็นสิ่งนี้ (หรือบางอย่างที่คล้ายกัน) มาก่อนหรือไม่

25 formal-languages  regular-languages  regular-expressions 

ฉันได้ดูคำตอบสำหรับคำถามนี้และดูเหมือนว่าทุกคนรู้คำตอบโดยปริยายยกเว้นฉัน สันนิษฐานว่าเป็นเพราะคนเพียงคนเดียวที่สนใจคือผู้ที่มีการศึกษาระดับอุดมศึกษาในเรื่อง ในทางกลับกันฉันถูกโยนลงไปลึกสุดเพื่อรับงานมัธยมปลาย คำถามของฉันคือภาษาการเขียนโปรแกรมเกี่ยวข้องกับภาษาทางการอย่างไร ทุกที่ที่ฉันอ่านมีบางสิ่งที่เรียงตามแนวของ "ภาษาที่เป็นทางการใช้เพื่อกำหนดไวยากรณ์ของภาษาโปรแกรม" ตอนนี้จากสิ่งที่ฉันสามารถรวบรวมได้ภาษาทางการเป็นชุดของกฎการผลิตที่ใช้กับชุดสัญลักษณ์เฉพาะ (ตัวอักษรของภาษา) กฎการผลิตเหล่านี้กำหนดชุดการแปลงเช่น: b -> a aaa->c สิ่งนี้สามารถนำไปใช้ได้เช่น: abab->aaaa aaaa-> ca เช่นเดียวกับบันทึกย่อหากเรากำหนดว่าตัวอักษรของภาษาทางการของเราคือ {a, b, c} จากนั้น a และ b ไม่ใช่เทอร์มินัลและ c เป็นเทอร์มินัลเนื่องจากไม่สามารถเปลี่ยนได้ (โปรดแก้ไขให้ฉันด้วยถ้าฉันผิด ที่). ถ้าอย่างนั้นจะใช้กับภาษาโปรแกรมได้อย่างไร บ่อยครั้งที่มีการระบุด้วยว่า regex ใช้ในการแยกภาษาในรูปแบบข้อความเพื่อให้แน่ใจว่าไวยากรณ์นั้นถูกต้อง มันสมเหตุสมผลแล้ว จากนั้นจะกล่าวว่า regex ถูกกำหนดโดยภาษาทางการ Regex ส่งคืนจริงหรือเท็จ (จากประสบการณ์ของฉันอย่างน้อย) ขึ้นอยู่กับว่าสถานะออโตมาต้าที่ จำกัด ซึ่งแสดงถึง regex มาถึงจุดเป้าหมายหรือไม่ เท่าที่ฉันเห็นมันไม่มีส่วนเกี่ยวข้องกับการเปลี่ยนแปลง * สำหรับการรวบรวมโปรแกรมนั้นฉันคิดว่าภาษาทางการจะสามารถแปลงรหัสให้เป็นรหัสระดับล่างได้อย่างต่อเนื่องในที่สุดก็ถึงการชุมนุมผ่านชุดกฎที่ซับซ้อนซึ่งฮาร์ดแวร์นั้นสามารถเข้าใจได้ นั่นคือสิ่งที่มาจากมุมมองที่สับสนของฉัน …

25 formal-languages  programming-languages  regular-expressions 

ในฐานะที่เป็นชื่อเรื่องว่าผมใช้เวลาสองสามชั่วโมงสุดสัปดาห์สุดท้ายพยายามที่จะตัดขึ้นใจของฉันเกี่ยวกับระดับของภาษาการจับคู่โดยการแสดงออกปกติ Perl ได้ที่ไม่รวมผู้ประกอบการจับคู่ใด ๆ ที่จะช่วยให้การรันโค้ดภายในรูปแบบ หากคุณไม่ได้รู้ว่าสิ่งที่เป็น PCREs โปรดอ่านนี้และนี้ ปัญหาคือทรัพยากรที่มีอยู่บนอินเทอร์เน็ตหยุดอยู่ที่ภาษาที่ไม่มีบริบทและ PCREs สามารถจับคู่ได้มากกว่านั้น (ดูด้านล่าง) แต่ฉันไม่รู้ว่าจะหาทฤษฏีหรือเอกสารเพิ่มเติมเกี่ยวกับเรื่องแบบนี้ได้ที่ไหน โดยเฉพาะอย่างยิ่ง: PCRE เป็นชุดภาษาปกติ (เนื่องจากไวยากรณ์ PCRE มีตัวดำเนินการภาษาปกติทั้งหมด) CFG ใด ๆ สามารถใส่ในรูปแบบปกติของ Greibach ซึ่งจะทำการลบการเรียกซ้ำไปทางซ้าย ฉันคิดว่าสิ่งนี้สามารถใช้โดย(?(DEFINE)...)กลุ่มเพื่อ "แปล" ไวยากรณ์เป็นรูทีนย่อยที่ตรงกันหลีกเลี่ยงที่จะสำลักในการเรียกซ้ำซ้ายโดยการแปล: non-terminal ที่หัวของการผลิตแต่ละครั้งจะกลายเป็นรูทีนย่อย (?<HEAD>...) เนื้อหาของการผลิตแต่ละครั้งจะถูกใส่ไว้ในรูทีนย่อย เทอร์มินัลถูกทิ้งไว้ตามที่เป็นอยู่มินัลจะกลายเป็นการร้องขอขั้นตอน (เช่น(?&NONTERMINAL)); โปรดักชั่นทั้งหมดที่มี nonterminal เช่นเดียวกับหัวเป็น ORed ร่วมกันโดยวิธีการของ|ผู้ประกอบการ (รวมทั้งการจัดกลุ่มเพิ่มเติมด้วย(?:...)ถ้าจำเป็น) รูปแบบนั้นจะกลายเป็น(?(DEFINE)...)กลุ่มที่มีการผลิต "แปล" ทั้งหมดและการร้องขอสำหรับกระบวนการของสัญลักษณ์เริ่มต้นเพื่อให้ตรงกับสตริงทั้งหมดเช่น^(?(DEFINE)...)(?&START)$ สิ่งนี้ควรจัดการกับ CFG ใด ๆ ดังนั้น PCREs ควรจะสามารถจับคู่ …

23 formal-languages  regular-expressions 

การตั้งค่า: นิพจน์ปกติที่มีการอ้างอิงย้อนกลับ ภาษาเดียว (ตัวอักษรสัญลักษณ์ 1 ตัว) ปัญหาต่อไปนี้สามารถแก้ไขได้ในการตั้งค่านี้: ได้รับการแสดงออกปกติด้วย backreferences มันกำหนดภาษาปกติหรือไม่ ตัวอย่างเช่น(aa+)\1กำหนดภาษาปกติโดยที่(aa+)\1+ไม่ทำเช่นนั้น เราสามารถตัดสินใจได้ว่าจะใช้กรณีใด สำหรับ concreteness "นิพจน์ทั่วไปที่มีการอ้างอิงย้อนกลับ" ที่นี่อ้างถึงเช่นชุดย่อยต่อไปนี้ของนิพจน์ปกติที่เข้ากันได้กับ Perl ปกติ : aจับคู่อักขระa( อักขระเพียงตัวเดียวในตัวอักษร) X* ตรงกับ 0 หรือมากกว่าที่เกิดขึ้นของ X X|Yจับคู่XหรือY วงเล็บสามารถใช้สำหรับการจัดกลุ่มและการจับภาพ \1. \2และอื่น ๆ จับคู่สตริงเดียวกันกับวงเล็บคู่ที่ 1, 2 และอื่น ๆ นอกจากนี้เรายังสามารถใช้ shorthands ปกติเช่น=X+XX*

18 formal-languages  computability  regular-languages  undecidability  regular-expressions 

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

16 regular-expressions  parsers 

ถ้าฉันมีไวยากรณ์ประเภทที่ 3 มันสามารถถูกแสดงในออโตเมติกแบบกดลง (โดยไม่ต้องดำเนินการใด ๆ กับสแต็ก) ดังนั้นฉันจึงสามารถแสดงนิพจน์ทั่วไปโดยใช้ภาษาที่ไม่มีบริบท แต่ฉันจะรู้ได้อย่างไรว่าไวยากรณ์ 3 ประเภทคือ , L L ( 1 ) , S L R ( 1 )และอื่น ๆ โดยไม่ต้องสร้างตารางแยกวิเคราะห์?LR(1)LR(1)LR(1)LL(1)LL(1)LL(1)SLR(1)SLR(1)SLR(1)

16 formal-languages  regular-languages  formal-grammars  parsers  regular-expressions 

ฉันพบว่าหากฉันไม่เข้าใจนิรุกติศาสตร์ที่อยู่เบื้องหลังคำศัพท์ cs / programming มันมักจะหมายความว่าฉันพลาดหรือเข้าใจผิดแนวคิดพื้นฐานที่สำคัญบางอย่าง ฉันไม่เข้าใจว่าทำไมดาว Kleene จึงถูกเรียกว่าการปิด Kleene มันเกี่ยวข้องกับการปิดในการเขียนโปรแกรมฟังก์ชั่นที่มีตัวแปรที่ไม่ใช่ท้องถิ่นที่ถูกผูกไว้หรือไม่? ... ในการไตร่ตรองอาจเป็นเพราะมันอนุญาตให้เขียนชุดเปิดปลายในรูปแบบนิพจน์ปิด? ... ในแบบเป็ดยางอธิบายได้ดีตอนนี้ฉันเดาว่ามัน แต่ก็ยังคงยินดีต้อนรับคำตอบที่มีสิทธิ์

14 automata  regular-expressions 

ฉันหลอกไปเมื่อวันก่อนในเว็บไซต์นี้: http://regexcrossword.com/และทำให้ฉันสงสัยว่าวิธีที่ดีที่สุดในการแก้ไขคืออะไร คุณสามารถแก้ปัญหาดังต่อไปนี้ในเวลาพหุนามหรือว่าเป็น NP- ยาก? ให้กริด NxM ที่มีนิพจน์ปกติ N สำหรับคอลัมน์และ M สำหรับแถวหาวิธีแก้ปัญหาใด ๆ ที่กริดเช่นว่านิพจน์ปกติทั้งหมดพอใจหรือกล่าวว่าไม่มีวิธีแก้ปัญหา

13 complexity-theory  np-hard  regular-expressions 

ปรากฏว่า "นิพจน์ธรรมดาพื้นฐาน" ตามที่กำหนดโดยPOSIX.1-2008ไม่สนับสนุนการสลับกันa|b(แม้ว่าการใช้ grep บางตัวจะรู้จักเวอร์ชันหลบหนี\|) เนื่องจากภาษาปกติถูกปิดภายใต้การรวมกันตามคำนิยามนี่หมายความว่า POSIX BRE มีพลังในการแสดงออกน้อยกว่าออโตเมติก จำกัด ? หรือมีวิธีการจำลองการสลับโดยใช้โครงสร้างอื่น ๆ ?

13 formal-languages  regular-expressions 

ปัญหา ไม่มีวิธีง่ายๆในการรับการเปลี่ยนแปลงด้วย regex การเปลี่ยนแปลง:การเดินทางคำ ( "aabc") ในการสั่งซื้ออื่นโดยไม่มีการเปลี่ยนแปลงจำนวนหรือชนิดของตัวอักษรw = x1… xnW=x1...xnw=x_1…x_n Regex:การแสดงออกปกติ สำหรับการตรวจสอบ: "การเปลี่ยนลำดับ Regex โดยไม่มีการทำซ้ำ"คำตอบจะสร้างรหัส JavaScript แทนการใช้ Regex โดยสมมติว่าสิ่งนี้ง่ายกว่ามาก "วิธีหาวิธีเรียงสับเปลี่ยนทั้งหมดของคำที่กำหนดในข้อความที่กำหนด" - คำตอบไม่ได้ใช้ regexes เช่นกัน "Regex จับคู่ทั้งหมด {1, 2, 3, 4} โดยไม่มีการทำซ้ำ" - คำตอบนั้นใช้ regexes แต่ก็ไม่สามารถปรับเปลี่ยนได้หรือไม่ง่าย คำตอบนี้ยังเรียกร้อง: "นิพจน์ทั่วไปไม่สามารถทำในสิ่งที่คุณขอมันไม่สามารถสร้างพีชคณิตจากสตริง." วิธีการแก้ปัญหาที่ฉันค้นหา ควรมีแบบฟอร์ม: » aabc « (หรืออะไรก็ได้ที่คุณสามารถใช้วงเล็บเปิดและปิด) (aabc)! (คล้ายกับ (abc)? แต่มีสัญลักษณ์อื่นในตอนท้าย) [aabc]! (คล้ายกับ [abc] …

13 formal-languages  regular-languages  regular-expressions 

ฉันคิดว่าภาษาปกติทั้งหมดสามารถแสดงออกด้วยการแสดงออกปกติ (ถ้าภาษาเป็นปกติมันสามารถแสดงด้วย regex) แต่ฉันได้รับแจ้งว่าคุณต้องการการดำเนินงานปกติทั้งสาม (การต่อเชื่อมสหภาพและดาว) ที่จะถือ ตัวอย่างเช่นผมได้รับการบอกว่าถ้าฉันสามารถเพียงใช้ยูเนี่ยนและการ concatenationการดำเนินงาน regex (2 จาก 3) จะมีภาษาปกติฉันไม่สามารถอธิบายที่มีเพียงสองคน เช่นเดียวกันกับ Kleene Star และ Union ตัวอย่างนี้มีอะไรบ้าง

12 formal-languages  regular-languages  regular-expressions  kleene-star 

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

12 automata  formal-grammars  regular-expressions