परिमित ऑटोमेटा से नियमित अभिव्यक्तियों में रूपांतरण करने के लिए कई विधियाँ हैं। यहाँ मैं स्कूल में पढ़ाया जाने वाला वर्णन करूँगा जो बहुत ही दृश्य है। मेरा मानना है कि यह व्यवहार में सबसे अधिक उपयोग किया जाता है। हालाँकि, एल्गोरिथ्म लिखना इतना अच्छा विचार नहीं है।
राज्य हटाने की विधि
यह एल्गोरिथम ऑटोमेटन के ग्राफ को संभालने के बारे में है और इस प्रकार एल्गोरिदम के लिए बहुत उपयुक्त नहीं है क्योंकि इसके लिए ग्राफ प्राइमेटिव्स की आवश्यकता होती है ... जैसे राज्य निकालना। मैं इसे उच्च-स्तर की प्राथमिकताओं का उपयोग करके वर्णन करूंगा।
प्रमुख विचार
किनारों पर नियमित अभिव्यक्ति पर विचार करना है और फिर किनारों को लेबल के अनुरूप रखते हुए मध्यवर्ती राज्यों को हटाना है।
मुख्य पैटर्न निम्नलिखित आंकड़ों में देखा जा सकता है। पहले में बीच के लेबल हैं जो नियमित अभिव्यक्ति e , f , g , h , i हैं और हम q को हटाना चाहते हैं ।p,q,re,f,g,h,iq
एक बार निकाल हम रचना एक साथ (जबकि बीच अन्य किनारों संरक्षण पी और आर लेकिन यह इस पर प्रदर्शित नहीं है):e,f,g,h,ipr
उदाहरण
राफेल के उत्तर में उसी उदाहरण का उपयोग करना :
हम क्रमिक रूप से हटाते हैं :q2
और फिर :q3
तो हम अभी भी से अभिव्यक्ति पर एक स्टार आवेदन करना होगा करने के लिए क्यू 1 । इस स्थिति में, अंतिम स्थिति भी प्रारंभिक है, इसलिए हमें वास्तव में एक स्टार जोड़ने की आवश्यकता है:q1q1
(ab+(b+aa)(ba)∗(a+bb))∗
कलन विधि
L[i,j]
से q j तक भाषा का rexxp है । सबसे पहले, हम सभी बहु-किनारों को हटा देते हैं:qiqj
for i = 1 to n:
for j = 1 to n:
if i == j then:
L[i,j] := ε
else:
L[i,j] := ∅
for a in Σ:
if trans(i, a, j):
L[i,j] := L[i,j] + a
अब, राज्य को हटाने। मान लीजिए कि हम राज्य को हटाना चाहते हैं :qk
remove(k):
for i = 1 to n:
for j = 1 to n:
L[i,i] += L[i,k] . star(L[k,k]) . L[k,i]
L[j,j] += L[j,k] . star(L[k,k]) . L[k,j]
L[i,j] += L[i,k] . star(L[k,k]) . L[k,j]
L[j,i] += L[j,k] . star(L[k,k]) . L[k,i]
star(ε)=ε
e.ε=e
∅+e=e
∅.e=∅
∅εक्ष कश्मीर क्ष ञ क्ष कश्मीरqiqkqjqk
अब, कैसे उपयोग करें remove(k)
? आपको अंतिम या प्रारंभिक राज्यों को हल्के से नहीं निकालना चाहिए, अन्यथा आप भाषा के कुछ हिस्सों को याद करेंगे।
for i = 1 to n:
if not(final(i)) and not(initial(i)):
remove(i)
यदि आपके पास केवल एक अंतिम स्थिति और एक प्रारंभिक अवस्था तो अंतिम अभिव्यक्ति है:q स sqfqs
e := star(L[s,s]) . L[s,f] . star(L[f,s] . star(L[s,s]) . L[s,f] + L[f,f])
यदि आपके पास कई अंतिम राज्य (या यहां तक कि प्रारंभिक राज्य) हैं तो इन लोगों को विलय करने का कोई सरल तरीका नहीं है, जो कि संक्रामक बंद करने की विधि को लागू करने के अलावा है। आमतौर पर यह हाथ से समस्या नहीं है, लेकिन एल्गोरिथ्म लिखते समय यह अजीब है। एक बहुत सरल समाधान का सभी जोड़ों की गणना करने में है और (पहले से ही राज्य से हटाया) ग्राफ पर एल्गोरिथ्म सभी भाव प्राप्त करने के लिए चलाने के मान केवल प्रारंभिक अवस्था है और केवल अंतिम है राज्य, फिर सभी का मिलन ।ई एस , एफ एस एफ ई एस , एफ(s,f)es,fsfes,f
यह, और यह तथ्य कि यह भाषाओं को पहली विधि की तुलना में अधिक गतिशील रूप से संशोधित कर रहा है, प्रोग्रामिंग करते समय इसे और अधिक त्रुटि-प्रवण बनाता है। मैं किसी अन्य विधि का उपयोग करने का सुझाव देता हूं।
विपक्ष
इस एल्गोरिथ्म में बहुत सारे मामले हैं, उदाहरण के लिए कि हमें किस नोड को चुनना चाहिए, अंत में अंतिम राज्यों की संख्या, तथ्य यह है कि एक अंतिम राज्य प्रारंभिक हो सकता है, आदि।
ध्यान दें कि अब एल्गोरिथ्म लिखा गया है, यह एक बहुत ही सकर्मक बंद करने की विधि है। केवल उपयोग का संदर्भ अलग है। मैं एल्गोरिथ्म को लागू करने की अनुशंसा नहीं करता, लेकिन हाथ से करने के लिए विधि का उपयोग करना एक अच्छा विचार है।