public NFA RemoveLambda()
{
NFA TempNfa = this;
for (int i = 0; i < TempNfa.States.Count; i++)
{
if (TempNfa.States[i].DTransitions.TryGetValue("", out List <DeletableTransition> value))
{
for (int j = 0; j < value.Count; j++)
{
State statete_to_remove = value[j].State;
TempNfa.States[i] = TempNfa.States[i].Merge(value[j].State, TempNfa);
for (int t = 0; t < TempNfa.States.Count; t++)
{
if (TempNfa.States[t].name == statete_to_remove.name)
{
TempNfa.States.RemoveAt(t);
i = 0;
}
}
}
}
}
return(new NFA(TempNfa.States[0], TempNfa.States));
}
static void Main(string[] args)
{
List <State> states = new List <State>();
Console.WriteLine("Please, Enter the states like ( q0,q1,q2, ...):");
string[] Statenames = Console.ReadLine().Split(',');
for (int i = 0; i < Statenames.Length; i++)
{
if (i != 0)
{
State temp = new State(Statenames[i]);
states.Add(temp);
}
else
{
State temp = new State(Statenames[i], true);
states.Add(temp);
}
}
Console.WriteLine("Please, Enter the alphabet like (a,b,c, ...):");
State.alphabets = Console.ReadLine().Split(',').ToList();
State.alphabets.Add("");
Console.WriteLine("Please, Enter the Final states like (q0,q1,q2, ...):");
string[] FinalStates = Console.ReadLine().Split(',');
for (int i = 0; i < FinalStates.Length; ++i)
{
for (int j = 0; j < states.Count; ++j)
{
if (states[j].name == FinalStates[i])
{
states[j].isFinal = true;
break;
}
}
}
Console.WriteLine("Please, Enter how many rules you want to enter: ");
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; i++)
{
string[] token = Console.ReadLine().Split(',');
for (int j = 0; j < states.Count; j++)
{
if (states[j].name == token[0])
{
for (int t = 0; t < states.Count; t++)
{
if (states[t].name == token[1])
{
states[j].AddTransition(token[2], states[t]);
}
}
}
}
}
Console.WriteLine();
NFA nfa = new NFA(states[0], states);
// END of Initializing...
bool IsThereDFA = false;
string input = "";
DFA dfa = new DFA(new State("sample"), new List <State>());
while (input != "8")
{
while (!(input == "1" || input == "2" || input == "3" || input == "4" || input == "5" || input == "6" || input == "7" || input == "8"))
{
Console.WriteLine("Please enter: ");
Console.WriteLine("1 for isAcceptByNFA");
Console.WriteLine("2 for createEquivalentDFA");
Console.WriteLine("3 for findRegExp");
Console.WriteLine("4 for showSchematic(NFA)");
Console.WriteLine("5 for isAcceptByDFA");
Console.WriteLine("6 for makeSimpleDFA");
Console.WriteLine("7 for showSchematic(DFA)");
Console.WriteLine("8 for Exit");
input = Console.ReadLine();
}
switch (input)
{
case "1":
Console.Write("please enter a string: ");
string s = Console.ReadLine();
if (nfa.IsAcceptByFA(s))
{
Console.WriteLine($"Yes, {s} is Accepted");
}
else
{
Console.WriteLine($"No, {s} is not Accepted");
}
break;
case "2":
IsThereDFA = true;
dfa = nfa.CreateEquivalentDFA();
Console.WriteLine("DFA has been built");
break;
case "3":
Console.WriteLine(nfa.findRegExp());
break;
case "4":
nfa.ShowSchematicFA();
break;
case "5":
if (IsThereDFA)
{
Console.Write("please enter a string: ");
s = Console.ReadLine();
if (dfa.IsAcceptByFA(s))
{
Console.WriteLine($"Yes, {s} is Accepted");
}
else
{
Console.WriteLine($"No, {s} is not Accepted");
}
}
else
{
Console.WriteLine("There is no DFA yet!");
}
break;
case "6":
if (IsThereDFA)
{
dfa = dfa.MakeSimpleDFA(dfa);
Console.WriteLine("DFA has been minimized");
}
else
{
Console.WriteLine("There is no DFA yet!");
}
break;
case "7":
if (IsThereDFA)
{
dfa.ShowSchematicFA();
}
else
{
Console.WriteLine("There is no DFA yet!");
}
break;
case "8":
break;
}
if (input != "8")
{
input = "";
}
Console.WriteLine();
}
/*NFA nfa = new NFA(states[0], states);
* Console.WriteLine();
* Console.WriteLine("Alphabet : ");
*
* foreach (var i in State.alphabets)
* Console.WriteLine(i);
*
* Console.WriteLine("States: ");
* for (int i = 0; i < nfa.States.Count; i++)
* {
* Console.WriteLine($"name: {nfa.States[i].name} isinitial: {nfa.States[i].isInit} isfinal: {nfa.States[i].isFinal}");
* foreach (var j in nfa.States[i].DTransitions)
* foreach (var t in j.Value)
* Console.WriteLine($"source: {nfa.States[i].name} alphabet: {j.Key} destination: {t.name}");
* Console.WriteLine();
* }*/
}
public State Merge(State s, NFA TempNfa)
{
State merged = new State(this.name + s.name);
DeletableTransition MERGED = new DeletableTransition(merged);
if (this.isInit || s.isInit)
{
merged.isInit = true;
}
if (this.isFinal || s.isFinal)
{
merged.isFinal = true;
}
if (this.DTransitions.TryGetValue("", out List <DeletableTransition> value))
{
for (int i = 0; i < value.Count; i++)
{
if (value[i].State.name == s.name || value[i].State.name == this.name)
{
value.RemoveAt(i);
}
}
}
if (s.DTransitions.TryGetValue("", out List <DeletableTransition> value1))
{
for (int i = 0; i < value1.Count; i++)
{
if (value1[i].State.name == this.name || value1[i].State.name == s.name)
{
value.RemoveAt(i);
}
}
}
for (int i = 0; i < State.alphabets.Count; i++)
{
List <DeletableTransition> temp = new List <DeletableTransition>();
if (this.DTransitions.TryGetValue(State.alphabets[i], out value))
{
for (int j = 0; j < value.Count; j++)
{
if (value[j].State.name == this.name || value[j].State.name == s.name)
{
temp.Add(MERGED);
}
else
{
temp.Add(value[j]);
}
}
}
if (s.DTransitions.TryGetValue(State.alphabets[i], out value1))
{
for (int j = 0; j < value1.Count; j++)
{
if (value1[j].State.name == this.name || value1[j].State.name == s.name)
{
temp.Add(MERGED);
}
else
{
temp.Add(value1[j]);
}
}
}
merged.DTransitions.Add(State.alphabets[i], temp);
}
for (int i = 0; i < TempNfa.States.Count; i++)
{
for (int j = 0; j < State.alphabets.Count; j++)
{
if (TempNfa.States[i].DTransitions.TryGetValue(State.alphabets[j], out value))
{
for (int t = 0; t < value.Count; t++)
{
if (value[t].State.name == this.name || value[t].State.name == s.name)
{
value.RemoveAt(t);
value.Add(MERGED);
}
}
}
}
}
return(merged);
}
public DFA CreateEquivalentDFA()
{
NFA TEMP = this.RemoveLambda();
List <ConvertionalState> table = new List <ConvertionalState>();
State trap = new State("trap");
TEMP.States.Add(trap);
ConvertionalState Trap = new ConvertionalState(new List <State>()
{
trap
});
for (int i = 0; i < State.alphabets.Count; i++)
{
Trap.DTransitions.Add(State.alphabets[i], trap.name);
}
List <State> name = new List <State>()
{
TEMP.initialState
};
table.Add(new ConvertionalState(name, true));
for (int i = 0; i < table.Count; i++)
{
for (int j = 0; j < State.alphabets.Count; j++)
{
List <State> transition = new List <State>();
for (int t = 0; t < table[i].name.Count; t++)
{
if (table[i].name[t].DTransitions.TryGetValue(State.alphabets[j], out List <DeletableTransition> value))
{
for (int z = 0; z < value.Count; z++)
{
bool Its_new = true;
for (int x = 0; x < transition.Count; x++)
{
if (value[z].State.name == transition[x].name)
{
Its_new = false;
}
}
if (Its_new)
{
transition.Add(value[z].State);
}
}
}
}
if (transition.Count == 0)
{
table[i].DTransitions.Add(State.alphabets[j], trap.name);
}
else
{
string Name = "";
for (int t = 0; t < transition.Count; t++)
{
Name += transition[t].name;
}
table[i].DTransitions.Add(State.alphabets[j], Name);
}
bool flag = false;
string Value = "";
if (table[i].DTransitions.TryGetValue(State.alphabets[j], out Value))
{
if (Value.Length != 0)
{
for (int t = 0; t < table.Count; t++)
{
string tempname = "";
List <char> c = new List <char>();
for (int z = 0; z < table[t].name.Count; z++)
{
tempname += table[t].name[z].name;
}
for (int z = 0; z < tempname.Length; z++)
{
c.Add(tempname[z]);
}
for (int z = 0; z < c.Count; z++)
{
for (int x = z; x < c.Count; x++)
{
if (c[z] < c[x])
{
char s = c[z];
c[z] = c[x];
c[x] = s;
}
}
}
tempname = "";
for (int z = 0; z < c.Count; z++)
{
tempname += c[z];
}
c = new List <char>();
for (int z = 0; z < Value.Length; z++)
{
c.Add(Value[z]);
}
for (int z = 0; z < c.Count; z++)
{
for (int x = z; x < c.Count; x++)
{
if (c[z] < c[x])
{
char s = c[z];
c[z] = c[x];
c[x] = s;
}
}
}
Value = "";
for (int z = 0; z < c.Count; z++)
{
Value += c[z];
}
if (tempname == Value)
{
flag = true;
break;
}
}
}
}
if (!flag && transition.Count != 0)
{
table.Add(new ConvertionalState(transition));
}
}
}
List <State> dfa = new List <State>();
for (int i = 0; i < table.Count; i++)
{
bool finalSt = false;
string NAME = "";
for (int j = 0; j < table[i].name.Count; j++)
{
NAME += table[i].name[j].name;
if (table[i].name[j].isFinal)
{
finalSt = true;
}
}
if (i == 0)
{
dfa.Add(new State(NAME, true));
}
else
{
dfa.Add(new State(NAME));
}
dfa[dfa.Count - 1].isFinal = finalSt;
}
for (int i = 0; i < table.Count; i++)
{
for (int j = 0; j < State.alphabets.Count; j++)
{
for (int t = 0; t < dfa.Count; t++)
{
if (table[i].DTransitions.TryGetValue(State.alphabets[j], out string value))
{
if (dfa[t].name == value)
{
DeletableTransition tempp = new DeletableTransition(dfa[t]);
dfa[i].DTransitions.Add(State.alphabets[j], new List <DeletableTransition>()
{
tempp
});
}
}
}
}
}
DFA ReDfa = new DFA(dfa[0], dfa);
for (int i = 0; i < ReDfa.States.Count; i++)
{
for (int j = 0; j < State.alphabets.Count - 1; j++)
{
if (!ReDfa.States[i].DTransitions.TryGetValue(State.alphabets[j], out List <DeletableTransition> value))
{
DeletableTransition tempp = new DeletableTransition(trap);
ReDfa.States[i].DTransitions.Add(State.alphabets[j], new List <DeletableTransition> {
tempp
});
}
}
}
return(ReDfa);
}
