Download deterministic finite and more Lecture notes Computer Engineering and Programming in PDF only on Docsity!
The job of an FA is to accept or reject an input depending on whether the pattern defined by the FA
occurs in the input.
- Design a DFA in which set of all strings can be accepted which start with ab. Given: Input alphabet, Σ={a, b} Language L ={ab, aba, abaabbb, abba, ….}
Clearly the language is infinite because there is infinite number of strings.
The idea behind this approach is very simple, follow the steps below and you will understand.
- First we will make DFA for accepting the smallest string that is ‘ab’ and after that whatever comes we don’t care as the condition is satisfied.
- In DFA we have to take care of all the input alphabets at every state.
- so we have to take care of input symbol ‘b’ on state A, that is we have to reject it cause first ‘a’ should come then ‘b’.
- So we will make one more state D to take care of ‘b’ from state A
- On state B if a comes then we have to reject it, so we will direct this input to state D
- On state D for input a and b we do not care so we will make one self-loop
Testing
- Lets take one input string abab
- First input is a, so from state A we will go to state B
- Second input is b, so from state B we will go to state C
- Third input is a, so from state C we will go to state C itself
- Fourth input is b, so from state C we will go to state C itself (final state)
After end of the string we are at final state so string is accepted.
DFA for binary No divisible by 2
Construct a minimal DFA, which accepts set of all strings over {0,
1}, which when interpreted as binary number is divisible by ‘2’.
Means 110 in binary is equivalent to 6 in decimal and 6 is
divisible by 2.
Answer So if you think in the way of considering remainders if you divide by 2 that is {0, 1}
Answer So if you think in the way of considering remainders if you divide by 3 that is {0, 1, 2}
As you can see that binary number which is divisible by 2 is appearing on left state. Short Trick to create such DFAs Create Transition Table as below
State 0 1
q0 q0 q
q1 q2 q
q2 q1 q
Table creation rules
- (^) first write the input alphabets, example 0, 1
- there will n states for given number which is divisor.
- start writing states, as for n=3: q0 under 0, q1 under 1
- q2 under 0 and q0 under 1
- q1under 0 and q2 under 1
If the input alphabets are 0, 1, 2 then table will expand accordingly with same rules above. Example For ternary pattern and n=4, table will be as follows ;
State 0 1 2
q0 q0 q1 q
q1 q3 q0 q
q2 q2 q3 q
q3 q1 q2 q
set of all strings can be accepted which start
with 'a'
Design a DFA in which set of all strings can be accepted which
start with a.
Given: Input alphabet, Σ={a, b}
Language L = {a, ab, aba, aabb, aaabbba, …..}
Clearly the language is infinite because there is infinite number of strings.
The idea behind this approach is very simple, follow the steps below and you will understand.
- We know that first input must be a and from start state on a we should go to final state, so two states are confirmed: start state and final state.
- And if the first input is something else than ‘a’ then string should not be accepted. And we don’t care whatever comes on state C as state C now will work as dead state.
- Once we reach final state we accept everything that is why we have a loop
Set of all strings can be accepted which end
with ‘a’
Design a DFA in which set of all strings can be accepted which
end with ‘a’.
Given: Input alphabet, Σ={a, b}
Language L ={aa, aba, aaabbba, abba,baba ….}
Clearly the language is infinite because there is infinite number of strings.
The idea behind this approach is very simple, follow the steps below and you will understand.
- We will first start accepting ‘b’ on start state itself and then on a we will go to final state.
- And on final state we do not care for a’s so we have to put a self-loop.
- On final state if ‘b’ comes then we will redirect it start state so that any string which does not end with ‘a’ should not get accepted.
Testing
- Lets take one input string baba
- First input is b, so from state A we will go to state A itself
- Second input is a, so from state A we will go to state B
- Third input is b, so from state B we will go to state A
- Fourth input is a, so from state A we will go to state B (final state)
After end of the string we are at final state so string is accepted.
Set of all strings can be accepted which start with ab
Design a DFA in which set of all strings can be accepted which
start with ab.
Given: Input alphabet, Σ={a, b}
Language L ={ab, aba, abaabbb, abba, ….}
Clearly the language is infinite because there is infinite number of strings.
The idea behind this approach is very simple, follow the steps below and you will understand.
- First we will make DFA for accepting the smallest string that is ‘ab’ and after that whatever comes we don’t care as the condition is satisfied.
- In DFA we have to take care of all the input alphabets at every state.
- so we have to take care of input symbol ‘b’ on state A, that is we have to reject it cause first ‘a’ should come then ‘b’.
- So we will make one more state D to take care of ‘b’ from state A
- On state B if a comes then we have to reject it, so we will direct this input to state D
- On state D for input a and b we do not care so we will make one self-loop
Testing
- Lets take one input string abab
- First input is a, so from state A we will go to state B
- Second input is b, so from state B we will go to state C
- Third input is a, so from state C we will go to state C itself
- Fourth input is b, so from state C we will go to state C itself (final state)
After end of the string we are at final state so string is accepted.
Set of all strings can be accepted which
contain ab
Design a DFA in which set of all strings can be accepted which
ends with ab.
Given: Input alphabet, Σ={a, b}
Language L ={ab, abab, abaabbab, abbab, bbabaabab ….}
Clearly the language is infinite because there is infinite number of strings.
The idea behind this approach is very simple, follow the steps below and you will understand.
- First we will make DFA for accepting the smallest string that is ‘ab’
- (^) In DFA we have to take care of all the input alphabets at every state.
- so we have to take care of input symbol ‘b’ on state A, that is we made self-loop on start state.
- On state B if a comes then we will accept it as repetition of ‘a’ after a will not ruin anything. Because we want ab in the end.
- on State C if b comes then that will be a problem as we only want ab in the end not bb, so we will direct b to state A.
- If ‘a’ comes on state C then we will direct it to state B and if one ‘b’ comes then we will be good by getting ‘ab’ in the end
Testing
- Lets take one input string baababab
- First input is b, so from state A we will go to state A itself
- Second input is a, so from state A we will go to state B
- Third input is a, so from state B we will go to state B itself
- Fourth input is b, so from state B we will go to state C
- Fifth input is a, so from state C we will go to state B
- Sixth input is b, so from state B we will go to state C
- Seventh input is a, so from state C we will go to state B
- (^) Eighth input is b, so from state B we will go to state C (final state)
After end of the string we are at final state so string is accepted.
Start and end symbol must be different
Design a DFA in which start and end symbol must be different
Given: Input alphabet, Σ={a, b}
Language L = {ab, ab, abab, aabb, aaabbb,...}
Clearly the language is infinite because there is infinite number of strings.
The idea behind this approach is very simple, follow the steps below and you will understand.
- We know that if the first input is 'a' then the last input cannot be 'a', so we start two flows form start state, one for staring with 'a' and another for starting with 'b'
- This is also clear that there will be two final states
- In the first flow starting with 'a' we have already discussed the process in the previous examples. We will accept the input 'a' on state B for multiple times and then on b we will go to final state.
- On final state we will direct the input 'a' to state B so that the last symbol should not be 'a'
- The same mechanism will be for another flow staring from start state A on input 'a'.
Testing 1
Clearly the language is infinite because there is infinite number of strings.
This DFA is complement of the previous example. We will explain complementation in the next section. The idea behind this approach is very simple, follow the steps below and you will understand.
- We know that if the first input is 'a' then the last input should be 'a', so we start two flows form start state, one for staring with 'a' and another for starting with 'b'
- Now just design the very basic DFA accepting for ε, that means the start state should final state.
- In the first flow when 'a' comes form the input string then we should also reach final state as 'a' is also satify the property of DFA
- After 'a' if any number of 'a' comes then we do not have any problem, that is why a self-loop on state B
- On state B if b comes then it should be accepted as B is final state so we will create one more state C to get the 'b'
- On state C if any number of 'b' comes we do not have issues but if 'a' comes then we have to accept it so we will direct input to state B
- The same mechanism will be for another flow staring from start state A on input 'b'.
Testing 1
- Lets take one input string aba (this will describe for strings which starts with a and ends with same symbol a)
- Scan string from left to right
- First input is a, so from state A we will go to state B
- Second input is b, so from state B we will go to state C
- Third input is a, so from state C we will go to state B (final state)
After end of the string we are at final state so string is accepted.
Testing 2
- Lets take another input string bab(this will describe for strings which starts with b and ends with same symbol b)
- Scan string from left to right
- First input is b, so from state A we will go to state D
- Second input is a, so from state D we will go to state E
- Third input is b, so from state E we will go to state D (final state)
After end of the string we are at final state so string is accepted.
You may also try some examples of strings to run over this DFA, and you will understand more
Every 'a' should be followed by 'b'
Design a DFA in which every 'a' should be followed by 'b'
Given: Input alphabet, Σ={a, b}
Language L = {ε, ab, abab, bbbb, ...}
Clearly the language is infinite because there is infinite number of strings.
The idea behind this approach is very simple, follow the steps below and you will understand.
- Firstly for ε we will make the start sate as final state.
- Here C state is a dead state
Testing
- (^) Lets take one input string baa
- Scan string from left to right
- First input is b, so from state A we will go to state A itself
- Second input is a, so from state A we will go to state B
- Third input is a, so from state B we will go to state B itself (final state)
After end of the string we are at final state so string is accepted. You may also try some examples of strings to run over this DFA, and you will understand
more
Every 'a' should followed by 'bb'
Design a DFA in which every 'a' should followed by 'bb'
Given: Input alphabet, Σ={a, b}
Language L = {ε, abb, abbabb, abbabbabb, babb, ...}
Clearly the language is infinite because there is infinite number of strings.
The idea behind this approach is very simple, follow the steps below and you will understand.
- Firstly there is ε so make start state as final state
- And we do not care if string is only 'bbbbb...'(as this doesn't violate given property) so put self- loop on start state itself
- if a comes then we will move state B and we should have two b's after that so state C and D (final state)
- Now what if 'a' comes on state D so we will direct it to state B so that if two b's comes thereafter then string will be accepted
- On state D if b comes then that is not a problem so a self-loop is given there for 'b'
- What if 'a' comes on state B then it should be rejected as after 'a' only two b's are allowed
- That is why we have a dead state E(in red)
- On state C if 'a' comes then also property is violated so we will direct flow to state D on 'a'
- On state E we do not care about either 'a' or 'b' as the stirng is already failed the property
Testing
- Lets take one input string babb
- Scan string from left to right
- First input is b, so from state A we will go to state A itself
- Second input is a, so from state A we will go to state B
- Third input is b, so from state B we will go to state C
- Fourth input is b, so from state C we will go ti state D (final state)
After end of the string we are at final state so string is accepted. You may also try some examples of strings to run over this DFA, and you will understand more
Every 'a' should never followed by
'bb'
Design a DFA in which every 'a' should never followed by 'bb'
Given: Input alphabet, Σ={a, b}
Language L = {ε, aa, bb, ab, aaa, bbbb, ...}
