How do I draw a DFA which accepts all strings with exactly one ‘a’?

 To design a Deterministic Finite Automaton (DFA) that accepts all strings with exactly one 'a', we need to create states that track the number of 'a's encountered and ensure that only one 'a' appears in the input string. Here's how you can design such a DFA:

Key Observations:

• The DFA should only accept strings that contain exactly one 'a'.
• The alphabet for the strings is assumed to be {a, b}, where 'b' is any character that doesn't affect the count of 'a's.
• The DFA will transition based on whether it has seen zero, exactly one, or more than one 'a's.

States:

1. q0: The initial state. This state represents having seen zero 'a's so far.
2. q1: This state represents having seen exactly one 'a'.
3. q2: A "dead" state (or reject state) that represents the scenario where more than one 'a' has been encountered. Once in this state, the DFA will never accept any further strings.

Transitions:

• From q0 (seen 0 'a's):

  • On reading 'a', move to q1 (because we've seen exactly one 'a').
  • On reading 'b', stay in q0 (no 'a' encountered yet).

• From q1 (seen exactly 1 'a'):

  • On reading 'a', move to q2 (we've encountered more than one 'a').
  • On reading 'b', stay in q1 (still exactly one 'a' seen).

• From q2 (seen more than 1 'a'):

  • On reading 'a' or 'b', stay in q2 (this state is a "sink" state—once we're in it, we can't leave).

Final State:

• The only accepting state is q1, because we want to accept strings with exactly one 'a'.
• States q0 and q2 are non-accepting.

DFA Diagram:

Here's a textual representation of the DFA:

(q0) --a--> (q1) --a--> (q2)
 |           |           |
 b           b           b
 |           |           |
 v           v           v
(q0)       (q1)        (q2)

• q0 (start state) accepts strings with no 'a'.
• q1 accepts strings with exactly one 'a'.
• q2 is a "dead" state for strings with more than one 'a', which the DFA rejects.

Transition Table:

State	Input 'a'	Input 'b'
q0	q1	q0
q1	q2	q1
q2	q2	q2

Example Walkthrough:

1. Input: "b"

   • Start at q0 (seen 0 'a's).
   • Read 'b', stay in q0.
   • End in q0, which is not accepting. Reject.

2. Input: "ab"

   • Start at q0 (seen 0 'a's).
   • Read 'a', move to q1 (seen 1 'a').
   • Read 'b', stay in q1.
   • End in q1, which is accepting. Accept.

3. Input: "aab"

   • Start at q0 (seen 0 'a's).
   • Read 'a', move to q1 (seen 1 'a').
   • Read 'a', move to q2 (seen more than 1 'a').
   • Read 'b', stay in q2.
   • End in q2, which is not accepting. Reject.

Conclusion:

This DFA ensures that it accepts only those strings which contain exactly one 'a' and reject all others.