Croustys

xd

Sep 16th, 2020
606
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.IO;
  4.  
  5. namespace Prog_Tetelek
  6. {
  7.     class Program
  8.     {
  9.         static void Clear()
  10.         {
  11.             Console.Clear();
  12.         }
  13.         static void File_Name_Text()
  14.         {
  15.             Console.WriteLine("Adja meg a file nevét! (nev.txt)");
  16.         }
  17.         static void FileHossza()
  18.         {
  19.             Console.WriteLine("Adja meg a file hosszát!");
  20.         }
  21.  
  22.         static void SorozatSzamitas()
  23.         {
  24.             Clear();
  25.  
  26.             Console.WriteLine("Fileból vagy saját számból szeretné a sorozatszámítást? (csak a számot írja be, pont nélkül!)");
  27.             Console.WriteLine("1. File\n2. Saját");
  28.  
  29.             int answer = int.Parse(Console.ReadLine());
  30.  
  31.             if (answer == 1) SorozatSzamitas_File();
  32.             else SorozatSzamitas_Sajat();
  33.  
  34.             void SorozatSzamitas_Sajat()
  35.             {
  36.                 Clear();
  37.                 Console.WriteLine("Hány darab számot szeretne összeadni?");
  38.                 int amount = int.Parse(Console.ReadLine());
  39.  
  40.                 int osszeg = 0;
  41.                 for (int i = 0; i < amount; i++)
  42.                 {
  43.                     Clear();
  44.                     Console.WriteLine($"{ i + 1 }. szám:");
  45.                     osszeg += int.Parse(Console.ReadLine());
  46.                 }
  47.  
  48.                 Clear();
  49.                 Console.WriteLine($"A számok összege: {osszeg}");
  50.             }
  51.             void SorozatSzamitas_File()
  52.             {
  53.                 Clear();
  54.                 File_Name_Text();
  55.  
  56.                 string choice = Console.ReadLine();
  57.  
  58.                 StreamReader sr = new StreamReader(choice);
  59.  
  60.                 int osszeg = 0;
  61.  
  62.                 while (!sr.EndOfStream)
  63.                 {
  64.                     osszeg += int.Parse(sr.ReadLine());
  65.                 }
  66.                 sr.Close();
  67.  
  68.                 Clear();
  69.                 Console.WriteLine($"A számok összege: {osszeg}");
  70.             }
  71.             Redirect();
  72.         }
  73.         static void Eldontes()
  74.         {
  75.             Clear();
  76.             Console.WriteLine("Számot vagy szöveget szeretne eldönteni?");
  77.             Console.WriteLine("1. Szám\n2. Szöveg");
  78.  
  79.             bool num = int.Parse(Console.ReadLine()) == 1;
  80.  
  81.             Clear();
  82.  
  83.             File_Name_Text();
  84.  
  85.             string name = Console.ReadLine();
  86.             int c = 0;
  87.  
  88.             Clear();
  89.             FileHossza();
  90.  
  91.             int l = int.Parse(Console.ReadLine());
  92.  
  93.             int[] ar = new int[l];
  94.             string[] sAr = new string[l];
  95.  
  96.             StreamReader sr = new StreamReader(name);
  97.  
  98.  
  99.             while (!sr.EndOfStream)
  100.             {
  101.                 if (num)
  102.                 {
  103.                     ar[c] = int.Parse(sr.ReadLine());
  104.                 }
  105.                 else
  106.                 {
  107.                     sAr[c] = sr.ReadLine();
  108.                 }
  109.  
  110.                 c++;
  111.             }
  112.             sr.Close();
  113.  
  114.             Clear();
  115.             Console.WriteLine("Mit szeretne eldönteni, hogy van-e?");
  116.  
  117.             int keresett = 0;
  118.             string search = "";
  119.  
  120.             if (num)
  121.             {
  122.                 keresett = int.Parse(Console.ReadLine());
  123.             }
  124.             else
  125.             {
  126.                 search = Console.ReadLine();
  127.             }
  128.  
  129.             bool van = false;
  130.  
  131.             for (int i = 0; i < c; i++)
  132.             {
  133.                 if (num)
  134.                 {
  135.                     if (ar[i] == keresett)
  136.                     {
  137.                         van = true;
  138.                     }
  139.                 }
  140.                 else
  141.                 {
  142.                     if (sAr[i] == search) van = true;
  143.                 }
  144.             }
  145.  
  146.             Clear();
  147.  
  148.             string ki = van ? "Megtalálható a tömbben!" : "Nem található a tömbben!";
  149.             Console.WriteLine(ki);
  150.  
  151.             Redirect();
  152.         }
  153.         static void Kivalasztas()
  154.         {
  155.             Clear();
  156.             Console.WriteLine("Szám vagy Szöveget szeretne kiválasztani?");
  157.             Console.WriteLine("1. Szám\n2. Szöveg");
  158.  
  159.             bool num = int.Parse(Console.ReadLine()) == 1;
  160.  
  161.             Clear();
  162.  
  163.             File_Name_Text();
  164.             string name = Console.ReadLine();
  165.             int c = 0;
  166.  
  167.             Clear();
  168.  
  169.             FileHossza();
  170.             int l = int.Parse(Console.ReadLine());
  171.  
  172.             int[] ar = new int[l];
  173.             string[] sAr = new string[l];
  174.  
  175.             StreamReader sr = new StreamReader(name);
  176.  
  177.             while (!sr.EndOfStream)
  178.             {
  179.                 if (num)
  180.                 {
  181.                     ar[c] = int.Parse(sr.ReadLine());
  182.                 }
  183.                 else
  184.                 {
  185.                     sAr[c] = sr.ReadLine();
  186.                 }
  187.  
  188.                 c++;
  189.             }
  190.             sr.Close();
  191.  
  192.             Clear();
  193.  
  194.             int v = 0;
  195.             char va = ' ';
  196.             if (num)
  197.             {
  198.                 Console.WriteLine("Melyik számmal osztható számot szeretné kiválasztani elsőnek?");
  199.                 v = int.Parse(Console.ReadLine());
  200.             }
  201.             else
  202.             {
  203.                 Console.WriteLine("Melyik betűvel kezdődő szót szeretné elsőnek kiválasztani?");
  204.                 va = char.Parse(Console.ReadLine());
  205.             }
  206.  
  207.             int index = -1;
  208.             string sIndex = "";
  209.  
  210.             bool firstNum = false;
  211.             bool firstString = false;
  212.  
  213.             for (int i = 0; i < c; i++)
  214.             {
  215.                 if (num)
  216.                 {
  217.                     if (ar[i] % v == 0 && !firstNum)
  218.                     {
  219.                         index = ar[i];
  220.                         firstNum = true;
  221.                     }
  222.                 }
  223.                 else
  224.                 {
  225.                     if (sAr[i][0] == va && !firstString)
  226.                     {
  227.                         sIndex = sAr[i];
  228.                         firstString = true;
  229.                     }
  230.                 }
  231.             }
  232.  
  233.             string ki = num ? $"{index} az első szám amely osztható a számmal ({v})" : $"{sIndex} az első szó ami a betűvel kezdődik. ({va})";
  234.             Console.WriteLine(ki);
  235.             Redirect();
  236.         }
  237.         static void Kereses()
  238.         {
  239.             Clear();
  240.  
  241.             Console.WriteLine("Rendezett vagy rendezettlen tömbben szeretne keresni?");
  242.             Console.WriteLine("1. rendezett\n2. rendezetlen");
  243.  
  244.             int answer = int.Parse(Console.ReadLine());
  245.  
  246.             Clear();
  247.  
  248.             Console.WriteLine("Számot vagy Szöveget akar keresni?");
  249.             Console.WriteLine("1. Szám\n2. Szöveg");
  250.  
  251.             bool szam = int.Parse(Console.ReadLine()) == 1;
  252.  
  253.             if (answer == 1) Rendezett_File(szam);
  254.             else if (answer == 2) nemRendezett_File(szam);
  255.  
  256.             Redirect();
  257.  
  258.             void Rendezett_File(bool num)
  259.             {
  260.                 Clear();
  261.                 File_Name_Text();
  262.  
  263.                 string name = Console.ReadLine();
  264.  
  265.                 Clear();
  266.                 FileHossza();
  267.                 int l = int.Parse(Console.ReadLine());
  268.  
  269.                 StreamReader sr = new StreamReader(name);
  270.  
  271.                 int[] ar = new int[l];
  272.                 string[] sAr = new string[l];
  273.                 int c = 0;
  274.  
  275.                 while (!sr.EndOfStream)
  276.                 {
  277.                     if (num)
  278.                     {
  279.                         ar[c] = int.Parse(sr.ReadLine());
  280.                     }
  281.                     else
  282.                     {
  283.                         sAr[c] = sr.ReadLine();
  284.                     }
  285.  
  286.                     c++;
  287.                 }
  288.                 sr.Close();
  289.  
  290.                 string stringOrInt = num ? "Számot" : "Szót";
  291.  
  292.                 Clear();
  293.  
  294.                 Console.WriteLine($"Milyen {stringOrInt} szeretne keresni?");
  295.  
  296.  
  297.                 int keresett = 0;
  298.                 string search = "";
  299.  
  300.                 if (num)
  301.                 {
  302.                     keresett = int.Parse(Console.ReadLine());
  303.                 }
  304.                 else
  305.                 {
  306.                     search = Console.ReadLine();
  307.                 }
  308.  
  309.                 int j = 0;
  310.  
  311.                 if (num)
  312.                 {
  313.  
  314.                     while (j < c && ar[j] != keresett)
  315.                     {
  316.                         j++;
  317.                     }
  318.                 }
  319.                 else
  320.                 {
  321.                     while (j < c && sAr[j] != search)
  322.                     {
  323.                         j++;
  324.                     }
  325.                 }
  326.                 int index = j + 1;
  327.  
  328.                 if (index > -1)
  329.                 { Console.WriteLine($"A {index}. helyen található a keresett elem!"); }
  330.                 else Console.WriteLine("A keresett elem nem található a file-ban!");
  331.             }
  332.             void nemRendezett_File(bool num)
  333.             {
  334.                 Clear();
  335.                 File_Name_Text();
  336.  
  337.                 string name = Console.ReadLine();
  338.  
  339.                 FileHossza();
  340.                 int l = int.Parse(Console.ReadLine());
  341.  
  342.                 int[] ar = new int[l];
  343.                 string[] sAr = new string[l];
  344.  
  345.                 int c = 0;
  346.  
  347.                 StreamReader sr = new StreamReader(name);
  348.  
  349.                 while (!sr.EndOfStream)
  350.                 {
  351.                     if (num)
  352.                     {
  353.                         ar[c] = int.Parse(sr.ReadLine());
  354.                     }
  355.                     else
  356.                     {
  357.                         sAr[c] = sr.ReadLine();
  358.                     }
  359.  
  360.                     c++;
  361.                 }
  362.                 sr.Close();
  363.  
  364.                 string stringOrInt = num ? "Számot" : "Szót";
  365.  
  366.                 Console.WriteLine($"Milyen {stringOrInt} szeretne keresni?");
  367.  
  368.                 int j = 0;
  369.  
  370.                 int keresett = -1;
  371.                 string search = "";
  372.  
  373.                 int index = -1;
  374.  
  375.                 if (num)
  376.                 {
  377.                     keresett = int.Parse(Console.ReadLine());
  378.                 }
  379.                 else
  380.                 {
  381.                     search = Console.ReadLine();
  382.                 }
  383.  
  384.                 bool talalt = false;
  385.                 while (j < c && !talalt)
  386.                 {
  387.                     if (num)
  388.                     {
  389.                         if (ar[j] == keresett)
  390.                         {
  391.                             index = j;
  392.                             talalt = true;
  393.                         }
  394.                     }
  395.                     else
  396.                     {
  397.                         if (sAr[j] == search)
  398.                         {
  399.                             index = j;
  400.                             talalt = true;
  401.                         }
  402.                     }
  403.                     j++;
  404.                 }
  405.  
  406.                 if (index != -1)
  407.                 { Console.WriteLine($"A {index + 1}. helyen található a keresett elem!"); }
  408.                 else Console.WriteLine("A keresett elem nem található a file-ban!");
  409.             }
  410.         }
  411.         static void Megszamolas()
  412.         {
  413.             Clear();
  414.             Console.WriteLine("Számot vagy Szöveget szeretne megszámolni?");
  415.             Console.WriteLine("1. Szám\n2. Szöveg");
  416.  
  417.             bool num = int.Parse(Console.ReadLine()) == 1;
  418.  
  419.             Clear();
  420.  
  421.             File_Name_Text();
  422.             string name = Console.ReadLine();
  423.  
  424.             Clear();
  425.  
  426.             FileHossza();
  427.             int l = int.Parse(Console.ReadLine());
  428.  
  429.             int[] ar = new int[l];
  430.             string[] sAr = new string[l];
  431.             int c = 0;
  432.  
  433.             StreamReader sr = new StreamReader(name);
  434.  
  435.             while (!sr.EndOfStream)
  436.             {
  437.                 if (num)
  438.                 {
  439.                     ar[c] = int.Parse(sr.ReadLine());
  440.                 }
  441.                 else
  442.                 {
  443.                     sAr[c] = sr.ReadLine();
  444.                 }
  445.  
  446.                 c++;
  447.             }
  448.             sr.Close();
  449.  
  450.             Clear();
  451.  
  452.             string sz = num ? "Számot" : "Szöveget";
  453.             Console.WriteLine($"Melyik {sz} szeretné megszámolni?");
  454.  
  455.             int n = 0;
  456.             string s = "";
  457.  
  458.             if (num) n = int.Parse(Console.ReadLine());
  459.             else s = Console.ReadLine();
  460.  
  461.             int nCounter = 0;
  462.             int sCounter = 0;
  463.  
  464.             for (int i = 0; i < c; i++)
  465.             {
  466.                 if (ar[i] == n) { nCounter++; }
  467.                 else if (sAr[i] == s) { sCounter++; }
  468.             }
  469.  
  470.             string ki = num ? $"{nCounter} alkalommal található meg ({n})" : $"{sCounter} alkalommal található meg ({s})";
  471.             Console.WriteLine(ki);
  472.             Redirect();
  473.         }
  474.         static void MaxValaszt()
  475.         {
  476.             Clear();
  477.             File_Name_Text();
  478.  
  479.             string name = Console.ReadLine();
  480.  
  481.             Clear();
  482.             FileHossza();
  483.             int l = int.Parse(Console.ReadLine());
  484.  
  485.             int[] ar = new int[l];
  486.             int c = 0;
  487.             StreamReader sr = new StreamReader(name);
  488.  
  489.             while (!sr.EndOfStream)
  490.             {
  491.                 ar[c] = int.Parse(sr.ReadLine());
  492.  
  493.                 c++;
  494.             }
  495.             sr.Close();
  496.  
  497.             int max = ar[0];
  498.             int index = 0;
  499.  
  500.             for (int i = 0; i < c; i++)
  501.             {
  502.                 if (max < ar[i])
  503.                 {
  504.                     max = ar[i];
  505.                     index = i;
  506.                 }
  507.             }
  508.             Console.WriteLine($"{max} a legnagyobb érték a file-ban, és a {index + 1}. helyen található!");
  509.             Redirect();
  510.         }
  511.  
  512.         static void Masolas()
  513.         {
  514.             Clear();
  515.  
  516.             File_Name_Text();
  517.             string name = Console.ReadLine();
  518.             int c = 0;
  519.  
  520.             Clear();
  521.  
  522.             FileHossza();
  523.             int l = int.Parse(Console.ReadLine());
  524.  
  525.             int[] ar = new int[l];
  526.  
  527.             StreamReader sr = new StreamReader(name);
  528.  
  529.             while (!sr.EndOfStream)
  530.             {
  531.                 ar[c] = int.Parse(sr.ReadLine());
  532.                 c++;
  533.             }
  534.             sr.Close();
  535.  
  536.             Clear();
  537.  
  538.             int[] newArr = new int[c];
  539.             for (int i = 0; i < c; i++)
  540.             {
  541.                 newArr[i] = ar[i] - 2;
  542.             }
  543.             Console.WriteLine("Eredeti tömb -> Másolat, ahol minden elemből kivontunk 2-t.");
  544.             for (int i = 0; i < c; i++)
  545.             {
  546.                 Console.WriteLine($"{ar[i]} -> {newArr[i]}");
  547.             }
  548.             Redirect();
  549.         }
  550.         static void Kivalogatas()
  551.         {
  552.             Clear();
  553.             Console.WriteLine("Szám vagy Szöveget szeretne kiválogatni?");
  554.             Console.WriteLine("1. Szám\n2. Szöveg");
  555.  
  556.             bool num = int.Parse(Console.ReadLine()) == 1;
  557.  
  558.             Clear();
  559.  
  560.             File_Name_Text();
  561.             string name = Console.ReadLine();
  562.             int c = 0;
  563.  
  564.             Clear();
  565.  
  566.             FileHossza();
  567.             int l = int.Parse(Console.ReadLine());
  568.  
  569.             int[] ar = new int[l];
  570.             string[] sAr = new string[l];
  571.  
  572.             StreamReader sr = new StreamReader(name);
  573.  
  574.             while (!sr.EndOfStream)
  575.             {
  576.                 if (num)
  577.                 {
  578.                     ar[c] = int.Parse(sr.ReadLine());
  579.                 }
  580.                 else
  581.                 {
  582.                     sAr[c] = sr.ReadLine();
  583.                 }
  584.  
  585.                 c++;
  586.             }
  587.             sr.Close();
  588.  
  589.             Clear();
  590.  
  591.             if (num)
  592.             {
  593.                 Console.WriteLine("Mekkora számnál szeretne kisebbeket kiválogatni?");
  594.                 int ans = int.Parse(Console.ReadLine());
  595.  
  596.                 List<int> list = new List<int>();
  597.  
  598.                 for (int i = 0; i < c; i++)
  599.                 {
  600.                     if (ar[i] < ans)
  601.                     {
  602.                         list.Add(ar[i]);
  603.                     }
  604.                 }
  605.  
  606.                 Clear();
  607.                 Console.WriteLine($"A következő számok lettek kiválogatva, melyek kisebbek mint {ans}");
  608.                 foreach (int i in list)
  609.                 {
  610.                     Console.WriteLine(i);
  611.                 }
  612.             }
  613.             else
  614.             {
  615.                 Console.WriteLine("Milyen betűvel kezdődő szavakat szeretne kiválogatni?");
  616.                 char ans = char.Parse(Console.ReadLine());
  617.  
  618.                 List<string> list = new List<string>();
  619.  
  620.                 for (int i = 0; i < c; i++)
  621.                 {
  622.                     if (sAr[i][0] == ans)
  623.                     {
  624.                         list.Add(sAr[i]);
  625.                     }
  626.                 }
  627.  
  628.                 Clear();
  629.                 Console.WriteLine($"A következő Szavak lettek kiválogatva, melyek {ans} betűvel kezdődnek.");
  630.  
  631.                 foreach (string i in list)
  632.                 {
  633.                     Console.WriteLine(i);
  634.                 }
  635.             }
  636.             Redirect();
  637.         }
  638.         static void Szetvalogatas()
  639.         {
  640.             Clear();
  641.  
  642.             File_Name_Text();
  643.             string name = Console.ReadLine();
  644.             int c = 0;
  645.  
  646.             Clear();
  647.  
  648.             FileHossza();
  649.             int l = int.Parse(Console.ReadLine());
  650.  
  651.             int[] ar = new int[l];
  652.             string[] sAr = new string[l];
  653.  
  654.             StreamReader sr = new StreamReader(name);
  655.  
  656.             while (!sr.EndOfStream)
  657.             {
  658.                 ar[c] = int.Parse(sr.ReadLine());
  659.                 c++;
  660.             }
  661.             sr.Close();
  662.  
  663.             Clear();
  664.  
  665.             List<int> paros = new List<int>();
  666.             List<int> ptlan = new List<int>();
  667.  
  668.             for (int i = 0; i < c; i++)
  669.             {
  670.                 if (ar[i] % 2 == 0)
  671.                 {
  672.                     paros.Add(ar[i]);
  673.                 }
  674.                 else
  675.                 {
  676.                     ptlan.Add(ar[i]);
  677.                 }
  678.             }
  679.  
  680.             Clear();
  681.  
  682.             Console.WriteLine("Páros, illetve páratlan számok szétválogatva:");
  683.             Console.WriteLine("\tPáros számok:");
  684.             foreach (int i in paros)
  685.             {
  686.                 Console.WriteLine(i);
  687.             }
  688.  
  689.             Console.WriteLine("\tPáratlan számok:");
  690.             foreach (int i in ptlan)
  691.             {
  692.                 Console.WriteLine(i);
  693.             }
  694.             Redirect();
  695.         }
  696.         static void Metszet()
  697.         {
  698.             Clear();
  699.  
  700.             File_Name_Text();
  701.             string name = Console.ReadLine();
  702.             int c = 0;
  703.  
  704.             Clear();
  705.  
  706.             FileHossza();
  707.             int l = int.Parse(Console.ReadLine());
  708.  
  709.             int[] ar = new int[l];
  710.  
  711.             StreamReader sr = new StreamReader(name);
  712.  
  713.             while (!sr.EndOfStream)
  714.             {
  715.                 ar[c] = int.Parse(sr.ReadLine());
  716.                 c++;
  717.             }
  718.             sr.Close();
  719.  
  720.             Clear();
  721.  
  722.             Console.WriteLine("Adjon meg egy számot!");
  723.             int ans1 = int.Parse(Console.ReadLine());
  724.  
  725.             Clear();
  726.  
  727.             Console.WriteLine("Adjon meg még egy számot!");
  728.             int ans2 = int.Parse(Console.ReadLine());
  729.  
  730.             List<int> list = new List<int>();
  731.  
  732.             for (int i = 0; i < c; i++)
  733.             {
  734.                 if (ar[i] % ans1 == 0 && ar[i] % ans2 == 0)
  735.                 {
  736.                     list.Add(ar[i]);
  737.                 }
  738.             }
  739.             Clear();
  740.  
  741.             if (list.Count > 0)
  742.             {
  743.                 Console.WriteLine($"Ezek a számok oszthatóak a megadott számokkal: ({ans1}, {ans2})");
  744.                 foreach (int item in list)
  745.                 {
  746.                     Console.WriteLine(item);
  747.                 }
  748.             }
  749.             else
  750.             {
  751.                 Console.WriteLine($"Nincsenek ezekkel a számokkal osztható számok a tömbben. ({ans1}, {ans2})");
  752.             }
  753.             Redirect();
  754.         }
  755.         static void Unio()
  756.         {
  757.             Clear();
  758.  
  759.             File_Name_Text();
  760.             string name = Console.ReadLine();
  761.             int c = 0;
  762.  
  763.             Clear();
  764.  
  765.             FileHossza();
  766.             int l = int.Parse(Console.ReadLine());
  767.  
  768.             int[] ar = new int[l];
  769.  
  770.             StreamReader sr = new StreamReader(name);
  771.  
  772.             while (!sr.EndOfStream)
  773.             {
  774.                 ar[c] = int.Parse(sr.ReadLine());
  775.                 c++;
  776.             }
  777.             sr.Close();
  778.  
  779.             Clear();
  780.  
  781.             Console.WriteLine("Adjon meg egy számot!");
  782.             int ans1 = int.Parse(Console.ReadLine());
  783.  
  784.             Clear();
  785.  
  786.             Console.WriteLine("Adjon meg még egy számot!");
  787.             int ans2 = int.Parse(Console.ReadLine());
  788.  
  789.             List<int> list = new List<int>();
  790.  
  791.             for (int i = 0; i < c; i++)
  792.             {
  793.                 if (ar[i] % ans1 == 0 || ar[i] % ans2 == 0)
  794.                 {
  795.                     list.Add(ar[i]);
  796.                 }
  797.             }
  798.             Clear();
  799.  
  800.             if (list.Count > 0)
  801.             {
  802.                 Console.WriteLine($"Ezek a számok, oszthatóak a megadott számok közül legalább az egyikkel: ({ans1}, {ans2})");
  803.                 foreach (int item in list)
  804.                 {
  805.                     Console.WriteLine(item);
  806.                 }
  807.             }
  808.             else
  809.             {
  810.                 Console.WriteLine($"Nincsenek ilyen számok a tömbben. ({ans1}, {ans2})");
  811.             }
  812.             Redirect();
  813.         }
  814.         static void OsszeFuttatas()
  815.         {
  816.             Clear();
  817.  
  818.             File_Name_Text();
  819.             string name = Console.ReadLine();
  820.             int c = 0;
  821.             int c2 = 0;
  822.  
  823.             Clear();
  824.  
  825.             FileHossza();
  826.             int l = int.Parse(Console.ReadLine());
  827.  
  828.             int[] ar = new int[l];
  829.             int[] ar2 = new int[l];
  830.  
  831.             StreamReader sr = new StreamReader(name);
  832.  
  833.             while (!sr.EndOfStream)
  834.             {
  835.                 ar[c] = int.Parse(sr.ReadLine());
  836.                 c++;
  837.             }
  838.             sr.Close();
  839.  
  840.             Clear();
  841.  
  842.             Console.WriteLine("Adja meg a 2. file nevét:");
  843.             string name2 = Console.ReadLine();
  844.  
  845.             Clear();
  846.  
  847.             StreamReader sr2 = new StreamReader(name2);
  848.  
  849.             while (!sr2.EndOfStream)
  850.             {
  851.                 ar2[c2] = int.Parse(sr2.ReadLine());
  852.                 c2++;
  853.             }
  854.             sr2.Close();
  855.  
  856.             List<int> list = new List<int>();
  857.  
  858.             if (c < c2) { c = c2; }
  859.  
  860.             Array.Sort(ar);
  861.             Array.Sort(ar2);
  862.  
  863.             for (int i = 0; i < c; i++)
  864.             {
  865.                 if (ar[i] < ar2[i])
  866.                 {
  867.                     list.Add(ar[i]);
  868.                     list.Add(ar2[i]);
  869.                 }
  870.                 else
  871.                 {
  872.                     list.Add(ar2[i]);
  873.                     list.Add(ar[i]);
  874.                 }
  875.             }
  876.             Clear();
  877.  
  878.             Console.WriteLine("Összefűzött elemek:");
  879.             foreach (int i in list)
  880.             {
  881.                 Console.WriteLine(i);
  882.             }
  883.             Redirect();
  884.         }
  885.         static void Rendezes_EgyszeruCsere()
  886.         {
  887.             Clear();
  888.  
  889.             File_Name_Text();
  890.             string name = Console.ReadLine();
  891.             int c = 0;
  892.  
  893.             Clear();
  894.  
  895.             FileHossza();
  896.             int l = int.Parse(Console.ReadLine());
  897.  
  898.             int[] ar = new int[l];
  899.  
  900.             StreamReader sr = new StreamReader(name);
  901.  
  902.             while (!sr.EndOfStream)
  903.             {
  904.                 ar[c] = int.Parse(sr.ReadLine());
  905.                 c++;
  906.             }
  907.             sr.Close();
  908.  
  909.             Clear();
  910.  
  911.             Console.WriteLine("Tömb, rendezés előtt:\n");
  912.             for (int i = 0; i < c; i++)
  913.             {
  914.                 Console.WriteLine($"{ar[i]}");
  915.             }
  916.  
  917.             for (int i = 0; i < c - 1; i++)
  918.             {
  919.                 for (int j = i + 1; j < c; j++)
  920.                 {
  921.                     if (ar[i] > ar[j])
  922.                     {
  923.                         int cs = ar[j];
  924.                         ar[j] = ar[i];
  925.                         ar[i] = cs;
  926.                     }
  927.                 }
  928.             }
  929.             Console.WriteLine("\nTömb rendezés után:\n");
  930.             for (int i = 0; i < c; i++)
  931.             {
  932.                 Console.WriteLine($"{ar[i]}");
  933.             }
  934.             Redirect();
  935.         }
  936.         static void Rendezes_Buborekos()
  937.         {
  938.             Clear();
  939.  
  940.             File_Name_Text();
  941.             string name = Console.ReadLine();
  942.             int c = 0;
  943.  
  944.             Clear();
  945.  
  946.             FileHossza();
  947.             int l = int.Parse(Console.ReadLine());
  948.  
  949.             int[] ar = new int[l];
  950.  
  951.             StreamReader sr = new StreamReader(name);
  952.  
  953.             while (!sr.EndOfStream)
  954.             {
  955.                 ar[c] = int.Parse(sr.ReadLine());
  956.                 c++;
  957.             }
  958.             sr.Close();
  959.  
  960.             Clear();
  961.  
  962.             Console.WriteLine("Csere előtti tömb:\n");
  963.             for (int i = 0; i < c; i++)
  964.             {
  965.                 Console.WriteLine($"{ar[i]}");
  966.             }
  967.  
  968.             for (int i = c - 1; i > 0; i--)
  969.             {
  970.                 for (int j = 0; j < i; j++)
  971.                 {
  972.                     if (ar[j] > ar[j + 1])
  973.                     {
  974.                         int cs = ar[j + 1];
  975.                         ar[j + 1] = ar[j];
  976.                         ar[j] = cs;
  977.                     }
  978.                 }
  979.             }
  980.  
  981.             Console.WriteLine("\nCsere utáni tömb:\n");
  982.             for (int i = 0; i < c; i++)
  983.             {
  984.                 Console.WriteLine($"{ar[i]}");
  985.             }
  986.             Redirect();
  987.         }
  988.         static void Rendezes_Beilleszteses()
  989.         {
  990.             Clear();
  991.  
  992.             File_Name_Text();
  993.             string name = Console.ReadLine();
  994.             int c = 0;
  995.  
  996.             Clear();
  997.  
  998.             FileHossza();
  999.             int l = int.Parse(Console.ReadLine());
  1000.  
  1001.             int[] ar = new int[l];
  1002.  
  1003.             StreamReader sr = new StreamReader(name);
  1004.  
  1005.             while (!sr.EndOfStream)
  1006.             {
  1007.                 ar[c] = int.Parse(sr.ReadLine());
  1008.                 c++;
  1009.             }
  1010.             sr.Close();
  1011.  
  1012.             Clear();
  1013.  
  1014.             Console.WriteLine("Csere előtti tömb:\n");
  1015.             for (int i = 0; i < c; i++)
  1016.             {
  1017.                 Console.WriteLine($"{ar[i]}");
  1018.             }
  1019.  
  1020.             for (int i = 1; i < c; i++)
  1021.             {
  1022.                 int k = ar[i];
  1023.                 int j = i - 1;
  1024.                 while (j >= 0 && ar[j] > k)
  1025.                 {
  1026.                     ar[j + 1] = ar[j];
  1027.                     j--;
  1028.                 }
  1029.                 ar[j + 1] = k;
  1030.  
  1031.             }
  1032.  
  1033.             Console.WriteLine("\nCsere utáni tömb:\n");
  1034.             for (int i = 0; i < c; i++)
  1035.             {
  1036.                 Console.WriteLine($"{ar[i]}");
  1037.             }
  1038.             Redirect();
  1039.         }
  1040.         static void Rendezes_MinKivalaszt()
  1041.         {
  1042.             Clear();
  1043.  
  1044.             File_Name_Text();
  1045.             string name = Console.ReadLine();
  1046.             int c = 0;
  1047.  
  1048.             Clear();
  1049.  
  1050.             FileHossza();
  1051.             int l = int.Parse(Console.ReadLine());
  1052.  
  1053.             int[] ar = new int[l];
  1054.  
  1055.             StreamReader sr = new StreamReader(name);
  1056.  
  1057.             while (!sr.EndOfStream)
  1058.             {
  1059.                 ar[c] = int.Parse(sr.ReadLine());
  1060.                 c++;
  1061.             }
  1062.             sr.Close();
  1063.  
  1064.             Clear();
  1065.  
  1066.             Console.WriteLine("Csere előtti tömb:\n");
  1067.             for (int i = 0; i < c; i++)
  1068.             {
  1069.                 Console.WriteLine($"{ar[i]}");
  1070.             }
  1071.  
  1072.             for (int i = 0; i < c - 1; i++)
  1073.             {
  1074.                 int min = i;
  1075.                 for (int j = i + 1; j < c; j++)
  1076.                 {
  1077.                     if (ar[i] > ar[j])
  1078.                     {
  1079.                         min = j;
  1080.                     }
  1081.                 }
  1082.                 int cs = ar[min];
  1083.                 ar[min] = ar[i];
  1084.                 ar[i] = cs;
  1085.             }
  1086.  
  1087.             Console.WriteLine("\nCsere utáni tömb:\n");
  1088.             for (int i = 0; i < c; i++)
  1089.             {
  1090.                 Console.WriteLine($"{ar[i]}");
  1091.             }
  1092.             Redirect();
  1093.         }
  1094.         static void Rendezesek()
  1095.         {
  1096.             Clear();
  1097.  
  1098.             Console.WriteLine("Melyik rendezést szeretné alkalmazni?");
  1099.             Console.WriteLine("1. Egyszerű cserés\n2. Buborékos\n3. Beillesztéses\n4. Minimum kiválasztásos");
  1100.             int ans = int.Parse(Console.ReadLine());
  1101.  
  1102.             switch (ans)
  1103.             {
  1104.                 case 1:
  1105.                     Rendezes_EgyszeruCsere();
  1106.                     break;
  1107.                 case 2:
  1108.                     Rendezes_Buborekos();
  1109.                     break;
  1110.                 case 3:
  1111.                     Rendezes_Beilleszteses();
  1112.                     break;
  1113.                 case 4:
  1114.                     Rendezes_MinKivalaszt();
  1115.                     break;
  1116.                 default:
  1117.                     Rendezesek();
  1118.                     break;
  1119.             }
  1120.         }
  1121.         static void Redirect()
  1122.         {
  1123.             Console.WriteLine("\n\n\n\tHa szeretne visszalépni a főmenühöz, nyomja meg az 1es gombot.");
  1124.             if (int.Parse(Console.ReadLine()) == 1)
  1125.             {
  1126.                 Menu();
  1127.             }
  1128.             Environment.Exit(0);
  1129.         }
  1130.         static void Menu()
  1131.         {
  1132.             Console.WriteLine("Szám beírásával kérem válasszon egyet, az alábbiak közül!");
  1133.             Console.WriteLine("1. Sorozatszámítás\n2. Eldöntés\n3. Kiválasztás\n4. Keresés\n5. Megszámolás\n6. Maximum kiválasztás.");
  1134.             Console.WriteLine("7. Másolás\n8. Kiválogatás\n9. Szétválogatás\n10. Metszet\n11. Unió\n12. Összefuttatás\n13. Rendezések");
  1135.  
  1136.             int answer = 0;
  1137.  
  1138.             try { answer = int.Parse(Console.ReadLine()); }
  1139.             catch (Exception)
  1140.             {
  1141.                 Clear();
  1142.                 Console.WriteLine("Hibás szám, Próbálja újra.\n");
  1143.                 Menu();
  1144.             }
  1145.  
  1146.             switch (answer)
  1147.             {
  1148.                 case 1:
  1149.                     SorozatSzamitas();
  1150.                     break;
  1151.                 case 2:
  1152.                     Eldontes();
  1153.                     break;
  1154.                 case 3:
  1155.                     Kivalasztas();
  1156.                     break;
  1157.                 case 4:
  1158.                     Kereses();
  1159.                     break;
  1160.                 case 5:
  1161.                     Megszamolas();
  1162.                     break;
  1163.                 case 6:
  1164.                     MaxValaszt();
  1165.                     break;
  1166.                 case 7:
  1167.                     Masolas();
  1168.                     break;
  1169.                 case 8:
  1170.                     Kivalogatas();
  1171.                     break;
  1172.                 case 9:
  1173.                     Szetvalogatas();
  1174.                     break;
  1175.                 case 10:
  1176.                     Metszet();
  1177.                     break;
  1178.                 case 11:
  1179.                     Unio();
  1180.                     break;
  1181.                 case 12:
  1182.                     OsszeFuttatas();
  1183.                     break;
  1184.                 case 13:
  1185.                     Rendezesek();
  1186.                     break;
  1187.                 default:
  1188.                     Clear();
  1189.                     Console.WriteLine("Hibás szám, Próbálja újra.\n");
  1190.                     Menu();
  1191.                     break;
  1192.             }
  1193.         }
  1194.         static void Main(string[] args)
  1195.         {
  1196.             Menu();
  1197.         }
  1198.     }
  1199. }
  1200.  
RAW Paste Data