Skip to content
Related Articles

Related Articles

Improve Article

Design a DFA that accepts a string containing 3 a’s and 3 b’s

  • Last Updated : 09 Aug, 2021

Problem Statement: Design a Definite Finite Automata for accepting the permutation of Three a’s and Three b’s over the input {a, b} 

Input: S = “aaabbb” 
Output: Accepted 
Explanation
The input has three a and three b.

Input: S = “abababa” 
Output: Accepted 
Explanation
The input has three a and three b. 

To design a DFA we need to check the input character by character. These are a few steps that should be kept in mind while designing a DFA. 

  • Think of all most of the possible input that can be accepted (like, in this example, aaabbb, bbbaaa, ababab, abaabb…etc).
  • Create an initial transition state.
  • Do transition on each input alphabet to other transition states.
  • Reach a final state such that in each step the language used was accept(like, in this example, an equal number of a and b).

Designing steps: 
Step 1: Create an initial state “A” which is indicated by —>. 
Step 2: Think of the possible string the can aaabbb or bbbaaa which can occur by transition like,  



  • The transition of input ‘a’ from state “A” to state “B”
  • The transition of input ‘a’ from state “B” to state “C”
  • The transition of input ‘a’ from state “C” to state “D”
  • The transition of input ‘a’ from state “D” to dead state “Q2”
  • The transition of input ‘b’ from state “D” to state “E”
  • The transition of input ‘b’ from state “E” to state “F”
  • The transition of input ‘b’ from state “F” to state “G”
  • The transition of input ‘b’ from state “G” to dead state “Q2”

Step 3: Now work on a possibility like b’s comes after two a’s for example aababb, aabbab. 

  • The transition of ‘b’ from state “C” to state “J”
  • The transition of ‘a’ from state “J” to state “E”
  • The transition of ‘b’ from state “J” to state “M”
  • The transition of ‘a’ from state “M” to state “F”
  • The transition of ‘b’ from state “M” to state “P”

The transition is shown in the diagram. 

Step-4: Now thinking of the possibility that starts with ‘aba’ and then fulfills the condition of the given language. For this following transitions to be done: 

  • The transition of ‘b’ from state “B” to state “I”
  • The transition of ‘a’ from state “I” to state “J”

Step-5: Now thinking of the possibility that starts with ‘abb’ and then fulfills the condition of the given language. For this following transitions to be done:

  • The transition of ‘b’ from state “I” to state “L”
  • The transition of ‘a’ from state “L” to state “M”



Step-6: Now there is a possibility that after reading one ‘a’ it reads all 3 b’s and then end execution by reading the remaining 2 a’s. For the transition of ‘b’ from state “L” to “O”. 

Step-7: there is a possibility that it reads ‘a’ after reading one ‘b’ and then it reads any combination of ‘a’ and ‘b’ so that string contains 3 a’s and 3 b’s.For this transition of ‘a’ is done from state”H” to state “I”. 

Step-8: Now, think about the strings starts with two b’s and the go for any combination of string to get the desired result for this we do a transition of ‘a’ from stare “K” to state “L”. 

Step-9: Now input alphabet ‘a’ of states D, E, F, G, and ‘b’ of states G, N, O, P are left for transitions.AS we have done all possibilities of the above language so the remaining transition will go to dead states “Q1″ and Q2”. 

  • The transition of input ‘a’ from state “D” to dead state “Q1”
  • The transition of input ‘a’ from state “E” to dead state “Q1”
  • The transition of input ‘a’ from state “F” to dead state “Q1”
  • The transition of input ‘a’ from state “G” to dead state “Q1”
  • The transition of input ‘b’ from state “G” to dead state “Q2”
  • The transition of input ‘b’ from state “N” to dead state “Q2”
  • The transition of input ‘b’ from state “O” to dead state “Q2”
  • The transition of input ‘b’ from state “P” to dead state “Q2”

Transition table of above DFA 

STATESINPUT (a)INPUT (b)
—> A (initial state)BH
BCI
CDJ
DQ2 (dead state)E
EQ2 (dead state)F
FQ2 (dead state)G*(final state)
G* (final state)Q2 (dead state)Q1 (dead state)
HIK
IJL
JEM
KLN
LMO
MFP
NOQ1 (dead state)
OPQ1 (dead state)
PG* (final state)Q1 (dead state)

