DFA that contains 1011 as a substring

Question

I have to draw a DFA that accepts set of all strings containing 1011 as a substring in it. I tried but could not come up with one. Can anyone help me please?

Thanks

Answer 1

The idea for a DFA that does this is simple: keep track of how much of that substring we have seen on the end of the input we've seen so far. If you eventually get to a point where the input you've seen so far ends with that substring, then you accept the whole input. If you get to the end of input before ever seeing a prefix that ends with your substring, you don't accept.

We can create the DFA by adding states as necessary to represent differing levels of match against the target substring. All DFAs need at least one state: let's call it q0.

---->q0

The implied alphabet of your language is {0, 1}, so we need transitions for both of these symbols on the state q0. Let's think about how much of the substring we will have seen in state q0. We can get to q0 with the empty string; that is, before consuming any input at all. After seeing the empty string we have seen zero of the four symbols that make up our substring. So, q0 should correspond to the case "the input I've seen up until now ends with a string that matches 0/4 of the target substring".

Given this, what transitions should we add for 0 and 1? If we see a 0 in state q0, that doesn't help at all, since the substring we're looking for begins with 1; so, seeing a 0 in q0 doesn't change the fact that the input we've seen so far matches 0/4 symbols. This means we can have the transition from q0 on 0 return to q0.

     /-\
   0 |  |
     V /
---->q0

What about if we see a 1 in q0? Well, if we see a 1, then the input we've seen so far ends with a string that matches 1011 in exactly 1/4 places (the first 1); so, we need another state to represent the fact we're a little closer to the goal. Let's call this state q1.

     /-\
   0 |  |
     V /
---->q0---->q1
         1

We repeat the process now for state q1. If we see a 0 in q1, we get a little closer to our target of 1011, so we can go to a new state, q2. If we see a 1 in q1, we don't get any closer to our goal, but we also don't fall back.

      0      1
     /-\    /-\
     |  |   |  |
     V /    V /
---->q0---->q1---->q2
         1      0

If we see a 0 in q2, that means we've seen the substring 00; that doesn't appear in 1011 at all, which means we are totally back to square one and must return to q0. If we see a 1 though, we get a little closer to our goal and must move to a new state; let's call this q3:

      0      1
     /-\    /-\
     |  |   |  |
     V /    V /
---->q0---->q1---->q2---->q3
     ^   1      0  |   1
     |             |
     \-------------/
            0

If we see a 0 in q3 then our input has ended with the substring 10, which puts us back at q2; if we see a 1, then we have seen the whole target 1011 and need to go to a new state to remember this fact.

      0      1         0
     /-\    /-\    /------\
     |  |   |  |   |      |
     V /    V /    V      |
---->q0---->q1---->q2---->q3---->q4
     ^   1      0  |   1      1
     |             |
     \-------------/
            0

Finally, in state q4, no matter what we see, we know we must accept the input since we've already seen the substring 1011 somewhere in the input. This means we should make q4 accepting and have both transitions go back to q4:

      0      1         0          
     /-\    /-\    /------\       /---\
     | |    | |    |      |       |    | 
     V /    V /    V      |       V    | 0,1
---->q0---->q1---->q2---->q3---->[q4]--/
     ^   1      0  |   1      1
     |             |
     \-------------/
            0

You can check some samples to convince yourself that this DFA accepts the language you want. We built it one state at a time by asking ourselves where the transitions had to go. We stopped adding new states when new transitions didn't demand them anymore.

Answer 2

We want to construct a DFA for a string which contains 1011 as a substring which means it language contain

L={0,1}

which means the strings may be

{0111011,001011,11001011,........} 

A string must contains 1011 has a substring.

1. As we observed in the transition diagram at initial state if q0 accepts 1 then move to next state otherwise remains in the same state.

2. If q1 accepts 0 then move to next state q2 otherwise remains in the same state.

3. If q2 accepts 1 then move to q3 else move to q0 because we want to substring which starts with 1 not with 0.

4. If q3 accepts 1 then move to q4 else which is a final state if system reaches to a final state it means a string is accepted because it contains a 1011 as a substring , if q3 accepts then back to q2.

After reaching the final state a string may not end with 1011 but it have some more words or string to be taken like in 001011110 110 is left which have to accept that's why at q4 if it accepts 0 or 1 it remains in the same state.

Answer 3

They are four transitions A,B,C,D in every construction of DFA we have to check each transaction must have both transactions otherwise it is not a DFA so that it is given to construct a DFA that accept string of odd 0's and 1's that was as shown below A is the initial state on transition of 0 it will goes to C and On transition 1 it will give to B B is another state gives transition of D on 0 and A on 1 and C is a state that will give transition of D and A on transition of 1 and 0 D is final state will give transition of B and C on 0 and 1 This is the process is been done on the below figure let us check the DFA with example 1011 it has odd no of 1'sand odd no of 0 so A on 1 it will give B and B on 0 it will give D and D on 1 it will give C and C on 1 it will give D hence it is the required DFA.

Answer 4

DFA for accepting strings with a substring 1011.