daily pastebin goal
37%
SHARE
TWEET

Kamino Factory SoftUni

a guest Apr 16th, 2018 64 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. namespace Problem_2___Command_Interpreter
  2. {
  3.     using System;
  4.     using System.Collections.Generic;
  5.     using System.Linq;
  6.     using System.Text;
  7.     using System.Threading.Tasks;
  8.  
  9.  
  10.  
  11.  
  12.     public class Program
  13.     {
  14.         static void Main(string[] args)
  15.         {
  16.             int Lenght = int.Parse(Console.ReadLine());
  17.  
  18.             string read = Console.ReadLine();
  19.  
  20.             string[] sequence = new string[Lenght];
  21.  
  22.             List<string[]> Memory = new List<string[]>();
  23.  
  24.             string[] select = new string[Lenght]; var ones = 0; var longest = 0; var longestsubsequence = new Dictionary<int, int>(); var sample = -1;
  25.  
  26.             var leftindexsubsequence = new Dictionary<int, int>();
  27.             var LeftIndex = 0;
  28.  
  29.             var bestSum = 0;
  30.             var sum = 0;
  31.  
  32.             while (read != "Clone them!")
  33.             {
  34.                 sequence = read.Split(new char[] { '!' }, StringSplitOptions.RemoveEmptyEntries);
  35.                 Memory.Add(sequence);
  36.                 sample++;
  37.                 FindingTheLongestSubsequenceOfOnce(sequence, ref ones, ref longest, longestsubsequence, sample);
  38.                 if ((longestsubsequence.Values.Last().Equals(longestsubsequence.Values.First()) && longestsubsequence.Count > 1) || (longestsubsequence.Count>2 && longestsubsequence.Values.ElementAt(0)==longestsubsequence.Values.ElementAt(1)) || (longestsubsequence.Count > 2 && longestsubsequence.Values.ElementAt(0) == longestsubsequence.Values.ElementAt(2)) || (longestsubsequence.Count > 2 && longestsubsequence.Values.ElementAt(1) == longestsubsequence.Values.ElementAt(2)) )
  39.                 {
  40.                
  41.                     LeftIndex = FindingTheMostLeftIndexSubsequence(Memory, longestsubsequence, leftindexsubsequence, LeftIndex);
  42.  
  43.                    
  44.  
  45.                 }
  46.                 else if (longestsubsequence.Count>1)
  47.                 {
  48.                     var mostlongestONES = longestsubsequence.Values.OrderByDescending(x => x).Take(1).First();
  49.  
  50.                     for (int i = 0; i < longestsubsequence.Count; i++)
  51.                     {
  52.                         if (longestsubsequence.Values.ElementAt(i) < mostlongestONES)
  53.                         {
  54.                             longestsubsequence.Remove(i);
  55.                         }
  56.                     }
  57.                 }
  58.              
  59.  
  60.                
  61.  
  62.  
  63.                 if (leftindexsubsequence.Count > 1)
  64.                 {
  65.                     var mostLeftindex = leftindexsubsequence.Values.OrderBy(x => x).Take(1).First();
  66.  
  67.                     for (int i = 0; i < leftindexsubsequence.Count; i++)
  68.                     {
  69.                         if (leftindexsubsequence.Values.ElementAt(i) > mostLeftindex)
  70.                         {
  71.                             leftindexsubsequence.Remove(i);
  72.                         }
  73.                     }
  74.  
  75.                 }
  76.                
  77.                
  78.                 read = Console.ReadLine();
  79.             }
  80.  
  81.            
  82.  
  83.             if (leftindexsubsequence.Count>1)
  84.             {
  85.                 foreach (var item in leftindexsubsequence.Keys)
  86.                 {
  87.                     for (int i = 0; i < Memory[item].Length; i++)
  88.                     {
  89.                         if (Memory[item][i]=="1")
  90.                         {
  91.                             sum++;
  92.                         }
  93.                     }
  94.  
  95.                     if (sum>bestSum)
  96.                     {
  97.                         bestSum = sum;
  98.                         select = Memory[item];
  99.                            sample = item + 1;
  100.                     }
  101.                     sum = 0;
  102.                 }
  103.             }
  104.             else if (leftindexsubsequence.Count==1)
  105.             {
  106.                 for (int i = 0; i < Memory[leftindexsubsequence.First().Key].Length; i++)
  107.                 {
  108.                     if (Memory[leftindexsubsequence.First().Key][i]=="1")
  109.                     {
  110.                         bestSum++;
  111.                     }
  112.                 }
  113.  
  114.                 select = Memory[leftindexsubsequence.First().Key];
  115.                 sample = leftindexsubsequence.First().Key + 1;
  116.  
  117.             }
  118.  
  119.             if (longestsubsequence.Count == 1)
  120.             {
  121.                 for (int i = 0; i < Memory[longestsubsequence.First().Key].Length; i++)
  122.                 {
  123.                     if (Memory[longestsubsequence.First().Key][i] == "1")
  124.                     {
  125.                         bestSum++;
  126.                     }
  127.                 }
  128.  
  129.                 select = Memory[longestsubsequence.First().Key];
  130.                 sample = longestsubsequence.First().Key + 1;
  131.             }
  132.  
  133.  
  134.             Console.WriteLine($"Best DNA sample {sample} with sum: {bestSum}.");
  135.             Console.WriteLine(string.Join(" ", select));
  136.  
  137.  
  138.          
  139.         }
  140.  
  141.         private static int FindingTheMostLeftIndexSubsequence(List<string[]> Memory, Dictionary<int, int> longestsubsequence, Dictionary<int, int> leftindexsubsequence, int LeftIndex)
  142.         {
  143.             foreach (var item in longestsubsequence.Keys)
  144.             {
  145.  
  146.                 for (int i = 0; i < Memory[item].Length; i++)
  147.                 {
  148.                     if (Memory[item][i] == "1")
  149.                     {
  150.                         LeftIndex = i;
  151.  
  152.                         if (i > 0)
  153.                         {
  154.                             if (!leftindexsubsequence.ContainsValue(LeftIndex) && (Memory[item][i - 1] == "1") && i > 0)
  155.                             {
  156.                                 leftindexsubsequence[item] = LeftIndex - 1;
  157.                             }
  158.                             else if (Memory[item][i - 1] == "1")
  159.                             {
  160.                                 leftindexsubsequence[item] = LeftIndex - 1;
  161.                             }
  162.                         }
  163.  
  164.  
  165.  
  166.                     }
  167.  
  168.                 }
  169.             }
  170.  
  171.             return LeftIndex;
  172.         }
  173.  
  174.         private static void FindingTheLongestSubsequenceOfOnce(string[] sequence, ref int ones, ref int longest, Dictionary<int, int> longestsubsequence, int sample)
  175.         {
  176.             ones = 0;
  177.             for (int i = 0; i < sequence.Length; i++)
  178.             {
  179.                 if (sequence[i] == "1")
  180.                 {
  181.                     ones++;
  182.                 }
  183.                 else
  184.                 {
  185.                     ones = 0;
  186.                 }
  187.  
  188.                 if (ones >= longest)
  189.                 {
  190.                     longest = ones;
  191.                     if (!longestsubsequence.ContainsValue(longest))
  192.                     {
  193.                         longestsubsequence[sample] = longest;
  194.                     }
  195.                     else
  196.                     {
  197.                         longestsubsequence[sample] = longest;
  198.                     }
  199.                 }
  200.                
  201.  
  202.  
  203.             }
  204.         }
  205.     }
  206. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top