Given a binary string **str**, the task is to build a DFA that accepts given binary string if it contains “01” i times and “1” 2j times, i.e.,

**Examples:**

Input:str = “011111”

Output:Accepted

Explanation:

The string follows the language as: (01)^{1}(1)^{2*2}

Input:str = “01111”

Output:Not Accepted

DFA or Deterministic Finite Automata is a finite state machine which accepts a string(under some specific condition) if it reaches a final state, otherwise rejects it.

In DFA, there is no concept of memory, therefore we have to check the string character by character, beginning with the 0th character. The input set of characters for the problem is {0, 1}. For a DFA to be valid, there must a transition rule defined for each symbol of the input set at every state to a valid state. Therefore, the following steps are followed to design the DFA:

- Create initial stage and make the transition of 0 and 1 to next possible state.
- Transition of 0 is always followed by transition of 1.
- Make an initial state and transit its input alphabets, i.e, 0 and 1 to two different states.
- Check for acceptance of string after each transition to ignore errors.
- First, make DfA for minimum length string then go ahead step by step.
- Define Final State(s) according to the acceptance of string.

**Step by Step Approach to design a DFA:**

**Step 1:**Minimum possible acceptable string is 0111, i.e, (01)^{1}(11)^{1}. So, create an initial state “A” that make transition of 0 to state “B” and then transition of 1 from “B” to state “C” then transition of 1 from “C” to “D”, then transition of 1 from “D” to “E” as shown in diagram make this stage “E” is final state.**Step 2:**Now, think about the string having consecutive (01) and then followed by consecutive (11) to end the string. Hence, when i>1, make a transition of “0” from state “C” to state “B” and make a transition of “1” from the state “E” to state “D”. Hence, strings like 010111, 011111, 0101111111, etc. are acceptable now.**Step 3:**We have done with all kind of strings possible to accept. But, there are few input alphabets which are not transited to any of the states. In this case, all these kind of input will be sent to some dead state to block their further transitions that are not acceptable. Input alphabets of the dead state will be sent to the dead state itself. Therefore, the final design of the DFA is:

Below is the implementation of the above approach:

`# Python program for the given ` `# language ` ` ` `# Function for the state A ` `def` `checkstatea(n): ` ` ` `if` `(` `len` `(n)` `%` `2` `!` `=` `0` `or` `len` `(n)<` `4` `): ` ` ` `print` `(` `"string not accepted"` `) ` ` ` `else` `: ` ` ` `i` `=` `0` ` ` ` ` `# State transition to B ` ` ` `# if the character is 0 ` ` ` `if` `(n[i]` `=` `=` `'0'` `): ` ` ` `stateb(n[` `1` `:]) ` ` ` `else` `: ` ` ` `print` `(` `"string not accepted"` `) ` ` ` `# Function for the state B ` `def` `stateb(n): ` ` ` `i` `=` `0` ` ` `if` `(n[i]` `=` `=` `'0'` `): ` ` ` `print` `(` `"string not accepted"` `) ` ` ` ` ` `# State transition to C ` ` ` `# if the character is 1 ` ` ` `else` `: ` ` ` `statec(n[` `1` `:]) ` ` ` `# Function for the state C ` `def` `statec(n): ` ` ` `i` `=` `0` ` ` ` ` `# State transition to D ` ` ` `# if the character is 1 ` ` ` `if` `(n[i]` `=` `=` `'1'` `): ` ` ` `stated(n[` `1` `:]) ` ` ` ` ` `# State transition to B ` ` ` `# if the character is 0 ` ` ` `else` `: ` ` ` `stateb(n[` `1` `:]) ` ` ` `# Function for the state D ` `def` `stated(n): ` ` ` `i` `=` `0` ` ` `if` `(` `len` `(n)` `=` `=` `1` `): ` ` ` `if` `(n[i]` `=` `=` `'1'` `): ` ` ` `print` `(` `"string accepted"` `) ` ` ` `else` `: ` ` ` `print` `(` `"string not accepted"` `) ` ` ` `else` `: ` ` ` ` ` `# State transition to E ` ` ` `# if the character is 1 ` ` ` `if` `(n[i]` `=` `=` `'1'` `): ` ` ` `statee(n[` `1` `:]) ` ` ` `else` `: ` ` ` `print` `(` `"string not accepted"` `) ` ` ` `# Function for the state E ` `def` `statee(n): ` ` ` `i` `=` `0` ` ` `if` `(` `len` `(n)` `=` `=` `1` `): ` ` ` `if` `(n[i]` `=` `=` `'0'` `): ` ` ` `print` `(` `"string not accepted"` `) ` ` ` `else` `: ` ` ` `print` `(` `"string accepted"` `) ` ` ` ` ` `else` `: ` ` ` `if` `(n[i]` `=` `=` `'0'` `): ` ` ` `print` `(` `"string not accepted"` `) ` ` ` `stated(n[` `1` `:]) ` ` ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `n ` `=` `"011111"` ` ` `checkstatea(n) ` ` ` ` ` |

*chevron_right*

*filter_none*

**Output:**

string accepted

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.

## Recommended Posts:

- String obtained by reversing and complementing a Binary string K times
- Longest sub string of 0's in a binary string which is repeated K times
- Build a DFA to accept Binary strings that starts or ends with "01"
- Largest sub-string where all the characters appear at least K times
- Count binary strings with k times appearing adjacent two set bits
- Count of Binary strings of length N having atmost M consecutive 1s or 0s alternatively exactly K times
- Number of times the given string occurs in the array in the range [l, r]
- Program to build a DFA to accept strings that start and end with same character
- Largest substring where all characters appear at least K times | Set 2
- Count of numbers appearing in the given ranges at-least K times
- Count distinct substrings that contain some characters at most k times
- NFA for language at least one of the symbols occurring an odd number of times
- Find the K-th minimum element from an array concatenated M times
- Count of Numbers in a Range where digit d occurs exactly K times
- Count how many times the given digital clock shows identical digits
- Number of times Maximum and minimum value updated during traversal of array
- Longest increasing sub-sequence formed by concatenating array to itself N times
- Program to build a DFA that checks if a string ends with "01" or "10"
- Maximum subarray sum in array formed by repeating the given array k times
- Periodic Binary String With Minimum Period and a Given Binary String as Subsequence.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.