Advertisement
silvana1303

array manipulator

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