Question about Finite State Automata - finite-automata

Question

I want to construct a deterministic finite automata that accepts the following language:
{w ∈ {a,b}* : each a in w is immediately preceded by a b}
So far I've got >⨀ ---b---> O ---a---> O.
'>' = initial state
⨀ = final state

Answer 1

A good way to think about FAs is by trying to think about how many different situations you can be in, in terms of how you are going to get to a string in the language. Let's start with a few small strings and see what I mean.
Say you start with the empty string. What can you append to this to get a string in the language? Well, the empty string is in the language, so we can append the empty string (i.e., nothing) and also have a string in the language. Additionally, we can append any string in the language we are going for to the empty string, and we will get a string in the language (trivially). We will need at least one state to remember the empty string (and strings like it - strings to which we can append the empty string or any other string in the language and still have a string in the language); this will be the start/initial state, and since the empty string is in the language (we check this easily), we know the start/initial state will be accepting.
Now let's consider the string a. This is an example of a string not in the language, and there's nothing we can add to the end of this string to cause it to be in the language; we've already violated the condition that all a's in the string are preceded by b's. The set of strings we can add to this to get a string in the language is the empty set, and therefore, we will need a state distinct from the one we've already identified to remember this string and strings like it - strings to which we cannot add anything to get a string in the language.
To recap, we have identified two states: an accepting start/initial state, and what we call a "dead" state - a state that is not accepting and which does not ever lead to an accepting state.
Let's try the string b. This string is in the language, and so we can add the empty string to it. We can also trivially add any other string in the language to the end of this string, and get another string in the language. However, we can also add an a followed by any string in the language, and get another string in the language. For instance, we can add the string a followed by bbabb to get babbabb, which is also in the language. The set of strings which we can add is therefore a set we haven't seen before, and we will need a new state to represent this string - the string b - and strings like it. It will be accepting, since the string b is a string in the language.
You should try the strings aa, ab, ba, and bb. You should find that the strings aa and ab are both already covered by our dead state (we can't add any strings to the end of these to get anything in our language), and that the string ba is covered by the start/initial state (we can only add to this strings already in the language to get other strings in the language), and that bb corresponds to the third state we identified (adding any string, or a single a followed by any string, will result in a string also in the language). Since we have exhausted all strings of length 2 and not added any new states, we know that these are all the states that we need in the FA; we could add others, but they'd be unnecessary.
To get the transitions, all we need to do is to make sure that all the states lead to the correct place. In other words, since the string a is formed by adding the character a to the end of the empty string, we need a transition from the start/initial state (corresponding to the empty string) to the dead state (corresponding to the string a) which occurs when the FA reads the symbol a. Similarly, we need a transition from the start/initial state to the third state on the symbol b. The other transitions are found similarly: on either an a or a b, the dead state transitions to itself, and the third state loops on b and transitions to the start/initial state on an a. Once each state has a transition for each symbol in the alphabet, you have a complete (and correct) FA. Moreoever, by constructing it in this fashion, you guarantee that you have a minimal FA... which is a nice way to solve problems requesting one, instead of coming up with an arbitrary one and minimizing it post-hoc.

Answer 2

State 1 (accepting, initial state):
On input 'a', go to state 3 (permanently rejecting the string)
On input 'b', go to state 2
State 2 (accepting):
On input 'a', go to state 1
On input 'b', go to state 2
State 3 (not accepting)
On input 'a' or 'b', stay in state 3
Conceptually, State 1 represents "a valid string whose final letter is not b", State 2 represents "a valid string whose final letter is b", and State 3 represents "a string that is not valid"
In graphed form: