├── README.md
├── demo.gif
└── regex_to_min_dfa.cpp


/README.md:
--------------------------------------------------------------------------------
1 | # Automata From Regular Expressions
2 | 
3 | An interactive c++11 program to construct NFA, DFA, and minimized DFA from a given regular expression on the alphabet {a,b} and simulate the DFA on any possible input.
4 | 
5 | ![Demo](https://github.com/swapagarwal/automata-from-regex/blob/master/demo.gif)
6 | 


--------------------------------------------------------------------------------
/demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/swapagarwal/automata-from-regex/f4a02719c648adfa588df443ee3c0d595cc5ba45/demo.gif


--------------------------------------------------------------------------------
/regex_to_min_dfa.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | 
  3 | using namespace std;
  4 | 
  5 | struct nst
  6 | {
  7 |     vector<int> a[2], e;
  8 |     bool f=0;
  9 | };
 10 | 
 11 | vector<nst> nfa;
 12 | 
 13 | struct dst
 14 | {
 15 |     int a[2] = {-1,-1};
 16 |     bool f=0;
 17 | };
 18 | 
 19 | vector<dst> dfa;
 20 | 
 21 | stack<int> st;
 22 | 
 23 | int nfa_size, dfa_size;
 24 | string dispregex;
 25 | 
 26 | struct nst init_nfa_state;
 27 | 
 28 | struct dst init_dfa_state;
 29 | 
 30 | void custom_clear() {
 31 |     for(int i=0; i<100; i++) cout<<endl;
 32 | }
 33 | 
 34 | /***************************** regex to nfa ****************************/
 35 | 
 36 | string insert_concat(string regexp){
 37 |     string ret="";
 38 |     char c,c2;
 39 |     for(unsigned int i=0; i<regexp.size(); i++){
 40 |         c=regexp[i];
 41 |         if(i+1<regexp.size()){
 42 |             c2=regexp[i+1];
 43 |             ret+=c;
 44 |             if(c!='('&&c2!=')'&&c!='+'&&c2!='+'&&c2!='*'){
 45 |                 ret+='.';
 46 |             }
 47 |         }
 48 |     }
 49 |     ret+=regexp[regexp.size()-1];
 50 |     return ret;
 51 | }
 52 | 
 53 | void character(int i)
 54 | {
 55 |     nfa.push_back(init_nfa_state);
 56 |     nfa.push_back(init_nfa_state);
 57 |     nfa[nfa_size].a[i].push_back(nfa_size+1);
 58 |     st.push(nfa_size);
 59 |     nfa_size++;
 60 |     st.push(nfa_size);
 61 |     nfa_size++;
 62 | }
 63 | 
 64 | void union_()
 65 | {
 66 |     nfa.push_back(init_nfa_state);
 67 |     nfa.push_back(init_nfa_state);
 68 |     int d = st.top(); st.pop();
 69 |     int c = st.top(); st.pop();
 70 |     int b = st.top(); st.pop();
 71 |     int a = st.top(); st.pop();
 72 |     nfa[nfa_size].e.push_back(a);
 73 |     nfa[nfa_size].e.push_back(c);
 74 |     nfa[b].e.push_back(nfa_size+1);
 75 |     nfa[d].e.push_back(nfa_size+1);
 76 |     st.push(nfa_size);
 77 |     nfa_size++;
 78 |     st.push(nfa_size);
 79 |     nfa_size++;
 80 | }
 81 | 
 82 | void concatenation()
 83 | {
 84 |     int d = st.top(); st.pop();
 85 |     int c = st.top(); st.pop();
 86 |     int b = st.top(); st.pop();
 87 |     int a = st.top(); st.pop();
 88 |     nfa[b].e.push_back(c);
 89 |     st.push(a);
 90 |     st.push(d);
 91 | }
 92 | 
 93 | void kleene_star()
 94 | {
 95 |     nfa.push_back(init_nfa_state);
 96 |     nfa.push_back(init_nfa_state);
 97 |     int b = st.top();
 98 |     st.pop();
 99 |     int a = st.top();
100 |     st.pop();
101 |     nfa[nfa_size].e.push_back(a);
102 |     nfa[nfa_size].e.push_back(nfa_size+1);
103 |     nfa[b].e.push_back(a);
104 |     nfa[b].e.push_back(nfa_size+1);
105 |     st.push(nfa_size);
106 |     nfa_size++;
107 |     st.push(nfa_size);
108 |     nfa_size++;
109 | }
110 | 
111 | void postfix_to_nfa(string postfix)
112 | {
113 |     for(unsigned int i=0; i<postfix.size(); i++)
114 |     {
115 |         switch(postfix[i])
116 |         {
117 |         case 'a':
118 |         case 'b': character(postfix[i]-'a'); break;
119 |         case '*': kleene_star(); break;
120 |         case '.': concatenation(); break;
121 |         case '+': union_();
122 |         }
123 |     }
124 | }
125 | 
126 | void display_nfa()
127 | {
128 |     cout<<endl<<endl;
129 |     cout<<"Phase 1: regex to nfa conversion using thompson's construction algorithm\n";
130 |     cout<<"------------------------------------------------------------------------\n";
131 |     cout<<"State\t|\ta\t|\tb\t|\teps\t|accepting state|"<<endl;
132 |     cout<<"------------------------------------------------------------------------\n";
133 |     for(unsigned int i=0; i<nfa.size(); i++)
134 |     {
135 |         cout<<i<<"\t|\t";
136 |         for(unsigned int j=0; j<nfa[i].a[0].size(); j++)cout<<nfa[i].a[0][j]<<' ';
137 |         cout<<"\t|\t";
138 |         for(unsigned int j=0; j<nfa[i].a[1].size(); j++)cout<<nfa[i].a[1][j]<<' ';
139 |         cout<<"\t|\t";
140 |         for(unsigned int j=0; j<nfa[i].e.size(); j++)cout<<nfa[i].e[j]<<' ';
141 |         cout<<"\t|\t";
142 |         if(nfa[i].f)cout<<"Yes"; else cout<<"No";
143 |         cout<<"\t|\n";
144 |     }
145 |     cout<<"------------------------------------------------------------------------\n";
146 | }
147 | 
148 | int priority(char c){
149 |     switch(c){
150 |         case '*': return 3;
151 |         case '.': return 2;
152 |         case '+': return 1;
153 |         default: return 0;
154 |     }
155 | }
156 | 
157 | string regexp_to_postfix(string regexp)
158 | {
159 |     string postfix="";
160 |     stack<char> op;
161 |     char c;
162 |     for(unsigned int i=0; i<regexp.size(); i++)
163 |     {
164 |         switch(regexp[i])
165 |         {
166 |             case 'a':
167 |             case 'b':
168 |                 postfix+=regexp[i]; break;
169 |             case '(':
170 |                 op.push(regexp[i]); break;
171 |             case ')':
172 |                 while(op.top()!='('){
173 |                     postfix+=op.top();
174 |                     op.pop();
175 |                 }
176 |                 op.pop();
177 |                 break;
178 |             default:
179 |                 while(!op.empty()){
180 |                     c=op.top();
181 |                     if(priority(c)>=priority(regexp[i])){
182 |                         postfix+=op.top();
183 |                         op.pop();
184 |                     }
185 |                     else break;
186 |                 }
187 |                 op.push(regexp[i]);
188 |         }
189 |         //cout<<regexp[i]<<' '<<postfix<<endl;
190 |     }
191 |     while(!op.empty())
192 |     {
193 |         postfix += op.top();
194 |         op.pop();
195 |     }
196 |     return postfix;
197 | }
198 | 
199 | /***************************** nfa to dfa ****************************/
200 | 
201 | void print_dfa(){
202 |     cout<<endl;
203 |     cout<<"NFA TO DFA CONVERSION"<<endl;
204 |     cout<<"---------------------------------------------------------"<<endl;
205 |     cout<<"STATE\t|\t"<<"a"<<"\t|\t"<<"b"<<"\t|\t"<<"FINAL"<<"\t|"<<endl;
206 |     cout<<"---------------------------------------------------------"<<endl;
207 |     for(int i=0;i<dfa.size();i++){
208 |         cout<<i<<"\t|\t"<<dfa[i].a[0]<<"\t|\t"<<dfa[i].a[1]<<"\t|\t"<<dfa[i].f<<"\t|"<<endl;
209 |     }
210 |     cout<<"---------------------------------------------------------"<<endl;
211 | }
212 | 
213 | void epsilon_closure(int state,set<int>&si){
214 |     for(unsigned int i=0;i<nfa[state].e.size();i++){
215 |         if(si.count(nfa[state].e[i])==0){
216 |             si.insert(nfa[state].e[i]);
217 |             epsilon_closure(nfa[state].e[i],si);
218 |         }
219 |     }
220 | }
221 | 
222 | set<int> state_change(int c,set<int>&si){
223 |     set<int> temp;
224 |     if(c==1){
225 |         for (std::set<int>::iterator it=si.begin(); it!=si.end(); ++it){
226 |             for(unsigned int j=0;j<nfa[*it].a[0].size();j++){
227 |                 temp.insert(nfa[*it].a[0][j]);
228 |             }
229 |         }
230 |     }
231 |     else{
232 |         for (std::set<int>::iterator it=si.begin(); it!=si.end(); ++it){
233 |             for(unsigned int j=0;j<nfa[*it].a[1].size();j++){
234 |                 temp.insert(nfa[*it].a[1][j]);
235 |             }
236 |         }
237 |     }
238 |     return temp;
239 | }
240 | 
241 | void nfa_to_dfa(set<int>&si,queue<set<int> >&que,int start_state){
242 |     map<set<int>, int> mp;
243 |     mp[si]=-1;
244 |     set<int> temp1;
245 |     set<int> temp2;
246 |     int ct=0;
247 |     si.clear();
248 |     si.insert(0);
249 |     epsilon_closure(start_state,si);
250 |     if(mp.count(si)==0){
251 |         mp[si]=ct++;
252 |         que.push(si);
253 |     }
254 |     int p=0;
255 |     bool f1=false;
256 |     while(que.size()!=0){
257 |         dfa.push_back(init_dfa_state);
258 |         si.empty();
259 |         si=que.front();
260 |         f1=false;
261 |         for (set<int>::iterator it=si.begin(); it!=si.end(); ++it){
262 |             if(nfa[*it].f==true)
263 |                 f1=true;
264 |         }
265 |         dfa[p].f=f1;
266 |         temp1=state_change(1,si);
267 |         si=temp1;
268 |         for (set<int>::iterator it=si.begin(); it!=si.end(); ++it){
269 |             epsilon_closure(*it,si);
270 |         }
271 |         if(mp.count(si)==0){
272 |             mp[si]=ct++;
273 |             que.push(si);
274 |             dfa[p].a[0]=ct-1;
275 |         }
276 |         else{
277 |             dfa[p].a[0]=mp.find(si)->second;
278 |         }
279 |         temp1.clear();
280 | 
281 |         si=que.front();
282 |         temp2=state_change(2,si);
283 |         si=temp2;
284 |         for (set<int>::iterator it=si.begin(); it!=si.end(); ++it){
285 |             epsilon_closure(*it,si);
286 |         }
287 |         if(mp.count(si)==0){
288 |             mp[si]=ct++;
289 |             que.push(si);
290 |             dfa[p].a[1]=ct-1;
291 |         }
292 |         else{
293 |             dfa[p].a[1]=mp.find(si)->second;
294 |         }
295 |         temp2.clear();
296 |         que.pop();
297 |         p++;
298 |     }
299 |     for(int i=0;i<p;i++){
300 |         if(dfa[i].a[0]==-1)dfa[i].a[0]=p;
301 |         if(dfa[i].a[1]==-1)dfa[i].a[1]=p;
302 |     }
303 |     dfa.push_back(init_dfa_state);
304 |     dfa[p].a[0]=p;
305 |     dfa[p].a[1]=p;
306 |     //cout<<p<<endl;
307 | }
308 | 
309 | /***************************** min dfa ****************************/
310 | 
311 | /// Function to minimize DFA
312 | pair<int,vector<tuple<int,int,bool> > > minimize_dfa(vector<dst> dfa) {
313 |     //cout<<dfa.size()<<endl;
314 |     vector<int> grp(dfa.size());    /// Group number for states
315 |     vector<vector<int> > part(2, vector<int>());   /// Partition for groups
316 | 
317 |     /// Initializing the groups
318 |     part[0].push_back(0);
319 |     for(int i=1; i<(int)grp.size(); i++) {
320 |         if(dfa[i].f==dfa[0].f) {
321 |             grp[i]=0;
322 |             part[0].push_back(i);
323 |         } else {
324 |             grp[i]=1;
325 |             part[1].push_back(i);
326 |         }
327 |     }
328 | 
329 |     if(!part[1].size()) part.erase(part.end());
330 | 
331 |     /// Loop until no new partition is created
332 |     bool chk=true;  /// Check if any new partition is created
333 |     int strt = 0;   /// Starting State
334 |     while(chk) {
335 |         chk=false;
336 | 
337 |         /*for(int i=0; i<part.size(); i++) {
338 |             cout<<i<<":";
339 |             for(int j=0; j<part[i].size(); j++) {
340 |                 cout<<part[i][j]<<" ";
341 |             } cout<<endl;
342 |         } cout<<endl;*/
343 |         /// Iterate over partitions and alphabets
344 |         for(int i=0; i<part.size(); i++) {
345 |             for(int j=0; j<2; j++) {
346 |                 vector<pair<int,int> > trans(part[i].size());   /// Transitions for the states of partitions
347 |                 /// Iterate over states of partitions and find transition groups
348 |                 for(int k=0; k<part[i].size(); k++) {
349 |                     if(dfa[part[i][k]].a[j] >= 0)
350 |                         trans[k] = make_pair(grp[dfa[part[i][k]].a[j]],part[i][k]);
351 |                     else
352 |                         trans[k] = make_pair(-1,part[i][k]);
353 |                 }
354 |                 sort(trans.begin(), trans.end());
355 | 
356 |                 /// Break partition in case of different transitions
357 |                 if(trans[0].first!=trans[trans.size()-1].first) {
358 |                     chk=true;
359 | 
360 |                     int k, m = part.size()-1;
361 | 
362 |                     part[i].clear();
363 |                     part[i].push_back(trans[0].second);
364 |                     for(k=1; k<trans.size() and (trans[k].first==trans[k-1].first); k++) {
365 |                         part[i].push_back(trans[k].second);
366 |                     }
367 | 
368 |                     while(k<trans.size()) {
369 |                         if(trans[k].first!=trans[k-1].first) {
370 |                             part.push_back(vector<int> ());
371 |                             m++;
372 |                         }
373 |                         grp[trans[k].second] = m;
374 |                         part[m].push_back(trans[k].second);
375 |                         k++;
376 |                     }
377 |                 }
378 |             }
379 |         }
380 |     }
381 | 
382 |     for(int i=0; i<part.size(); i++) {
383 |         for(int j=0; j<part[i].size(); j++) {
384 |             if(part[i][j]==0) strt=i;
385 |         }
386 |     }
387 | 
388 |     vector<tuple<int,int,bool> > ret(part.size());
389 |     //cout<<part.size()<<endl;
390 |     //sort(part.begin(), part.end());
391 |     for(int i=0; i<(int)part.size(); i++) {
392 |         //cout<<grp[part[i][0]]<<endl;
393 |         get<0>(ret[i]) = (dfa[part[i][0]].a[0]>=0)?grp[dfa[part[i][0]].a[0]]:-1;
394 |         get<1>(ret[i]) = (dfa[part[i][0]].a[1]>=0)?grp[dfa[part[i][0]].a[1]]:-1;
395 |         get<2>(ret[i]) = dfa[part[i][0]].f;
396 |     }
397 | 
398 |     return make_pair(strt, ret);
399 | }
400 | 
401 | void print_menu(){
402 |     cout<<"\n---------------------------------------\n";
403 |     cout<<"Input Regex: "<<dispregex<<endl<<endl;
404 |     cout<<"1. NFA\n";
405 |     cout<<"2. Intermediate DFA\n";
406 |     cout<<"3. Minimized DFA\n";
407 |     cout<<"4. Simulation\n";
408 |     cout<<"Press any other key to exit...\n\n";
409 | }
410 | 
411 | void print(vector<tuple<int,int,bool> > min_dfa) {
412 |     cout<<"---------------------------------------------------------"<<endl;
413 |     cout<<"State\t|\tA\t|\tB\t|\tFinal\t|"<<endl;
414 |     cout<<"---------------------------------------------------------"<<endl;
415 |     for(int i=0; i<(int)min_dfa.size(); i++) {
416 |         cout<<i<<"\t|\t";
417 |         cout<<get<0>(min_dfa[i])<<"\t|\t";
418 |         cout<<get<1>(min_dfa[i])<<"\t|\t";
419 |         if(get<2>(min_dfa[i])) cout<<"Yes\t|"; else cout<<"No\t|";
420 |         cout<<endl;
421 |     }
422 |     cout<<"---------------------------------------------------------"<<endl;
423 | }
424 | 
425 | void simulate(int start_st,vector<tuple<int,int,bool> >min_dfa){
426 |     print_menu();
427 |     cout<<"Enter string : ";
428 |     string input;
429 |     cin.ignore();
430 |     getline(cin,input);
431 |     int curr_state,next_state;
432 |     curr_state=start_st;
433 |     custom_clear();
434 |     cout<<"-----------------------------------------"<<endl;
435 |     cout<<"Input\t|\tCurrent\t|\tNext\t|"<<endl;
436 |     cout<<"-----------------------------------------"<<endl;
437 |     for(unsigned i=0;i<input.size();i++){
438 |         if(input[i]=='a')
439 |             next_state=get<0>(min_dfa[curr_state]);
440 |         else
441 |             next_state=get<1>(min_dfa[curr_state]);
442 |         cout<<input[i]<<"\t|\t"<<curr_state<<"\t|\t"<<next_state<<"\t|\n";
443 |         curr_state=next_state;
444 |     }
445 |     cout<<"-----------------------------------------"<<endl;
446 |     cout<<endl<<"Verdict: ";
447 |     if(curr_state>=0&&get<2>(min_dfa[curr_state]))cout<<"Accepted"; else cout<<"Rejected";
448 | 
449 |     cout<<endl;
450 | }
451 | 
452 | 
453 | int main()
454 | {
455 |     custom_clear();
456 |     string regexp,postfix;
457 |     cout<<"Enter Regular Expression: ";
458 |     cin>>regexp;
459 |     dispregex=regexp;
460 |     regexp=insert_concat(regexp);
461 |     postfix = regexp_to_postfix(regexp);
462 |     cout<<"Postfix Expression: "<<postfix<<endl;
463 |     postfix_to_nfa(postfix);
464 | 
465 |     int final_state=st.top();st.pop();
466 |     int start_state=st.top();st.pop();
467 |     //cout<<start_state<<' '<<final_state<<endl;
468 |     nfa[final_state].f=1;
469 | 
470 |     set<int> si;
471 |     queue<set<int> > que;
472 |     nfa_to_dfa(si,que,start_state);
473 | 
474 |     cout<<endl<<endl;
475 | 
476 |     pair<int,vector<tuple<int,int,bool> > > min_dfa_tmp = minimize_dfa(dfa);
477 | 
478 |     vector<tuple<int,int,bool> >  min_dfa= min_dfa_tmp.second;
479 |     int start_st = min_dfa_tmp.first;
480 | 
481 |     getchar();
482 |     custom_clear();
483 | 
484 | 
485 |     while(1){
486 |         print_menu();
487 |         char choice;
488 |         choice=getchar();
489 |         custom_clear();
490 | 
491 |         switch(choice) {
492 |         case '1':
493 |             display_nfa();
494 |             getchar();
495 |             break;
496 |         case '2':
497 |             print_dfa();
498 |             getchar();
499 |             break;
500 |         case '3':
501 |             print(min_dfa);
502 |             getchar();
503 |             break;
504 |         case '4':
505 |             simulate(start_st,min_dfa);
506 |             break;
507 |         default:
508 |             exit(EXIT_SUCCESS);
509 |         }
510 |     }
511 |     cout<<endl<<endl;
512 |     cout<<"Enter string : ";
513 |     string input;
514 |     cin.ignore();
515 |     getline(cin,input);
516 |     int curr_state,next_state;
517 |     while(input!=""){
518 |         //cout<<input<<endl;
519 |         curr_state=start_st;
520 |         for(unsigned i=0;i<input.size();i++){
521 |             if(curr_state>=0){
522 |                 if(input[i]=='a')
523 |                     next_state=get<0>(min_dfa[curr_state]);
524 |                 else
525 |                     next_state=get<1>(min_dfa[curr_state]);
526 |                 if(next_state>=0){
527 |                     cout<<input[i]<<" : State "<<curr_state<<" -> State "<<next_state<<endl;
528 |                 }
529 |                 else cout<<input[i]<<" : State "<<curr_state<<" -> Trap State"<<endl;
530 |             }
531 |             else cout<<input[i]<<" : Trapped"<<endl;
532 |             curr_state=next_state;
533 |         }
534 |         if(curr_state>=0&&get<2>(min_dfa[curr_state]))cout<<"accepted"; else cout<<"rejected";
535 |         cout<<endl<<endl;
536 |         cout<<"Enter string : ";
537 |         getline(cin,input);
538 |     }
539 |     return 0;
540 | }
541 | 


--------------------------------------------------------------------------------