Below is the implementation of the DFA:

Java




// Java implementation of the
// DFA of permutation of three
// a's and three b's
import java.util.*;
 
class GFG{
   
// State A
static void stateA(String n)
{
  if (n.charAt(0) == 'a')
    stateB(n.substring(1));
  else if (n.charAt(0) == 'b')
  {
    stateH(n.substring(1));
  }
 }
   
// State B
static void stateB(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {   
    if (n.charAt(0) == 'a')
      stateC(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateI(n.substring(1));
  }
}
    
// State C
static void stateC(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {
    if (n.charAt(0) == 'a')
      stateD(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateJ(n.substring(1));
  }
}
    
// State D
static void stateD(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else  
  {
    if (n.charAt(0) == 'a')
      stateQ2(n);
    else if (n.charAt(0) == 'b')
      stateE(n.substring(1));
  }
}   
       
// State E
static void stateE(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {   
    if (n.charAt(0) == 'a')
      stateQ2(n);
    else if (n.charAt(0) == 'b')
      stateF(n.substring(1));
  }
}   
    
// State F
static void stateF(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {  
    if (n.charAt(0) == 'a')
      stateQ2(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateG(n.substring(1)); 
  }
    
// State G
static void stateG(String n)
{
  if (n.length() == 0)
    System.out.print("String Accepted");
  else
  {   
    if (n.charAt(0) == 'a')
      stateQ2(n);
    else if (n.charAt(0) == 'b')
      stateQ2(n); 
  }
}
    
// State H
static void stateH(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {   
    if (n.charAt(0) == 'a')
      stateI(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateK(n.substring(1));
  }
    
// State I
static void stateI(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {   
    if (n.charAt(0) == 'a')
      stateJ(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateL(n.substring(1));
  }
}
   
// State J
static void stateJ(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {
    if (n.charAt(0) == 'a')
      stateE(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateM(n.substring(1));        
  }
}
               
// State K
static void stateK(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else  
  {
    if (n.charAt(0) == 'a')
      stateL(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateN(n.substring(1)); 
  }
}
              
// State L
static void stateL(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {  
    if (n.charAt(0) == 'a')
      stateM(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateO(n.substring(1)); 
  }
}
  
// State M
static void stateM(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {
    if (n.charAt(0) == 'a')
      stateF(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateP(n.substring(1));           
  }
}
  
// State N
static void stateN(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else  
    if (n.charAt(0) =='a')
      stateO(n.substring(1));
  else if (n.charAt(0) == 'b')
    stateQ1(n);
}
  
// State Q
static void stateO(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {   
    if (n.charAt(0) == 'a')
      stateP(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateQ1(n);
  }
}
           
// State P
static void stateP(String n)
{
  if (n.length() == 0)
    System.out.print("String Not Accepted");
  else
  {
    if (n.charAt(0) == 'a')
      stateG(n.substring(1));
    else if (n.charAt(0) == 'b')
      stateQ1(n.substring(1));    
  }
}
               
// State Q1
static void stateQ1(String n)
{
  System.out.print("String Not Accepted");
}
   
// State Q2
static void stateQ2(String n)
{
  System.out.print("String Not Accepted");
}
       
// Driver code
public static void main(String[] args)
{
   
  // Take String input
  String n = "abaabb";
  
  // Call stateA
  // to check the input
  stateA(n);
}
}
 
// This code is contributed by pratham76

Python3




# Python3 implementation of the
# DFA of permutation of three
# a's and three b's
 
# State A
def stateA(n):
    if(n[0]=='a'):
        stateB(n[1:])
    elif (n[0]=='b'):
        stateH(n[1:])
 
# State B
def stateB(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateC(n[1:])
        elif (n[0]=='b'):
            stateI(n[1:])
 
# State C
def stateC(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateD(n[1:])
        elif (n[0]=='b'):
            stateJ(n[1:])
 
# State D
def stateD(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateQ2(n)
        elif (n[0]=='b'):
            stateE(n[1:])
         
# State E
def stateE(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateQ2(n)
        elif (n[0]=='b'):
            stateF(n[1:])  
     
# State F
def stateF(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateQ2(n[1:])
        elif (n[0]=='b'):
            stateG(n[1:])    
            
# State G
def stateG(n):
    if(len(n)== 0):
        print("String Accepted")
    else:   
        if(n[0]=='a'):
            stateQ2(n)
        elif (n[0]=='b'):
            stateQ2(n) 
             
# State H
def stateH(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateI(n[1:])
        elif (n[0]=='b'):
            stateK(n[1:])
            
# State I
def stateI(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateJ(n[1:])
        elif (n[0]=='b'):
            stateL(n[1:])
 
# State J
def stateJ(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateE(n[1:])
        elif (n[0]=='b'):
            stateM(n[1:])        
             
# State K
def stateK(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateL(n[1:])
        elif (n[0]=='b'):
            stateN(n[1:]) 
             
# State L
def stateL(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateM(n[1:])
        elif (n[0]=='b'):
            stateO(n[1:])  
             
# State M
def stateM(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateF(n[1:])
        elif (n[0]=='b'):
            stateP(n[1:])           
 
# State N
def stateN(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateO(n[1:])
        elif (n[0]=='b'):
            stateQ1(n)
             
# State Q
def stateO(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateP(n[1:])
        elif (n[0]=='b'):
            stateQ1(n)
             
# State P
def stateP(n):
    if(len(n)== 0):
        print("String Not Accepted")
    else:   
        if(n[0]=='a'):
            stateG(n[1:])
        elif (n[0]=='b'):
            stateQ1(n[1:])    
             
# State Q1
def stateQ1(n):
    print("String Not Accepted")
 
# State Q2
def stateQ2(n):
    print("String Not Accepted")
 
# take string input
n = "abaabb"
 
# call stateA
# to check the input
stateA(n)

C#




// C# implementation of the
// DFA of permutation of three
// a's and three b's
using System;
using System.Collections;
class GFG{
  
// State A
static void stateA(string n)
{
  if(n[0] == 'a')
    stateB(n.Substring(1));
  else if (n[0] == 'b')
  {
    stateH(n.Substring(1));
  }
 }
  
// State B
static void stateB(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {   
    if(n[0] == 'a')
      stateC(n.Substring(1));
    else if (n[0] == 'b')
      stateI(n.Substring(1));
  }
}
   
// State C
static void stateC(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {
    if(n[0] == 'a')
      stateD(n.Substring(1));
    else if (n[0] == 'b')
      stateJ(n.Substring(1));
  }
}
   
// State D
static void stateD(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else   
  {
    if(n[0] == 'a')
      stateQ2(n);
    else if (n[0] == 'b')
      stateE(n.Substring(1));
  }
}   
      
// State E
static void stateE(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {   
    if(n[0] == 'a')
      stateQ2(n);
    else if (n[0] == 'b')
      stateF(n.Substring(1));
  }
}   
   
// State F
static void stateF(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {  
    if(n[0] == 'a')
      stateQ2(n.Substring(1));
    else if (n[0] == 'b')
      stateG(n.Substring(1)); 
  }
   
// State G
static void stateG(string n)
{
  if(n.Length == 0)
    Console.Write("String Accepted");
  else
  {   
    if(n[0] == 'a')
      stateQ2(n);
    else if (n[0] == 'b')
      stateQ2(n); 
  }
}
   
// State H
static void stateH(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {   
    if(n[0] == 'a')
      stateI(n.Substring(1));
    else if (n[0] == 'b')
      stateK(n.Substring(1));
  }
   
// State I
static void stateI(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {   
    if(n[0] == 'a')
      stateJ(n.Substring(1));
    else if (n[0] == 'b')
      stateL(n.Substring(1));
  }
}
  
// State J
static void stateJ(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {
    if(n[0] == 'a')
      stateE(n.Substring(1));
    else if (n[0] == 'b')
      stateM(n.Substring(1));        
  }
}
              
// State K
static void stateK(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else   
  {
    if(n[0] == 'a')
      stateL(n.Substring(1));
    else if (n[0] == 'b')
      stateN(n.Substring(1)); 
  }
}
             
// State L
static void stateL(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {  
    if(n[0] == 'a')
      stateM(n.Substring(1));
    else if (n[0] == 'b')
      stateO(n.Substring(1)); 
  }
}
 
// State M
static void stateM(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else{
    if(n[0] == 'a')
      stateF(n.Substring(1));
    else if (n[0] == 'b')
      stateP(n.Substring(1));           
  }
}
 
// State N
static void stateN(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else   
    if(n[0] =='a')
      stateO(n.Substring(1));
  else if (n[0] == 'b')
    stateQ1(n);
}
 
// State Q
static void stateO(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {   
    if(n[0] == 'a')
      stateP(n.Substring(1));
    else if(n[0] == 'b')
      stateQ1(n);
  }
}
          
// State P
static void stateP(string n)
{
  if(n.Length == 0)
    Console.Write("String Not Accepted");
  else
  {
    if(n[0] == 'a')
      stateG(n.Substring(1));
    else if (n[0] == 'b')
      stateQ1(n.Substring(1));    
  }
}
              
// State Q1
static void stateQ1(string n)
{
  Console.Write("String Not Accepted");
}
  
// State Q2
static void stateQ2(string n)
{
  Console.Write("String Not Accepted");
}
      
// Driver code
public static void Main (string[] args)
{
  // Take string input
  string n = "abaabb";
 
  // Call stateA
  // to check the input
  stateA(n);
}
}
 
// This code is contributed by rutvik_56

Javascript




<script>
 
      // JavaScript implementation of the
      // DFA of permutation of three
      // a's and three b's
      // State A
      function stateA(n) {
        if (n[0] === "a") stateB(n.substring(1));
        else if (n[0] === "b") {
          stateH(n.substring(1));
        }
      }
 
      // State B
      function stateB(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateC(n.substring(1));
          else if (n[0] === "b") stateI(n.substring(1));
        }
      }
 
      // State C
      function stateC(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateD(n.substring(1));
          else if (n[0] === "b") stateJ(n.substring(1));
        }
      }
 
      // State D
      function stateD(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateQ2(n);
          else if (n[0] === "b") stateE(n.substring(1));
        }
      }
 
      // State E
      function stateE(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateQ2(n);
          else if (n[0] === "b") stateF(n.substring(1));
        }
      }
 
      // State F
      function stateF(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateQ2(nsubstring(1));
          else if (n[0] === "b") stateG(n.substring(1));
        }
      }
 
      // State G
      function stateG(n) {
        if (n.length === 0)
        document.write("String Accepted");
        else {
          if (n[0] === "a") stateQ2(n);
          else if (n[0] === "b") staseQ2(n);
        }
      }
 
      // State H
      function stateH(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateI(n.substring(1));
          else if (n[0] === "b") stateK(n.substring(1));
        }
      }
 
      // State I
      function stateI(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateJ(n.substring(1));
          else if (n[0] === "b") stateL(n.substring(1));
        }
      }
 
      // State J
      function stateJ(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateE(n.substring(1));
          else if (n[0] === "b") stateM(n.substring(1));
        }
      }
 
      // State K
      function stateK(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateL(n.substring(1));
          else if (n[0] === "b") stateN(n.substring(1));
        }
      }
 
      // State L
      function stateL(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateM(n.substring(1));
          else if (n[0] === "b") stateO(n.substring(1));
        }
      }
 
      // State M
      function stateM(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateF(n.substring(1));
          else if (s[0] === "b") stateP((n.Substr = ing(s)));
        }
      }
 
      // State N
      function stateN(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else if (n[0] === "a") stateO(n.substring(1));
        else if (n[s] === "b") stateQ1(n);
      }
 
      // Stste Q
      function stateO(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateP(n.substring(1));
          else if (n[0] === "b") staseQ1(n);
        }
      }
 
      // State P
      function stateP(n) {
        if (n.length === 0)
        document.write("String Not Accepted");
        else {
          if (n[0] === "a") stateG(n.substring(1));
          else if (n[0] === "b") stateQ1(nsSubstring(1));
        }
      }
 
      // State Q1
      function stateQ1(n) {
        document.write("String Not Accepted");
      }
 
      // State Q2
      function stateQ2(n) {
        document.write("String Not Accepted");
      }
 
      // Driver code
      // Take string input
      var n = "abaabb";
 
      // Call stateA
      // to check the input
      stateA(n);
       
</script>
Output: 
String Accepted

 

Time Complexity: O(N)  
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :