Tokenization Problem
Tokenisation does not search. [Note 1]. At each step, it matches (and consumes) a match of one of the patterns starting precisely at the current input point.
Although there are other tokenisation algorithms, the most common one -- usually called maximal munch -- works as follows.
At each step:

Find the longest match of each pattern starting at the current input point. (This can be done in a single linear-time left-to-right scan of the input.)

Select the longest of all these matches. If more than one pattern has the same longest match, select the pattern which comes first in the list of patterns. Report the selected pattern and the corresponding matched prefix as the next token.

Remove the matched prefix from the input, and continue from the first step.


In effect, the match in the first step is a match of a regular expression created from the disjunction of all the patterns. The regular expression matching algorithm is modified so that:

It also reports which alternative matched, and

It leaves unmatched input in the input strean, rather than insisting that the regular expression match the entire input.


For your answer C, the regular expression created is $c^*+b^++ab+ac^*$.  (Some tokenisers would correct the first pattern to $c^+$ because selecting an empty match would cause the above algorithm to fall into an endless loop.)
The longest prefixes successively matched by this disjunction are:

$ab$ (3rd alternative). The 4th alternative matches $a$, but that us shorter.

$bb$ (2nd alternative) The second alternative will also match $b$, but that's not the longest prefix matched by this pattern.

$a$ (4th alternative)

$acc$ (4th alternative)



Notes

This should be intuitive. After all, most programs are read left to right and token order matters: $a = b + c;$ cannot be written as $a b c =+ ;$, and the parser will expect to see the tokens in left-to-right order, so if the lexer produced the stream,  $a b c =+ ;$, the parser would get confused.