krasizorbov

Array Manipulator

Mar 5th, 2019
169
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 12.79 KB | None | 0 0
  1. using System;
  2. using System.Linq;
  3. using System.Collections.Generic;
  4.  
  5. namespace AM
  6. {
  7.     class Program
  8.     {
  9.         static void Main(string[] args)
  10.         {
  11.             List<int> arr = Console.ReadLine().Split().Select(int.Parse).ToList();
  12.  
  13.             while (true)
  14.             {
  15.                 string[] input = Console.ReadLine().Split();
  16.                 if (input[0] == "end")
  17.                 {
  18.                     break;
  19.                 }
  20.                 else
  21.                 {
  22.                     if (input[0] == "exchange")
  23.                     {
  24.                         int index = int.Parse(input[1]);
  25.                         if (index < 0 || index >= arr.Count)
  26.                         {
  27.                             Console.WriteLine("Invalid index");
  28.                             continue;
  29.                         }
  30.                         else
  31.                         {
  32.                             List<int> temp = new List<int>();
  33.                             temp = arr.Take(index + 1).ToList();
  34.                             arr.RemoveRange(0, index + 1);
  35.                             arr = arr.Concat(temp).ToList();
  36.                         }
  37.                     }
  38.                     else if (input[0] == "max")
  39.                     {
  40.                         if (input[1] == "even")
  41.                         {
  42.                             List<int> temp = new List<int>();
  43.                             int counter = 0;
  44.                             for (int i = 0; i < arr.Count; i++)
  45.                             {
  46.                                 if (arr[i] % 2 == 0)
  47.                                 {
  48.                                     temp.Add(arr[i]);
  49.                                 }
  50.                                 else
  51.                                 {
  52.                                     counter++;
  53.                                 }
  54.                             }
  55.                             if (counter == arr.Count)
  56.                             {
  57.                                 Console.WriteLine("No matches");
  58.                             }
  59.                             else
  60.                             {
  61.                                 int index = temp.Max();
  62.                                 Console.WriteLine(arr.LastIndexOf(index));
  63.                             }
  64.                            
  65.                         }
  66.                         else if (input[1] == "odd")
  67.                         {
  68.                             List<int> temp = new List<int>();
  69.                             int counter = 0;
  70.                             for (int i = 0; i < arr.Count; i++)
  71.                             {
  72.                                 if (arr[i] % 2 != 0)
  73.                                 {
  74.                                     temp.Add(arr[i]);
  75.                                 }
  76.                                 else
  77.                                 {
  78.                                     counter++;
  79.                                 }
  80.                             }
  81.                             if (counter == arr.Count)
  82.                             {
  83.                                 Console.WriteLine("No matches");
  84.                             }
  85.                             else
  86.                             {
  87.                                 int index = temp.Max();
  88.                                 Console.WriteLine(arr.LastIndexOf(index));
  89.                             }
  90.  
  91.                         }
  92.                     }
  93.                     else if (input[0] == "min")
  94.                     {
  95.                         if (input[1] == "even")
  96.                         {
  97.                             List<int> temp = new List<int>();
  98.                             int counter = 0;
  99.                             for (int i = 0; i < arr.Count; i++)
  100.                             {
  101.                                 if (arr[i] % 2 == 0)
  102.                                 {
  103.                                     temp.Add(arr[i]);
  104.                                 }
  105.                                 else
  106.                                 {
  107.                                     counter++;
  108.                                 }
  109.                             }
  110.                             if (counter == arr.Count)
  111.                             {
  112.                                 Console.WriteLine("No matches");
  113.                             }
  114.                             else
  115.                             {
  116.                                 int index = temp.Min();
  117.                                 Console.WriteLine(arr.LastIndexOf(index));
  118.                             }
  119.  
  120.                         }
  121.                         else if (input[1] == "odd")
  122.                         {
  123.                             List<int> temp = new List<int>();
  124.                             int counter = 0;
  125.                             for (int i = 0; i < arr.Count; i++)
  126.                             {
  127.                                 if (arr[i] % 2 != 0)
  128.                                 {
  129.                                     temp.Add(arr[i]);
  130.                                 }
  131.                                 else
  132.                                 {
  133.                                     counter++;
  134.                                 }
  135.                             }
  136.                             if (counter == arr.Count)
  137.                             {
  138.                                 Console.WriteLine("No matches");
  139.                             }
  140.                             else
  141.                             {
  142.                                 int index = temp.Min();
  143.                                 Console.WriteLine(arr.LastIndexOf(index));
  144.                             }
  145.  
  146.                         }
  147.                     }
  148.                     else if (input[0] == "first")
  149.                     {
  150.                         int count = int.Parse(input[1]);
  151.                         if (input[2] == "even")
  152.                         {
  153.                             if (count > arr.Count || count < 0)
  154.                             {
  155.                                 Console.WriteLine("Invalid count");
  156.                                 continue;
  157.                             }
  158.                             else
  159.                             {
  160.                                 List<int> temp = new List<int>();
  161.                                 for (int i = 0; i < arr.Count; i++)
  162.                                 {  
  163.                                     if (arr[i] % 2 == 0)
  164.                                     {
  165.                                         temp.Add(arr[i]);
  166.                                         if (count == temp.Count)
  167.                                         {
  168.                                             break;
  169.                                         }
  170.                                     }
  171.                                 }
  172.                                 if (temp.Count == 0)
  173.                                 {
  174.                                     Console.WriteLine("[]");
  175.                                 }
  176.                                 else if (temp.Count == 1)
  177.                                 {
  178.                                     Console.WriteLine($"[{temp[0]}]");
  179.                                 }
  180.                                 else if (temp.Count > 1)
  181.                                 {
  182.                                     Console.WriteLine("[" + string.Join(", ",temp.Take(temp.Count)) + "]");
  183.                                 }
  184.                             }
  185.                         }
  186.                         else if (input[2] == "odd")
  187.                         {
  188.                             if (count > arr.Count || count < 0)
  189.                             {
  190.                                 Console.WriteLine("Invalid count");
  191.                                 continue;
  192.                             }
  193.                             else
  194.                             {
  195.                                 List<int> temp = new List<int>();
  196.                                 for (int i = 0; i < arr.Count; i++)
  197.                                 {
  198.                                     if (arr[i] % 2 != 0)
  199.                                     {
  200.                                         temp.Add(arr[i]);
  201.                                         if (count == temp.Count)
  202.                                         {
  203.                                             break;
  204.                                         }
  205.                                     }
  206.                                 }
  207.                                 if (temp.Count == 0)
  208.                                 {
  209.                                     Console.WriteLine("[]");
  210.                                 }
  211.                                 else if (temp.Count == 1)
  212.                                 {
  213.                                     Console.WriteLine($"[{temp[0]}]");
  214.                                 }
  215.                                 else if (temp.Count > 1)
  216.                                 {
  217.                                     Console.WriteLine("[" + string.Join(", ", temp.Take(temp.Count)) + "]");
  218.                                 }
  219.                             }
  220.                         }
  221.  
  222.                     }
  223.                     else if (input[0] == "last")
  224.                     {
  225.                         int count = int.Parse(input[1]);
  226.                         if (input[2] == "even")
  227.                         {
  228.                             if (count > arr.Count || count < 0)
  229.                             {
  230.                                 Console.WriteLine("Invalid count");
  231.                                 continue;
  232.                             }
  233.                             else
  234.                             {
  235.                                 List<int> temp = new List<int>();
  236.                                 for (int i = arr.Count - 1; i > -1; i--)
  237.                                 {
  238.                                     if (arr[i] % 2 == 0)
  239.                                     {
  240.                                         temp.Add(arr[i]);
  241.                                         if (count == temp.Count)
  242.                                         {
  243.                                             break;
  244.                                         }
  245.                                     }
  246.                                 }
  247.                                 temp.Reverse();
  248.                                 if (temp.Count == 0)
  249.                                 {
  250.                                     Console.WriteLine("[]");
  251.                                 }
  252.                                 else if (temp.Count == 1)
  253.                                 {
  254.                                     Console.WriteLine($"[{temp[0]}]");
  255.                                 }
  256.                                 else if (temp.Count > 1)
  257.                                 {
  258.                                     Console.WriteLine("[" + string.Join(", ", temp.Take(temp.Count)) + "]");
  259.                                 }
  260.                             }
  261.                         }
  262.                         else if (input[2] == "odd")
  263.                         {
  264.                             if (count > arr.Count || count < 0)
  265.                             {
  266.                                 Console.WriteLine("Invalid count");
  267.                                 continue;
  268.                             }
  269.                             else
  270.                             {
  271.                                 List<int> temp = new List<int>();
  272.                                 for (int i = arr.Count - 1; i > -1; i--)
  273.                                 {
  274.                                     if (arr[i] % 2 != 0)
  275.                                     {
  276.                                         temp.Add(arr[i]);
  277.                                         if (count == temp.Count)
  278.                                         {
  279.                                             break;
  280.                                         }
  281.                                     }
  282.                                 }
  283.                                 temp.Reverse();
  284.                                 if (temp.Count == 0)
  285.                                 {
  286.                                     Console.WriteLine("[]");
  287.                                 }
  288.                                 else if (temp.Count == 1)
  289.                                 {
  290.                                     Console.WriteLine($"[{temp[0]}]");
  291.                                 }
  292.                                 else if (temp.Count > 1)
  293.                                 {
  294.                                    
  295.                                     Console.WriteLine("[" + string.Join(", ", temp.Take(temp.Count)) + "]");
  296.                                 }
  297.                             }
  298.                         }
  299.                     }
  300.                 }
  301.             }// while loop ends here.
  302.             Console.Write("[" + string.Join(", ", arr) + "]");
  303.         }//Main method ends here.
  304.     }
  305. }
Advertisement
Add Comment
Please, Sign In to add comment