deterministic finite automaton

a finite automaton is a 5-tuple $\text{[math]}$ , where

$\text{[math]}$ is a finite set called the states,
$\text{[math]}$ is a finite set called the alphabet,
$\text{[math]}$ is the transition function,
$\text{[math]}$ is the start state, and
$\text{[math]}$ is the set of accept states.

[cite:;taken from @sipser_comp_2012 definition 1.5]

a configuration of a finite automaton $\text{[math]}$ is an element of $\text{[math]}$ . the current configuration of an automaton is a pair
$\text{[math]}$ [cite:@goldberg_automata]

given a DFA $\text{[math]}$ ,
for configurations $\text{[math]}$ such that $\text{[math]}$ , we write $\text{[math]}$ iff $\text{[math]}$ .
for configurations $\text{[math]}$ , where $\text{[math]}$ , $\text{[math]}$ and $\text{[math]}$ we write $\text{[math]}$ iff there exist $\text{[math]}$ where $\text{[math]}$ such that $\text{[math]}$ .
if $\text{[math]}$ then $\text{[math]}$ iff $\text{[math]}$ .
[cite:@lewenstein_automata]

a DFA $\text{[math]}$ accepts a string $\text{[math]}$ if $\text{[math]}$ for $\text{[math]}$ .
[cite:@lewenstein_automata]

given a DFA $\text{[math]}$ , we denote by $\text{[math]}$ the language of all words that $\text{[math]}$ accepts:
$\text{[math]}$ we say $\text{[math]}$ recognizes the language $\text{[math]}$ . and call $\text{[math]}$ a regular language.
[cite:@lewenstein_automata]

let $\text{[math]}$ be a finite automaton and let $\text{[math]}$ be a string where each $\text{[math]}$ is a member of the alphabet $\text{[math]}$ , then $\text{[math]}$ accepts $\text{[math]}$ if a sequence of states $\text{[math]}$ in $\text{[math]}$ exists with three conditions:

$\text{[math]}$ ,
$\text{[math]}$ , for $\text{[math]}$ , and
$\text{[math]}$ .

condition 1 says that the machine starts in the start state. condition 2 says that the machine goes from state to state according to the transition function. condition 3 says that the machine accepts its input if it ends up in an accept state. we say that $\text{[math]}$ recognizes language $\text{[math]}$ if $\text{[math]}$ .
[cite:@sipser_comp_2012]

[cite:@sipser_comp_2012 chapter 1.1 designing finite automata] describes how to build automata in detail.

$\text{[math]}$ a string input starts at $\text{[math]}$ , if we detect an $\text{[math]}$ , we move forward to the state $\text{[math]}$ which represents a progress of 1 in detecting 3 occurrences of $\text{[math]}$ , if the next character is in $\text{[math]}$ , our progress would be cancelled and we go back to $\text{[math]}$ , otherwise we move to $\text{[math]}$ , if we detect a $\text{[math]}$ we move to the accept state and stay there since we've achieved our goal of detecting 3 $\text{[math]}$ 's, otherwise we "cancel our progress" and go back to $\text{[math]}$ .

$\text{[math]}$ at first glance this may seem impossible because DFA's cant tell the length of the string and have no record of its symbols, but it can "store" knowledge in the form of states.
here is my line of reasoning for this problem:
the possible states for this problem are

string length is 1, so the DFA shouldnt accept, that is the state $\text{[math]}$
second-to-last seen symbol was $\text{[math]}$ , and the current symbol is $\text{[math]}$ , we should accept
second-to-last seen symbol was $\text{[math]}$ , and the current symbol is $\text{[math]}$ , we should accept
second-to-last seen symbol was $\text{[math]}$ , and the current symbol is $\text{[math]}$ , we shouldnt accept
second-to-last seen symbol was $\text{[math]}$ , and the current symbol is $\text{[math]}$ , we shouldnt accept

states 4 and 5 cannot be unified into a single non-accepting state that says "last symbol wasnt $\text{[math]}$ " because if we're currently at a state that says "last symbol wasnt $\text{[math]}$ ", we cant know what the character is, we just know that before it there wasnt an $\text{[math]}$ , and so we wouldnt know where to move from there, this might not make much sense for the reader as its merely someone else's thoughts put into few words, so perhaps it helps to consider an automaton that unifies those states into one, how would it behave for the input string $\text{[math]}$ ?
states 2 and 3 also cant be unified into a single accepting state, because the automaton needs to be able to tell the difference between those states to decide whether it should accept the sequence $\text{[math]}$ , for example.
this hints that we need a total of 4 states (2 accepting, 2 non-accepting) beside the initial state, but perhaps we can reuse the initial state and unify it with state 4 or 5.