Advertisement
Semount

Formal grammar for uni

Sep 27th, 2023
845
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 11.33 KB | None | 0 0
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Linq;
  5. using System.Runtime.InteropServices;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace MacAuto1_CTest
  10. {
  11.     internal class Program
  12.     {
  13.         static StringBuilder ReplaceChar(StringBuilder S, int num)
  14.         {
  15.             switch (num)
  16.             {
  17.                 case 1: S.Replace("0", "aSSa"); break;
  18.                 case 2: S.Replace("0", "bSb"); break;
  19.                 case 3: S.Replace("0", "cAb"); break;
  20.                 case 4: S.Replace("0", "Aa"); break;
  21.                 case 5: S.Replace("0", "Ba"); break;
  22.                 case 6: S.Replace("0", "e"); break;
  23.                 case 7: S.Replace("0", "bB"); break;
  24.                 case 8: S.Replace("0", "aA"); break;
  25.                 default: Console.WriteLine("error"); return S;
  26.             }
  27.             return S;
  28.         }
  29.  
  30.         static StringBuilder grammar_outL(StringBuilder S, StringBuilder sequence)
  31.         {
  32.             //Random rnd = new Random();
  33.             byte input_var = 0;
  34.             //int random_num = rnd.Next(1, 4);
  35.             //Console.Write(" -> " + S);
  36.             for (int i = 0; i < S.Length; i++)
  37.             {
  38.                 switch (S[i])
  39.                 {
  40.                     case 'S':
  41.                         //random_num = rnd.Next(1, 4);
  42.                         Console.WriteLine("Choose a rule: ");
  43.                         Console.WriteLine("1. S -> aSSa\n2. S -> bSb\n3. S -> cAb");
  44.                         do
  45.                         {
  46.                             input_var = Convert.ToByte(Console.ReadLine());
  47.                         }
  48.                         while (input_var < 1 || input_var > 3);
  49.                         sequence.Append(input_var);
  50.                         S[i] = '0';
  51.                         ReplaceChar(S, input_var);
  52.                         i = 0;
  53.                         Console.WriteLine(S);
  54.                         break;
  55.  
  56.                     case 'A':
  57.                         //random_num = rnd.Next(4, 7);
  58.                         Console.WriteLine("4. A -> Aa\n5. A -> Ba\n6. A -> epsilon");
  59.                         Console.WriteLine("Choose a rule: ");
  60.                         do
  61.                         {
  62.                             input_var = Convert.ToByte(Console.ReadLine());
  63.                         }
  64.                         while (input_var < 4 || input_var > 7);
  65.                         sequence.Append(input_var);
  66.                         S[i] = '0';
  67.                         ReplaceChar(S, input_var);
  68.                         i = 0;
  69.                         Console.WriteLine(S);
  70.                         break;
  71.  
  72.                     case 'B':
  73.                         //random_num = rnd.Next(7, 9);
  74.                         Console.WriteLine("7. B -> bB\n8. B -> aA");
  75.                         Console.WriteLine("Choose a rule: ");
  76.                         do
  77.                         {
  78.                             input_var = Convert.ToByte(Console.ReadLine());
  79.                         }
  80.                         while (input_var < 7 || input_var > 8);
  81.                         sequence.Append(input_var);
  82.                         S[i] = '0';
  83.                         ReplaceChar(S, input_var);
  84.                         i = 0;
  85.                         Console.WriteLine(S);
  86.                         break;
  87.                     default: break;
  88.                 }
  89.             }
  90.             S.Replace("e", "");
  91.             return S;
  92.         }
  93.  
  94.         static StringBuilder grammar_outR(StringBuilder S, StringBuilder sequence)
  95.         {
  96.             //Random rnd = new Random();
  97.             byte input_var = 0;
  98.             //int random_num = rnd.Next(1, 4);
  99.             //Console.Write(" -> " + S);
  100.             Console.WriteLine("\nS");
  101.             for (int i = S.Length - 1; i >= 0; i--)
  102.             {
  103.                 switch (S[i])
  104.                 {
  105.                     case 'S':
  106.                         //random_num = rnd.Next(1, 4);
  107.                         Console.WriteLine("Choose a rule: ");
  108.                         Console.WriteLine("1. S -> aSSa\n2. S -> bSb\n3. S -> cAb");
  109.                         do
  110.                         {
  111.                             input_var = Convert.ToByte(Console.ReadLine());
  112.                         }
  113.                         while (input_var < 1 || input_var > 3);
  114.                         sequence.Append(input_var);
  115.                         S[i] = '0';
  116.                         ReplaceChar(S, input_var);
  117.                         i = S.Length - 1;
  118.                         Console.WriteLine(S);
  119.                         break;
  120.  
  121.                     case 'A':
  122.                         //random_num = rnd.Next(4, 7);
  123.                         Console.WriteLine("4. A -> Aa\n5. A -> Ba\n6. A -> epsilon");
  124.                         Console.WriteLine("Choose a rule: ");
  125.                         do
  126.                         {
  127.                             input_var = Convert.ToByte(Console.ReadLine());
  128.                         }
  129.                         while (input_var < 4 || input_var > 6);
  130.                         sequence.Append(input_var);
  131.                         S[i] = '0';
  132.                         if (input_var == 6)
  133.                         {
  134.                             S.Remove(i, 1);
  135.                         }
  136.                         else
  137.                             ReplaceChar(S, input_var);
  138.                         i = S.Length - 1;
  139.                         Console.WriteLine(S);
  140.                         break;
  141.  
  142.                     case 'B':
  143.                         //random_num = rnd.Next(7, 9);
  144.                         Console.WriteLine("7. B -> bB\n8. B -> aA");
  145.                         Console.WriteLine("Choose a rule: ");
  146.                         do
  147.                         {
  148.                             input_var = Convert.ToByte(Console.ReadLine());
  149.                         }
  150.                         while (input_var < 7 || input_var > 8);
  151.                         sequence.Append(input_var);
  152.                         S[i] = '0';
  153.                         ReplaceChar(S, input_var);
  154.                         i = S.Length - 1;
  155.                         Console.WriteLine(S);
  156.                         break;
  157.                     default: break;
  158.                 }
  159.             }
  160.             S.Replace("e", "");
  161.             return S;
  162.         }
  163.  
  164.         static string Linear_Tree(StringBuilder sequence)
  165.         {
  166.             string _Linear_Tree = "S()";
  167.             var for_replacing = new StringBuilder("");
  168.             for (int i = 0; i < sequence.Length; i++)
  169.             {
  170.                 for_replacing.Clear();
  171.                 for_replacing.Append(0);
  172.                 for (int j = 0; j < _Linear_Tree.Length; j++)
  173.                 {
  174.                     if (j != _Linear_Tree.Length - 1 && _Linear_Tree[j + 1] == ')' && _Linear_Tree[j] == '(')
  175.                     {
  176.                         _Linear_Tree = _Linear_Tree.Insert(j + 1, Convert.ToString(ReplaceChar(for_replacing, Convert.ToInt32(sequence[i]) - 48)));
  177.                        
  178.                     }
  179.  
  180.                     if ((_Linear_Tree[j] == 'S' || _Linear_Tree[j] == 'A' || _Linear_Tree[j] == 'B') && _Linear_Tree[j + 1] != '(')
  181.                     {
  182.                         _Linear_Tree = _Linear_Tree.Insert(j + 1, "()");
  183.                         break;
  184.                     }
  185.                 }
  186.             }
  187.             _Linear_Tree = _Linear_Tree.Replace("e","");
  188.             return _Linear_Tree;
  189.         }
  190.  
  191.         static bool output_possible(string sequence, StringBuilder S)
  192.         {
  193.             int F = 0;
  194.             for (int i = 0; i < S.Length; i++)
  195.             {
  196.                 switch (S[i])
  197.                 {
  198.                     case 'S':
  199.                         if (F < sequence.Length && (sequence[F] == '1' || sequence[F] == '2' || sequence[F] == '3'))
  200.                         {
  201.                            
  202.                                 S[i] = '0';
  203.                                 ReplaceChar(S, Convert.ToInt32(sequence[F]) - 48);
  204.                                 F++;
  205.                                 i = 0;
  206.                                 break;
  207.                            
  208.                         }
  209.                         else
  210.                             return false;
  211.  
  212.                     case 'A':
  213.                         if (F < sequence.Length && (sequence[F] == '4' || sequence[F] == '5' || sequence[F] == '6'))
  214.                         {
  215.                            
  216.                                 S[i] = '0';
  217.                                 ReplaceChar(S, Convert.ToInt32(sequence[F]) - 48);
  218.                                 F++;
  219.                                 i = 0;
  220.                                 break;
  221.                            
  222.                         }
  223.                         else
  224.                             return false;
  225.                     case 'B':
  226.                         if (F < sequence.Length && (sequence[F] == '7' || sequence[F] == '8'))
  227.                         {
  228.                            
  229.                                 S[i] = '0';
  230.                                 ReplaceChar(S, Convert.ToInt32(sequence[F]) - 48);
  231.                                 F++;
  232.                                 i = 0;
  233.                                 break;
  234.                            
  235.                         }
  236.                         else
  237.                             return false;
  238.                 }
  239.             }
  240.             return true;
  241.         }
  242.  
  243.         static void Main(string[] args)
  244.         {
  245.             Console.WriteLine("Enter 1 for manual mode\nEnter 2 for sequence mode");
  246.             var S = new StringBuilder("S");
  247.             char mode = Console.ReadKey().KeyChar;
  248.             if (mode == '1')
  249.             {
  250.                 var sequence = new StringBuilder("");
  251.                 Console.WriteLine("\nChoose Left (l) or Right (r): ");
  252.                 char direction = Console.ReadKey().KeyChar;
  253.                 switch (direction)
  254.                 {
  255.                     case 'l':
  256.                         Console.WriteLine("\nLeft output");
  257.                         S = grammar_outL(S, sequence);
  258.                         break;
  259.                     case 'r':
  260.                         Console.WriteLine("\nRight output");
  261.                         S = grammar_outR(S, sequence);
  262.                         break;
  263.                     default:
  264.                         Console.WriteLine("\nerror");
  265.                         break;
  266.                 }
  267.                 Console.WriteLine("Final word: " + S);
  268.                 Console.Write("Sequence: ");
  269.                 for (int i = 0; i < sequence.Length; i++)
  270.                 {
  271.                     Console.Write(sequence[i] + " ");
  272.                 }
  273.                 Console.WriteLine("\n\n" + Linear_Tree(sequence));
  274.             }
  275.             else if (mode == '2')
  276.             {
  277.                 Console.WriteLine("\nInput sequence: ");
  278.                 string sequence;
  279.                 sequence = Console.ReadLine();
  280.                 switch(output_possible(sequence, S))
  281.                 {
  282.                     case true: Console.WriteLine("Yes"); break;
  283.                     case false: Console.WriteLine("No"); break;
  284.                 }
  285.             }
  286.             else
  287.                 Console.WriteLine("error");
  288.            
  289.             Console.WriteLine("\nPress any key to exit");
  290.             Console.ReadLine();
  291.         }
  292.     }
  293. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement