Your program will simulate a machine called a "finite automaton" (FA); sometimes this is also called a Deterministic Finite Automaton (DFA). An FA is described by its states and its transitions: each transition specifies an input and what state that input leads to. You will read the description of some arbitrary FA first; then you will simulate that FA starting in a specific state and running on a specific input.
Problem Statement (Including Input and Output)
First, process a file that describes a FA. Create a Map whose keys are states and whose values are another Map of the transitions from that state: whose keys are inputs and whose values are states. Each line of the file contains a state and a description of its transitions. The first token is the state (a String) and the remaining tokens (always coming in pairs) are inputs and states. Each transition Map for a state has a key that is an input (a String) and a value that is a state (a String). All tokens are separated by one semicolon character. We write this informally as Map[String] -> (Map[String] -> String).
For example, the file parity.txt contains the following lines:
even;0;even;1;odd
odd;0;odd;1;even
Here is a picture of the parity FA.
It graphically illustrates the two states (even and odd)
and their transitions, using inputs (0 and 1)
that always lead back to one of these two states.
Here, the state even (meaning it has seen an even number of 1 inputs so far) is a key in the main Map. It's value is a Map with two key/value pairs 0/even and 1/odd. It means that in the even state, if the input is a 0 the FA stays in the even state; if the input is a 1 the FA goes to the odd state. And similarly (the next line) means that in the odd state, if the input is a 0 the FA stays in the odd state; if the input is a 1 the FA goes back to the even state.
Second print a sorted version of the main Map: the states (for any FA, no matter how many states it has) must be printed in alphabetical order, one state per line, each followed by its associated Map of transitions. The information in the transition Maps does not have to be in alphabetical order: you can print the Map using a toString method (explicitly or implicitly).
For example, the file above would produce:
Finite Automaton
even transitions = ArrayMap[2/2:[0]=0->even,[1]=1->odd]
odd transitions = ArrayMap[2/2:[0]=0->odd,[1]=1->even]
Third, process a one-line file that contains an initial state followed by a sequence of inputs. The initial state will be a state in the FA (are in the outer map) and all inputs specify legal transitions (are in the inner maps).
For example, the input file inputparity.txt contains the following
line:
even;1;0;1;1;0;1
This means, starting in the initial state even it processes the inputs
1, 0, 1, 1, 0, and 1.
Print the initial state, and then each input and the new state it transitions
to, and finally print the final state.
For the parity FA and this file, it prints
Initial state = even
input = 1; new state = odd
input = 0; new state = odd
input = 1; new state = even
input = 1; new state = odd
input = 0; new state = odd
input = 1; new state = even
Final state = even
Sample Interaction
The program, as specified, will have the following interaction: user-typed information appears in italics. Your output should "match" this one.Enter Finite Automaton Description File: parity.txt Finite Automaton even transitions = ArrayMap[2/2:[0]=0->even,[1]=1->odd] odd transitions = ArrayMap[2/2:[0]=0->odd,[1]=1->even] Enter start state/inputs file: inputparity.txt Initial state = even input = 1; new state = odd input = 0; new state = odd input = 1; new state = even input = 1; new state = odd input = 0; new state = odd input = 1; new state = even Final state = even
