Automaton | Simple framework which allows the testing of Swing

As can be seen in the comments of the post, my problem is fixed, so I thought I'd collect a closing answer here to not leave the post pending.

The actual solution: As explained here nicely by @UninformedUser, the issue was that I had conflicting maven package versions in my dependencies. Bringing everything in sync with each other solved the issue.

Incidental solution: As I wrote in the comments above, specifically defining 3.3.0 for the maven-assembly-plugin happened to solve the issue. But this was only chance, as explained here by @Ignazio, just because the order of "assembling" things changed, overwriting the conflicting package.

Huge thanks to both for the help.

If you are only interested in matching for words (i.e. separated by a white space), rather than using a full search text, it might be faster to use a set of words. Note, however, that this uses some additional memory. One straightforward solution to replicate your behaviour would be:

Laziness to the rescue. We can recursively define a list of all the sub-automata, such that their transitions index into that same list:

You have to add word boundaries '\b' to your regex pattern. From the re module docs:

\b

Matches the empty string, but only at the beginning or end of a word. A word is defined as a sequence of word characters. Note that formally, \b is defined as the boundary between a \w and a \W character (or vice versa), or between \w and the beginning/end of the string. This means that r'\bfoo\b' matches 'foo', 'foo.', '(foo)', 'bar foo baz' but not 'foobar' or 'foo3'.

Besides that, you want to use Series.str.findall (or Series.str.extractall) instead of Series.str.extract to find all the matches.

This should work

That might do:

If you have access to the DFA's attributes (i.e., states, transitions, start state, accepting states), then let the algorithm turn that information into a graph, where states are vertices, transitions are labelled edges (labelled with the input symbol).

Perform a breadth-first traversal from the start node, and allow nodes to be revisited. Whenever a node is visited that represents an accepting state, output the string that corresponds to the path. Either keep track of the formed string while expanding the search, or keep a back reference to the preceding node in the path, so that the string can be rebuilt from that linked list.

If the output must be ordered for equally sized strings, then make sure the nodes have their outgoing edges ordered by label (symbol).

This is not a memory efficient method.

If the DFA accepts an infinite number of inputs, then this algorithm will run infinitely, but practically it will run until it runs out of memory.

As Drew said, you cannot use hooks in your useEffect (all hooks must be called on every render)

The problem in your code is you initialize grid with clearGrid() on the first render. but numRows used in that function still undefined.

you can use useRef and useEffect to initalize your grid

You have to call glutSwapBuffers to flush the display respectively perform a buffer swap:

There are lots of optimisations available.

If there is no transition with the current input character from the current state, then the lexer has found the match (but it might not be at the current input point, see below). So you have the option of storing a transition to a special "reject" state or of not storing a transition at all and using "reject" as the default lookup value. If you're using a map, then not storing non-transitions makes sense. But it's generally better to use a vector (or fixed-size array) which is a more efficient datatype, and use the character code as an integer in the index.

Either way, you can almost always significantly cut down on table size by grouping characters into equivalence classes based on the set of transitions for that character. (That is, two characters are in the same equivalence class if every state either has the same transition on both characters, or has no transition on either character.) The equivalence classes can be represented by small integeers; in a typical lexical grammar, even with Unicode character sets, there are fifty or sixty equivalence classes, which is a lot fewer than 256 8-bit characters and enormously fewer than over a million Unicode characters.

The transition table can be compressed a lot more; standard compression techniques are described in most relevant textbooks. But these days memory is cheap enough that the equivalence class compression is probably sufficient.

The other issue is knowing what to do when you hit a state with no valid transition. There's no guarantee in general that the current state is an accepting state, so it's possible that you will have to back up the input cursor.

For a simple example, consider a language like C in which . and ... are tokens but .. is not. As a result, the input: