{0,1} Every5-Two0 的确定性有限自动机

Question

Question:

Define a DFA that accepts all strings over {0,1} such that every block of five consecutive positions contains at least two 0s. Please read the question carefully. Ask yourselves: Does this allow e (epsilon (empty string)) to be accepted? How about 0101? Such English descriptions are found in various books, and I want to make sure you know how to read and interpret.

Instructor Hint: "The "blocks of 5" DFA can be programmatically generated without much trouble. I did it both ways (by hand and programmatically). Because I'm good with Emacs and Keyboard Macros, I could do even the 'by hand' mechanically and quite fast. But programmatic is less error-prone and compact."

---

I'm drawing this thing out, and I think I'm doing it wrong, as it is getting out of control.

My sketch of the DFA before I make it in python:

However, this isn't right, because index 2, 3, 4, 5, and 6 constitute a block of five consecutive positions, so I need to account for at least two zeroes in that. Oh, great, and I have been thinking it needs two 1s, not two 0s. Am I going about this the entirely wrong way? Because the way I'm thinking, this is going to have a huge amount of states.

(goes back to drawing this large DFA)

Answer 1

The way I would go about this would be to define a state for each possible 5-bit string, representing the last 5 bits seen. Start off at the state representing 00000, move from state to state naturally, and mark each state with 2 or more zeroes as accepting.

Answer 2

The way I would go about this would be to define a state for each possible 5-bit string, representing the last 5 bits seen. Start off at the state representing 00000, move from state to state naturally, and mark each state with more than 2 zeroes as accepting.

Answer 3

If you want to do it the old school way:

def check(s):
    buffer = s[:5]
    i = 5
    count0, count1 = 0, 0
    while i < len(s):
        if len(buffer) == 5:
            first = buffer[0]
            if first == '0':
                count0 -= 1
            else:
                count1 -= 1
            buffer = buffer[1:]
        buffer += s[i]
        if buffer[-1] == '0':
            count0 += 1
        else:
            count1 += 1
        if count0 < 2:
            return "REJECT"
        i += 1
    if buffer.count('0') >= 2:
        return "ACCEPT"
    else:
        return "REJECT"

A slightly smarter way:

def check(s):
    return all(ss.count('0')>=2 for ss in (s[i:i+5] for i in xrange(len(s)-4)))

The verbose code of the above method:

def check(s):
    subs = (s[i:i+5] for i in xrange(len(s)-4))
    for sub in subs:
        if sub.count('0') < 2:
            return "REJECT"
    return "ACCEPT"

Haven't tested this code, but it should likely work. Your professor probably wants the third method.

Hope this helps

Answer 4

There are actually 11 16 states, including the single rejecting state. The states correspond to the up-to-four-character histories, truncated at the second most-recent zero. Only four characters are needed because the transition constitutes the fifth character in the block; if the transition character is not a 0 and there are not two zeros in the four-character history, then the transition is to failure.

I generated the transitions by hand, because it was faster to type than to write Python, so I'll leave the generalized (k, n) (k zeros in blocks of n) problem as a coding exercise. (I inserted x's into the state names to make it line up better.)

sxx00 (0)->sxx00 (1)->sx001
sx001 (0)->sx010 (1)->s0011
sx010 (0)->sxx00 (1)->s0101
s0011 (0)->s0110 (1)->s0111
s0101 (0)->sx010 (1)->s1011
s0110 (0)->sxx00 (1)->s1101
s0111 (0)->s1110 (1)->sFAIL
s1011 (0)->s0110 (1)->sFAIL
s1101 (0)->sx010 (1)->sFAIL
s1110 (0)->sxx00 (1)->sFAIL
sFAIL (0)->sFAIL (1)->sFAIL

[EDIT]: That was actually not quite correct, because (as I read the question), the string '1111' should be accepted. (Every five-character block in it has two zeros, trivially, since there are no five-character blocks.) So there are some additional start-up states:

start (0)->sxx00 (1)->s1
s1    (0)->sx010 (1)->s11
s11   (0)->s0110 (1)->s111
s111  (0)->s1110 (1)->s1111
s1111 (0)->sFAIL (1)->sFAIL

That last state, which looks a lot like sFAIL, is different because it is an accepting state.

Answer 5

每 5 个连续的字母在一个单词中至少有两个 0 (2) <=> w 不包含四个连续的 1。