daily pastebin goal
66%
SHARE
TWEET

Untitled

a guest Feb 19th, 2019 64 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace _3._427
  8. {
  9.     class Program
  10.     {
  11.         class tantárgy
  12.         {
  13.             public string név;
  14.             public int minpont;
  15.             public List<versenyző> versenyzők = new List<versenyző>();
  16.         }
  17.         static List<versenyző> unio(List<versenyző> a, List<versenyző> b)
  18.         {
  19.             List<versenyző> c = new List<versenyző>();
  20.             int i = 0; int j = 0;
  21.             while (i < a.Count && j < b.Count)
  22.             {
  23.                 if (a[i].név.CompareTo(b[j].név) < 0)
  24.                 {
  25.                     c.Add(a[i]);
  26.                     ++i;
  27.                 }
  28.                 else if (a[i].név.CompareTo(b[j].név) > 0)
  29.                 {
  30.                     c.Add(b[j]);
  31.                     ++j;
  32.                 }
  33.                 else
  34.                 {
  35.                     c.Add(a[i]);
  36.                     ++i;
  37.                     ++j;
  38.  
  39.                 }
  40.  
  41.  
  42.  
  43.  
  44.             }
  45.             while (i < a.Count)
  46.             {
  47.                 c.Add(a[i++]);
  48.             }
  49.             while (j < b.Count)
  50.             {
  51.                 c.Add(b[j++]);
  52.             }
  53.             return c;
  54.         }
  55.         class versenyző
  56.         {
  57.             public string név;
  58.             public int pont;
  59.         }
  60.         static void Main(string[] args)
  61.         {
  62.             System.IO.StreamReader f = new System.IO.StreamReader("03_427.txt", Encoding.Default);
  63.             List<tantárgy> x = new List<tantárgy>();
  64.  
  65.             while (!f.EndOfStream)
  66.             {
  67.                 string[] s = f.ReadLine().Split('\t');
  68.                 int n = int.Parse(s[0]);
  69.                 int m = int.Parse(s[1]);
  70.                 for (int i = 0; i < m; ++i)
  71.                 {
  72.                     s = f.ReadLine().Split('\t');
  73.                     x.Add(new tantárgy());
  74.                     x[x.Count - 1].név = s[0];
  75.                     x[x.Count - 1].minpont = int.Parse(s[1]);
  76.                 }
  77.                 for (int i = 0; i < m; ++i)
  78.                 {
  79.                     s = f.ReadLine().Split('\t');
  80.                     int l = int.Parse(s[1]);
  81.                     for (int j = 0; j < l; ++j)
  82.                     {
  83.                         s = f.ReadLine().Split('\t');
  84.                         versenyző v = new versenyző();
  85.                         v.név = s[0];
  86.                         v.pont = int.Parse(s[1]);
  87.                         x[i].versenyzők.Add(v);
  88.                     }
  89.                 }
  90.  
  91.  
  92.  
  93.             }
  94.             f.Close();
  95.             System.IO.StreamWriter w1 = new System.IO.StreamWriter("matematika_győztes.txt");
  96.             System.IO.StreamWriter w = new System.IO.StreamWriter("matematika.txt");
  97.             Console.WriteLine("0.1.feladat");
  98.             bool van = false;
  99.             int sum = 0;
  100.             int db = 0;
  101.             int max = 0;
  102.             for (int i = 0; i < x.Count; ++i)
  103.             {
  104.  
  105.                 if (x[i].név == "matematika")
  106.                 {
  107.                     van = true;
  108.                     for (int j = 0; j < x[i].versenyzők.Count; ++j)
  109.                     {
  110.                         sum += x[i].versenyzők[j].pont;
  111.                         if (x[i].versenyzők[j].pont < x[i].minpont)
  112.                             ++db;
  113.                         else
  114.                             w.WriteLine(x[i].versenyzők[j].név);
  115.                         if (x[i].versenyzők[j].pont > max)
  116.                             max = x[i].versenyzők[j].pont;
  117.                     }
  118.                     Console.WriteLine(1.0 * sum / x[i].versenyzők.Count);
  119.                     Console.WriteLine("0.3.feladat");
  120.                     Console.WriteLine(db);
  121.                     for (int k = 0; k < x[i].versenyzők.Count; ++k)
  122.                     {
  123.                         if (x[i].versenyzők[k].pont == max)
  124.                             w1.WriteLine(x[i].versenyzők[k].név);
  125.                     }
  126.                     break;
  127.                 }
  128.  
  129.             }
  130.             if (!van)
  131.                 Console.WriteLine("Nincs matematika");
  132.             w.Close();
  133.             w1.Close();
  134.             Console.WriteLine("0.7.feladat");
  135.             tantárgy matek = keres("matematika", x);
  136.             tantárgy infó = keres("informatika", x);
  137.             System.IO.StreamWriter w2 = new System.IO.StreamWriter("MatInf.txt");
  138.  
  139.             if (matek != null && infó != null)
  140.             {
  141.                 matek.versenyzők.Sort(cmpByNév);
  142.                 infó.versenyzők.Sort(cmpByNév);
  143.                 List<versenyző> matinf = new List<versenyző>();
  144.                 int i = 0, j = 0;
  145.                 while (i < matek.versenyzők.Count && j < infó.versenyzők.Count)
  146.                 {
  147.                     if (matek.versenyzők[i].név.CompareTo(infó.versenyzők[j].név) < 0)
  148.                         ++i;
  149.                     else if (matek.versenyzők[i].név.CompareTo(infó.versenyzők[j].név) > 0)
  150.                         ++j;
  151.                     else
  152.                     {
  153.                         if (matek.versenyzők[i].pont >= matek.minpont && infó.versenyzők[j].pont >= infó.minpont)
  154.                         {
  155.                             versenyző v = new versenyző();
  156.                             v.név = matek.versenyzők[i].név;
  157.                             v.pont = infó.versenyzők[j].pont + matek.versenyzők[i].pont;
  158.                             matinf.Add(v);
  159.                         }
  160.                         ++i;
  161.                         ++j;
  162.                     }
  163.                 }
  164.                 matinf.Sort(cmpByPointDesc);
  165.                 if (matinf.Count > 0)
  166.                 {
  167.                     max = matinf[0].pont;
  168.                     int k = 0;
  169.                     while (k < matinf.Count && matinf[k].pont == max)
  170.                     {
  171.                         w2.WriteLine(matinf[k].név + " " + matinf[k].pont);
  172.                         ++k;
  173.                     }
  174.                 }
  175.                 else
  176.                     Console.WriteLine("Nincs matinf...");
  177.             }
  178.             w2.Close();
  179.  
  180.  
  181.             foreach (tantárgy t in x)
  182.             {
  183.                 t.versenyzők.Sort(cmpByPointDesc);
  184.  
  185.                 System.IO.StreamWriter wr = new System.IO.StreamWriter(t.név + "Rangsor.txt");
  186.                 foreach (versenyző v in t.versenyzők)
  187.                     wr.WriteLine(v.név + " " + v.pont);
  188.                 wr.Close();
  189.             }
  190.  
  191.  
  192.             foreach (tantárgy t in x)
  193.             {
  194.                 t.versenyzők.Sort(cmpByNév);
  195.             }
  196.             List<versenyző> összetett = new List<versenyző>();
  197.             int[] index = new int[x.Count];
  198.             while (EgyikListánakSemÉrtemaVégére(x, index))
  199.             {
  200.                 string minnév = x[0].versenyzők[index[0]].név;
  201.                 for (int i = 1; i < x.Count; ++i)
  202.                 {
  203.                     if (x[i].versenyzők[index[i]].név.CompareTo(minnév) < 0)
  204.                         minnév = x[i].versenyzők[index[i]].név;
  205.                 }
  206.                 //Hány listába van benne a minnév, ahol elérte a minpontot(közben összegzés)
  207.                 db = 0;
  208.                 sum = 0;
  209.                 for (int i = 0; i < x.Count; ++i)
  210.                 {
  211.                     if (x[i].versenyzők[index[i]].név == minnév && x[i].versenyzők[index[i]].pont >= x[i].minpont)
  212.                     {
  213.                         ++db;
  214.                         sum += x[i].versenyzők[index[i]].pont;
  215.                     }
  216.                 }
  217.                 //Minden tantárgyba elérete-e a minpontot
  218.                 if (db == x.Count)
  219.                 {
  220.                     versenyző v = new versenyző();
  221.                     v.név = minnév;
  222.                     v.pont = sum;
  223.                     összetett.Add(v);
  224.                 }
  225.                 //Lista minden elemével lépünk egyet(index)
  226.                 for (int i = 0; i < x.Count; ++i)
  227.                 {
  228.                     if (x[i].versenyzők[index[i]].név == minnév)
  229.                     {
  230.                         ++index[i];
  231.                     }
  232.                 }
  233.             }
  234.             összetett.Sort(cmpByPointDesc);
  235.             w = new System.IO.StreamWriter("Összetettrangsor.txt");
  236.             foreach (versenyző i in összetett)
  237.                 w.WriteLine(i.név + " " + i.pont);
  238.             w.Close();
  239.  
  240.             db = 1;
  241.             foreach (tantárgy i in x)
  242.             {
  243.                 w = new System.IO.StreamWriter("v" + db + ".txt");
  244.                 foreach (versenyző j in i.versenyzők)
  245.                     w.WriteLine(j.név);
  246.                 ++db;
  247.                 w.Close();
  248.             }
  249.             //6,7,8
  250.             List<string> csakegyverseny = new List<string>();
  251.             List<versenyző> u = new List<versenyző>();
  252.             for (int i = 0; i < x.Count; ++i)
  253.             {
  254.                 u = unio(u, x[i].versenyzők);
  255.             }
  256.  
  257.             for (int i = 0; i < u.Count; ++i)
  258.             {
  259.                 db = 0;
  260.                 for (int j = 0; j < x.Count; ++j)
  261.                 {
  262.  
  263.                     for (int k = 0; k < x[j].versenyzők.Count; ++k)
  264.                     {
  265.                         if (u[i].név == x[j].versenyzők[k].név)
  266.                             ++db;
  267.                     }
  268.                 }
  269.                 if (db == 1)
  270.                     csakegyverseny.Add(u[i].név);
  271.             }
  272.  
  273.             w = new System.IO.StreamWriter("CsakEgyInduló.txt");
  274.             foreach (string i in csakegyverseny)
  275.                 w.WriteLine(i);
  276.             w.Close();
  277.             w = new System.IO.StreamWriter("ValamilyenVersenyenIndult.txt");
  278.             foreach (versenyző i in u)
  279.                 w.WriteLine(i.név);
  280.             List<string> elerteaminpontot = new List<string>();
  281.             w = new System.IO.StreamWriter("MinPont.txt");
  282.             for (int i = 0; i < u.Count; ++i)
  283.             {
  284.                 van = true;
  285.                 for (int j = 0; j < x.Count; ++j)
  286.                 {
  287.  
  288.                     for (int k = 0; k < x[j].versenyzők.Count; ++k)
  289.                     {
  290.                         if (u[i].név == x[j].versenyzők[k].név && x[j].versenyzők[k].pont < x[j].minpont)
  291.                         {
  292.                             van = false;
  293.  
  294.                         }
  295.                     }
  296.  
  297.                 }
  298.                 if (van)
  299.                     elerteaminpontot.Add(u[i].név);
  300.             }
  301.             foreach (string i in elerteaminpontot)
  302.                 w.WriteLine(i);
  303.             w.Close();
  304.  
  305.             w = new System.IO.StreamWriter("Győztesek.txt");
  306.             foreach(var i in x)
  307.             {
  308.                 w.WriteLine(i.név);
  309.                 max = -1;
  310.                 foreach(var j in i.versenyzők)
  311.                 {
  312.                     if (j.pont >= i.minpont && j.pont > max)
  313.                         max = j.pont;
  314.                 }
  315.                 foreach (var j in i.versenyzők)
  316.                 {
  317.                     if ( j.pont == max)
  318.                         w.WriteLine(j.név);
  319.                 }
  320.             }
  321.             w.Close();
  322.             Console.WriteLine("11.feladat");
  323.             List<versenyző> összetettgyőztesek = new List<versenyző>();
  324.             max = 0;
  325.             foreach(var i in összetett)
  326.             {
  327.                 if (i.pont > max)
  328.                     max = i.pont;
  329.             }
  330.             foreach (var i in összetett)
  331.             {
  332.                 if (i.pont == max)
  333.                     összetettgyőztesek.Add(i);
  334.             }
  335.             foreach(var ögy in összetettgyőztesek)
  336.             {
  337.                 bool minden = true;
  338.                 foreach (var i in x)
  339.                 {
  340.                     List<string> győztes = new List<string>();
  341.                     max = -1;
  342.                     foreach (var j in i.versenyzők)
  343.                     {
  344.                         if (j.pont >= i.minpont && j.pont > max)
  345.                             max = j.pont;
  346.                     }
  347.                     foreach (var j in i.versenyzők)
  348.                     {
  349.                         if (j.pont == max)
  350.                             győztes.Add(j.név);
  351.                     }
  352.                     if (!győztes.Contains(ögy.név))
  353.                         minden = false;
  354.                 }
  355.                 if(minden)
  356.                     Console.WriteLine(ögy.név);
  357.             }
  358.             Console.WriteLine("12.feladat");
  359.  
  360.             foreach (var ögy in összetettgyőztesek)
  361.             {
  362.                 van = false; ;
  363.                 foreach (var i in x)
  364.                 {
  365.                     List<string> győztes = new List<string>();
  366.                     max = -1;
  367.                     foreach (var j in i.versenyzők)
  368.                     {
  369.                         if (j.pont >= i.minpont && j.pont > max)
  370.                             max = j.pont;
  371.                     }
  372.                     foreach (var j in i.versenyzők)
  373.                     {
  374.                         if (j.pont == max)
  375.                             győztes.Add(j.név);
  376.                     }
  377.                     if (győztes.Contains(ögy.név))
  378.                         van = true;
  379.                 }
  380.                 if (van)
  381.                     Console.WriteLine(ögy.név);
  382.             }
  383.         }
  384.         static bool EgyikListánakSemÉrtemaVégére(List<tantárgy> x, int[] index)
  385.         {
  386.             bool minden = true;
  387.             for (int i = 0; i < x.Count; ++i)
  388.             {
  389.                 if (index[i] >= x[i].versenyzők.Count)
  390.                     minden = false;
  391.             }
  392.             return minden;
  393.         }
  394.         static int cmpByNév(versenyző a, versenyző b)
  395.         {
  396.             return a.név.CompareTo(b.név);
  397.         }
  398.         static int cmpByPointDesc(versenyző a, versenyző b)
  399.         {
  400.             return -a.pont.CompareTo(b.pont);
  401.         }
  402.         static tantárgy keres(string név, List<tantárgy> x)
  403.         {
  404.             foreach (tantárgy t in x)
  405.                 if (t.név == név)
  406.                     return t;
  407.             return null;
  408.         }
  409.     }
  410. }
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