Deterministic Finite Automata MCQ Quiz - Objective Question with Answer for Deterministic Finite Automata - Download Free PDF

The correct answer is: Option 1

Key Points

To detect “abb”, we need at least 4 states:

1. q0 — Start state
2. q1 — After seeing 'a'
3. q2 — After seeing 'ab'
4. q3 — After seeing 'abb' → Accepting

We also need a dead state to trap wrong transitions. So the **minimum** DFA needs at least 5 states.

Option 1: This DFA uses 5 states correctly and has transitions:

• q1 → q2 (on a)
• q2 → q3 (on b)
• q3 → q4 (on b) → final
• Final state loops on a, b

Option 2: Incorrect transitions. Accepts some but not all “abb” variants. Incorrect

Option 3: Uses 6 states, which is not optimal/minimal. Incorrect

The correct answer is Option 3.

Key Points

• Option 3 specifies the grammar for the language accepted by the machine as follows:
  • S → AabbA
  • A → aA | bA | ε
• This grammar generates strings where:
  • The start symbol S derives a string with 'A', followed by 'aabb', followed by 'A'.
  • The non-terminal A can be replaced by 'aA', 'bA', or ε (the empty string).
• This allows for the generation of strings with 'a' and 'b' characters appropriately placed in the structure defined by the grammar.

Additional Information

• Grammar rules (productions) define how strings in a language can be generated from the start symbol.
• The symbol 'ε' denotes the empty string, which means a non-terminal can be replaced by nothing.
• The use of non-terminals like A allows for recursive definitions, enabling the generation of complex strings.
• Correct grammar formulations are essential in parsing and generating strings in programming languages and compilers.

The correct answer is Option 3.

Key Points

Option 1: The DFA transitions a → b → b directly to final state. But it lacks proper looping logic to verify intermediate characters. No trap state. Incorrect.

Option 2: Accepts strings only if they end with “abb”. But the question states the string can have “abb” anywhere. Incorrect.

Option 3: The DFA clearly detects “abb” and loops over further inputs. So, even strings like “aabb”, “baabbab”, “abba” will be accepted. Correct ✔

The correct answer is (a + b)* abb(a + b)*.

Key Points

• The given regular expression (a + b)* abb(a + b)* matches any string that has "abb" in between any combination of 'a' and 'b' characters.
  • The part (a + b)* indicates any combination (including none) of 'a' and 'b' characters before "abb".
  • The part abb is the fixed substring that must appear in the string.
  • The part (a + b)* after "abb" indicates any combination (including none) of 'a' and 'b' characters after "abb".
• This regular expression ensures that "abb" is always present in the string, surrounded by any number of 'a' and 'b' characters.

Additional Information

• Regular expressions are powerful tools used for pattern matching and string manipulation.
• They are widely used in various programming languages and tools for searching, replacing, and validating text.
• Understanding the components and structure of regular expressions is essential for effectively utilizing them in different applications.
• Common operations using regular expressions include searching for specific patterns, validating input data, and parsing text.

The correct answer is : Option 3

Key Points

Option 1: This DFA starts with state 1 looping on a and b. Then from 1 --a--> 2, 2 --b--> 3, and 3 --b--> 4. After reaching state 4, it loops on a and b and accepts. Looks promising, but lacks rejection for incorrect sequences like “aba”. It accepts too many patterns and has no trap state to reject wrong combinations. Incorrect.

Option 2: This DFA takes a → b → a → b → final. This structure doesn’t track “abb” correctly; it adds unnecessary transitions and doesn’t form the required substring properly. Incorrect.

Option 3: This DFA clearly implements the pattern detection:

• q1 --a--> q2
• q2 --b--> q3
• q3 --b--> q4 (final)
• q4 is the accepting state, loops on all inputs (a, b)
• Other transitions (like wrong 'a' or 'b') push to dead states

Given language is:  L = {w₁aw₂ | w₁, w₂ ϵ {a, b}*, |w₁| = 2, |w₂| ≥ 3}

Regular expression: (a+b) (a+b) a (a+b) (a+b) (a+b)(a+b)^*

Minimum length string that is possible = (a+b) (a+b) a (a+b) (a+b) (a+b)

This string has minimum length 6. For these 7 states are needed and one trap state. So, total 8 states are needed.

DFA for given language is

Consider DFA M,

It is accepting all the string that ends with a.

Language for DFA M L(M) = {a, aa, ba, aaa, aba, …}

Regular expression = (a + b )*a

DFA N is accepting all the languages ending with b.

Language for DFA N L (n) = {b, ab, bb, aab, abb, bbb,…….}

Regular expression = (a + b)*b

Intersection of both these languages L (M) ꓵ L(N) = { } = Ø i.e. empty language

For this, we just need 1 state with all transitions to itself and no final state.

Concept:

First convert the given regular expression into an NFA and then find out the DFA from NFA.

Explanation: 

Regular expression is (a + b) * b (a + b)

NFA for this expression is given here as:

Diagram: NFA

NFA Table:

DFA Table from the above NFA

Diagram: DFA

This DFA can’t be minimized further. So, for the given regular expression minimum number of states in the DFA is 4.

Concept:

Finite state automata is a machine that can be used to solve computer programs and other sequential logics and have finite number of states at a given time. There are 6 tuples in a finite state machine.

Explanation:

Two finite state machines are said to be equivalent if they recognize the same set of tokens.

Consider two automata M₁ and M₂, these are called equivalent for an input sequence if they produce the same output result.

Example:

Regular expression: baa*b

NFA: M₁

Number of states in NFA: 4

DFA: M₂

Number of states in DFA: 5

Above two finite automata are having different number of states and edges, but they are equivalent.

Data

Language L = { aⁿ b^2m | n, m ≥ 1 }

Concept

It is easier to find the minimized DFA if we find the NFA first.

NFA of the given language.

Converting this NFA into minimized DFA

Transition table

Hence, number of states in DFA for the language L = { aⁿ b^2m | n, m ≥ 1 } is 5.

Binary strings not ending in 101 is a set that is complement to binary strings ending in 101.

Since, regular languages are closed under complement, we can first design a DFA that accept strings that surely end in 101.

For finding the complement of this DFA, we simple change the non-final states to final and final state to non-final keeping the initial state as it is.

Given regular expression: (0 + 1)*(0 + 1)(0 + 1)*

In this, there is atleast one appearance of (0 + 1).

It generates strings of type {0, 1, 00, 01, 10, 11, 000, 001, 011, ……. }

DFA for the given expression is:

Number of states in minimum sized DFA for this regular expression = 2

Number of states in DFAs accepting L and L̅ is always equal.

DFA accepting (0+1) * 0011 (0+1)* is:

Hence DFA accepting L̅ will be

It has 5 states.

Concept:

Number of a’s in x: divisible by 2 = {0, 2, 4, 6, 8, 10, 12, 14, 16…}

Number of a’s in x: divisible by 3 = {0, 3, 6, 9, 12, 15, 18, 21…}

Now the number of a’s in x: divisible by 2 and not by 3 will include elements like {2, 4, 8, 10, 14, 16…}

Therefore, DFA for such a language where the number of a’s in x is divisible by 2 but not divisible by 3 will be

• Starting state 0
• Final states 2 and 4
• Note that 0 is not a final stat here only because we have to exclude numbers divisible by 6.

Therefore the number of states in DFA is 6.

Total number of bijective from A → A where A = {1,2 3, 4, 5} is 5! = 120.

The DFA for accepting L will have 5! = 120 states, since we need one state for every possible permutation function on 5 elements.