Advertisement
Guest User

Untitled

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