Advertisement
stanevplamen

02.09.02.04.Brackets

Jun 21st, 2013
114
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 16.58 KB | None | 0 0
  1. using System;
  2. using System.Text;
  3.  
  4.  
  5. class Brackets
  6. {
  7.     static void Main()
  8.     {
  9.         string input =  Console.ReadLine(); //"5"; //
  10.         int inputLength = int.Parse(input);
  11.         string separator =  Console.ReadLine(); // "...."; //
  12.         string[] inputText = new string[inputLength];
  13.  
  14.  
  15.         for (int i = 0; i < inputLength; i++)
  16.         {
  17.             inputText[i] = Console.ReadLine();
  18.         }
  19.         //inputText[0] = "using System;    namespace Stars";
  20.         //inputText[1] = "{class Program{";
  21.         //inputText[2] = "static    string[] separators ";
  22.         //inputText[3] = "= new string[] { \" \" };}";
  23.         //inputText[4] = "}";
  24.  
  25.         string formatedCode = TextFormat(inputText, separator);
  26.         Console.WriteLine(formatedCode);
  27.     }
  28.  
  29.     static string TextFormat(string[] inputText, string separator)
  30.     {
  31.         StringBuilder sb = new StringBuilder();
  32.         int counter = 0;
  33.         int separatorCounter = 0;
  34.         bool signOpen = false;
  35.         bool signClose = false;
  36.         bool signSpace = false;
  37.         bool signChar = false;
  38.         bool mizery = false;
  39.         foreach (string sentence in inputText)
  40.         {
  41.             int spaceCounter = 0;
  42.             for (int i = 0; i < sentence.Length; i++)
  43.             {
  44.                 char currentChar = sentence[i];
  45.                 if (i == 0 && counter == 0)
  46.                 {
  47.                     if (currentChar == '{')
  48.                     {
  49.                         signOpen = true;
  50.                     }
  51.                     else if (currentChar == '}')
  52.                     {
  53.                         signClose = true;
  54.                     }
  55.                     else if (currentChar == ' ')
  56.                     {
  57.                         signSpace = true;
  58.                     }
  59.                     else
  60.                     {
  61.                         signChar = true;
  62.                     }
  63.                 }
  64.  
  65.  
  66.                 if (currentChar == '{') // 1
  67.                 {                  
  68.                     spaceCounter = 0;
  69.  
  70.                     if (mizery == true)
  71.                     {
  72.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  73.                         {                                                   /// ///
  74.                             sb.Append(separator);                           /// ///
  75.                         }
  76.                         separatorCounter++;
  77.                         sb.Append("{");
  78.                         sb.AppendLine();
  79.                         signOpen = true;
  80.                         signClose = false;
  81.                         signSpace = false;
  82.                         signChar = false;
  83.                         mizery = false;
  84.                         continue;
  85.                     }
  86.  
  87.                     if (signOpen == true)
  88.                     {
  89.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  90.                         {                                                   /// ///
  91.                             sb.Append(separator);                           /// ///
  92.                         }
  93.                         separatorCounter++;
  94.                         sb.Append("{");
  95.                         sb.AppendLine();
  96.                         signOpen = true;
  97.                         signClose = false;
  98.                         signSpace = false;
  99.                         signChar = false;
  100.                         mizery = false;
  101.                         continue;
  102.                     }
  103.                     else if (signClose == true)
  104.                     {
  105.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  106.                         {                                                   /// ///
  107.                             sb.Append(separator);                           /// ///
  108.                         }
  109.                         separatorCounter++;
  110.                         sb.Append("{");
  111.                         sb.AppendLine();
  112.                         signOpen = true;
  113.                         signClose = false;
  114.                         signSpace = false;
  115.                         signChar = false;
  116.                         mizery = false;
  117.                         continue;
  118.                     }
  119.                     else if (signSpace == true)
  120.                     {
  121.                         sb.AppendLine();
  122.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  123.                         {                                                   /// ///
  124.                             sb.Append(separator);                           /// ///
  125.                         }
  126.                         separatorCounter++;
  127.                         sb.Append("{");
  128.                         sb.AppendLine();
  129.                         signOpen = true;
  130.                         signClose = false;
  131.                         signSpace = false;
  132.                         signChar = false;
  133.                         mizery = false;
  134.                         continue;
  135.                     }
  136.                     else if (signChar == true)
  137.                     {
  138.                         sb.AppendLine();
  139.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  140.                         {                                                   /// ///
  141.                             sb.Append(separator);                           /// ///
  142.                         }
  143.                         separatorCounter++;
  144.                         sb.Append("{");
  145.                         sb.AppendLine();
  146.                         signOpen = true;
  147.                         signClose = false;
  148.                         signSpace = false;
  149.                         signChar = false;
  150.                         mizery = false;
  151.                         continue;
  152.                     }
  153.  
  154.                 }
  155.  
  156.                 else if (currentChar == '}') // 2
  157.                 {
  158.                     spaceCounter = 0;
  159.  
  160.                     if (mizery == true)
  161.                     {
  162.                         separatorCounter--;
  163.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  164.                         {                                                   /// ///
  165.                             sb.Append(separator);                           /// ///
  166.                         }
  167.  
  168.                         sb.Append("}");
  169.                         sb.AppendLine();
  170.                         signOpen = false;
  171.                         signClose = true;
  172.                         signSpace = false;
  173.                         signChar = false;
  174.                         mizery = false;
  175.                         continue;
  176.                     }
  177.  
  178.                     if (signOpen == true)
  179.                     {
  180.                         separatorCounter--;
  181.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  182.                         {                                                   /// ///
  183.                             sb.Append(separator);                           /// ///
  184.                         }
  185.  
  186.                         sb.Append("}");
  187.                         sb.AppendLine();
  188.                         signOpen = false;
  189.                         signClose = true;
  190.                         signSpace = false;
  191.                         signChar = false;
  192.                         mizery = false;
  193.                         continue;
  194.                     }
  195.                     else if (signClose == true)
  196.                     {
  197.                         separatorCounter--;
  198.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  199.                         {                                                   /// ///
  200.                             sb.Append(separator);                           /// ///
  201.                         }
  202.                         sb.Append("}");
  203.                         sb.AppendLine();
  204.                         signOpen = false;
  205.                         signClose = true;
  206.                         signSpace = false;
  207.                         signChar = false;
  208.                         mizery = false;
  209.                         continue;
  210.                     }
  211.                     else if (signSpace == true)
  212.                     {
  213.                         sb.AppendLine();
  214.                         separatorCounter--;
  215.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  216.                         {                                                   /// ///
  217.                             sb.Append(separator);                           /// ///
  218.                         }
  219.                         sb.Append("}");
  220.                         sb.AppendLine();
  221.                         signOpen = false;
  222.                         signClose = true;
  223.                         signSpace = false;
  224.                         signChar = false;
  225.                         mizery = false;
  226.                         continue;
  227.                     }
  228.                     else if (signChar == true)
  229.                     {
  230.                         sb.AppendLine();
  231.                         separatorCounter--;
  232.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  233.                         {                                                   /// ///
  234.                             sb.Append(separator);                           /// ///
  235.                         }
  236.                         sb.Append("}");
  237.                         sb.AppendLine();
  238.                         signOpen = false;
  239.                         signClose = true;
  240.                         signSpace = false;
  241.                         signChar = false;
  242.                         mizery = false;
  243.                         continue;
  244.                     }
  245.  
  246.                 }
  247.  
  248.                 else if (currentChar == ' ') // 3
  249.                 {
  250.                     if (signOpen == true)
  251.                     {
  252.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  253.                         {                                                   /// ///
  254.                             sb.Append(separator);                           /// ///
  255.                         }
  256.  
  257.                         signOpen = false;
  258.                         signClose = false;
  259.                         signSpace = true;
  260.                         signChar = false;
  261.                         mizery = false;
  262.                         continue;
  263.                     }
  264.                     else if (signClose == true)
  265.                     {
  266.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  267.                         {                                                   /// ///
  268.                             sb.Append(separator);                           /// ///
  269.                         }
  270.  
  271.                         signOpen = false;
  272.                         signClose = false;
  273.                         signSpace = true;
  274.                         signChar = false;
  275.                         mizery = false;
  276.                         continue;
  277.                     }
  278.                     else if (signSpace == true)
  279.                     {
  280.                         if (spaceCounter >= 1)
  281.                         {
  282.                             spaceCounter++;
  283.  
  284.                             signOpen = false;
  285.                             signClose = false;
  286.                             signSpace = true;
  287.                             signChar = false;
  288.                             mizery = false;
  289.                             continue;
  290.                         }
  291.                         else
  292.                         {
  293.  
  294.                             spaceCounter++;
  295.  
  296.                             signOpen = false;
  297.                             signClose = false;
  298.                             signSpace = true;
  299.                             signChar = false;
  300.                             mizery = false;
  301.                             continue;
  302.                         }
  303.  
  304.                     }
  305.                     else if (signChar == true)
  306.                     {
  307.                         if (spaceCounter >= 1)
  308.                         {
  309.                             spaceCounter++;
  310.  
  311.                             signOpen = false;
  312.                             signClose = false;
  313.                             signSpace = true;
  314.                             signChar = false;
  315.                             mizery = false;
  316.                             continue;
  317.                         }
  318.                         else
  319.                         {
  320.                             sb.Append(' ');
  321.                             spaceCounter++;
  322.  
  323.                             signOpen = false;
  324.                             signClose = false;
  325.                             signSpace = true;
  326.                             signChar = false;
  327.                             mizery = false;
  328.                             continue;
  329.                         }
  330.                     }
  331.                     else if (mizery == true)
  332.                     {
  333.  
  334.                         continue;
  335.                     }
  336.                 }
  337.  
  338.                 else
  339.                 {
  340.                     spaceCounter = 0;
  341.                     if (signOpen == true)
  342.                     {
  343.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  344.                         {                                                   /// ///
  345.                             sb.Append(separator);                           /// ///
  346.                         }
  347.                         sb.Append(currentChar);
  348.  
  349.                         signOpen = false;
  350.                         signClose = false;
  351.                         signSpace = false;
  352.                         signChar = true;
  353.                         mizery = false;
  354.                         continue;
  355.                     }
  356.                     else if (signClose == true)
  357.                     {
  358.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  359.                         {                                                   /// ///
  360.                             sb.Append(separator);                           /// ///
  361.                         }
  362.                         sb.Append(currentChar);
  363.  
  364.                         signOpen = false;
  365.                         signClose = false;
  366.                         signSpace = false;
  367.                         signChar = true;
  368.                         mizery = false;
  369.                         continue;
  370.                     }
  371.                     else if (signSpace == true)
  372.                     {
  373.                         sb.Append(currentChar);
  374.  
  375.                         signOpen = false;
  376.                         signClose = false;
  377.                         signSpace = false;
  378.                         signChar = true;
  379.                         mizery = false;
  380.                         continue;
  381.                     }
  382.                     else if (signChar == true)
  383.                     {
  384.                         sb.Append(currentChar);
  385.                         signOpen = false;
  386.                         signClose = false;
  387.                         signSpace = false;
  388.                         signChar = true;
  389.                         mizery = false;
  390.                         continue;
  391.                     }
  392.                     else if (mizery == true)
  393.                     {
  394.                         for (int p = 0; p < separatorCounter; p++)          /// ///
  395.                         {                                                   /// ///
  396.                             sb.Append(separator);                           /// ///
  397.                         }
  398.                         sb.Append(currentChar);
  399.  
  400.                         signOpen = false;
  401.                         signClose = false;
  402.                         signSpace = false;
  403.                         signChar = true;
  404.                         mizery = false;
  405.                         continue;
  406.                     }
  407.                 }
  408.             }
  409.             if (mizery == true)
  410.             {
  411.                 continue;
  412.             }
  413.             if (signChar == true || signSpace == true)
  414.             {
  415.                 sb.AppendLine();
  416.                 mizery = true;
  417.                 signOpen = false;
  418.                 signClose = false;
  419.                 signSpace = false;
  420.                 signChar = false;
  421.             }
  422.             else if (signOpen == true || signClose == true)
  423.             {
  424.                 mizery = true;
  425.                 signOpen = false;
  426.                 signClose = false;
  427.                 signSpace = false;
  428.                 signChar = false;
  429.             }
  430.  
  431.             counter++;
  432.         }
  433.  
  434.         string output = sb.ToString();
  435.         return output;
  436.     }
  437. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement