Facebook

linq-sol safest cryptocurrency exchange

From Rude Hog, 2 Years ago, written in C#.
URL https://pastebin.pl/view/1ee39490
Embed
Download Paste or View Raw
Hits: 39
  1. using LinqTutorials.Models;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5.  
  6. namespace LinqTutorials
  7. {
  8.     public static class LinqTasks
  9.     {
  10.         public static IEnumerable<Emp> Emps { get; set; }
  11.         public static IEnumerable<Dept> Depts { get; set; }
  12.  
  13.         static LinqTasks()
  14.         {
  15.             var empsCol = new List<Emp>();
  16.             var deptsCol = new List<Dept>();
  17.  
  18.             #region Load depts
  19.  
  20.             var d1 = new Dept
  21.             {
  22.                 Deptno = 1,
  23.                 Dname = "Research",
  24.                 Loc = "Warsaw"
  25.             };
  26.  
  27.             var d2 = new Dept
  28.             {
  29.                 Deptno = 2,
  30.                 Dname = "Human Resources",
  31.                 Loc = "New York"
  32.             };
  33.  
  34.             var d3 = new Dept
  35.             {
  36.                 Deptno = 3,
  37.                 Dname = "IT",
  38.                 Loc = "Los Angeles"
  39.             };
  40.  
  41.             deptsCol.Add(d1);
  42.             deptsCol.Add(d2);
  43.             deptsCol.Add(d3);
  44.             Depts = deptsCol;
  45.  
  46.             #endregion
  47.  
  48.             #region Load emps
  49.  
  50.             var e1 = new Emp
  51.             {
  52.                 Deptno = 1,
  53.                 Empno = 1,
  54.                 Ename = "Jan Kowalski",
  55.                 HireDate = DateTime.Now.AddMonths(-5),
  56.                 Job = "Backend programmer",
  57.                 Mgr = null,
  58.                 Salary = 2000
  59.             };
  60.  
  61.             var e2 = new Emp
  62.             {
  63.                 Deptno = 1,
  64.                 Empno = 20,
  65.                 Ename = "Anna Malewska",
  66.                 HireDate = DateTime.Now.AddMonths(-7),
  67.                 Job = "Frontend programmer",
  68.                 Mgr = e1,
  69.                 Salary = 4000
  70.             };
  71.  
  72.             var e3 = new Emp
  73.             {
  74.                 Deptno = 1,
  75.                 Empno = 2,
  76.                 Ename = "Marcin Korewski",
  77.                 HireDate = DateTime.Now.AddMonths(-3),
  78.                 Job = "Frontend programmer",
  79.                 Mgr = null,
  80.                 Salary = 5000
  81.             };
  82.  
  83.             var e4 = new Emp
  84.             {
  85.                 Deptno = 2,
  86.                 Empno = 3,
  87.                 Ename = "Paweł Latowski",
  88.                 HireDate = DateTime.Now.AddMonths(-2),
  89.                 Job = "Frontend programmer",
  90.                 Mgr = e2,
  91.                 Salary = 5500
  92.             };
  93.  
  94.             var e5 = new Emp
  95.             {
  96.                 Deptno = 2,
  97.                 Empno = 4,
  98.                 Ename = "Michał Kowalski",
  99.                 HireDate = DateTime.Now.AddMonths(-2),
  100.                 Job = "Backend programmer",
  101.                 Mgr = e2,
  102.                 Salary = 5500
  103.             };
  104.  
  105.             var e6 = new Emp
  106.             {
  107.                 Deptno = 2,
  108.                 Empno = 5,
  109.                 Ename = "Katarzyna Malewska",
  110.                 HireDate = DateTime.Now.AddMonths(-3),
  111.                 Job = "Manager",
  112.                 Mgr = null,
  113.                 Salary = 8000
  114.             };
  115.  
  116.             var e7 = new Emp
  117.             {
  118.                 Deptno = null,
  119.                 Empno = 6,
  120.                 Ename = "Andrzej Kwiatkowski",
  121.                 HireDate = DateTime.Now.AddMonths(-3),
  122.                 Job = "System administrator",
  123.                 Mgr = null,
  124.                 Salary = 7500
  125.             };
  126.  
  127.             var e8 = new Emp
  128.             {
  129.                 Deptno = 2,
  130.                 Empno = 7,
  131.                 Ename = "Marcin Polewski",
  132.                 HireDate = DateTime.Now.AddMonths(-3),
  133.                 Job = "Mobile developer",
  134.                 Mgr = null,
  135.                 Salary = 4000
  136.             };
  137.  
  138.             var e9 = new Emp
  139.             {
  140.                 Deptno = 2,
  141.                 Empno = 8,
  142.                 Ename = "Władysław Torzewski",
  143.                 HireDate = DateTime.Now.AddMonths(-9),
  144.                 Job = "CTO",
  145.                 Mgr = null,
  146.                 Salary = 12000
  147.             };
  148.  
  149.             var e10 = new Emp
  150.             {
  151.                 Deptno = 2,
  152.                 Empno = 9,
  153.                 Ename = "Andrzej Dalewski",
  154.                 HireDate = DateTime.Now.AddMonths(-4),
  155.                 Job = "Database administrator",
  156.                 Mgr = null,
  157.                 Salary = 9000
  158.             };
  159.  
  160.             empsCol.Add(e1);
  161.             empsCol.Add(e2);
  162.             empsCol.Add(e3);
  163.             empsCol.Add(e4);
  164.             empsCol.Add(e5);
  165.             empsCol.Add(e6);
  166.             empsCol.Add(e7);
  167.             empsCol.Add(e8);
  168.             empsCol.Add(e9);
  169.             empsCol.Add(e10);
  170.             Emps = empsCol;
  171.  
  172.             #endregion
  173.         }
  174.  
  175.         /// <summary>
  176.         ///     SELECT * FROM Emps WHERE Job = "Backend programmer";
  177.         /// </summary>
  178.         public static IEnumerable<Emp> Task1()
  179.         {
  180.             IEnumerable<Emp> result = Emps.Where(x => x.Job == "Backend programmer");
  181.  
  182.             return result;
  183.         }
  184.  
  185.         /// <summary>
  186.         ///     SELECT * FROM Emps Job = "Frontend programmer" AND Salary>1000 ORDER BY Ename DESC;
  187.         /// </summary>
  188.         public static IEnumerable<Emp> Task2()
  189.         {
  190.             IEnumerable<Emp> result = Emps
  191.                 .Where(x => x.Job == "Frontend programmer" && x.Salary > 1000)
  192.                 .OrderByDescending(x => x.Ename);
  193.  
  194.             return result;
  195.         }
  196.  
  197.  
  198.         /// <summary>
  199.         ///     SELECT MAX(Salary) FROM Emps;
  200.         /// </summary>
  201.         public static int Task3()
  202.         {
  203.             int result = Emps.Max(x => x.Salary);
  204.             return result;
  205.         }
  206.  
  207.         /// <summary>
  208.         ///     SELECT * FROM Emps WHERE Salary=(SELECT MAX(Salary) FROM Emps);
  209.         /// </summary>
  210.         public static IEnumerable<Emp> Task4()
  211.         {
  212.             IEnumerable<Emp> result = Emps.Where(x => x.Salary == Emps.Max(y => y.Salary));
  213.             return result;
  214.         }
  215.  
  216.         /// <summary>
  217.         ///    SELECT ename AS Nazwisko, job AS Praca FROM Emps;
  218.         /// </summary>
  219.         public static IEnumerable<object> Task5()
  220.         {
  221.             IEnumerable<object> result = Emps.Select(x => new
  222.             {
  223.                 Nazwisko = x.Ename,
  224.                 Praca = x.Job
  225.             });
  226.             return result;
  227.         }
  228.  
  229.         /// <summary>
  230.         ///     SELECT Emps.Ename, Emps.Job, Depts.Dname FROM Emps
  231.         ///     INNER JOIN Depts ON Emps.Deptno=Depts.Deptno
  232.         ///     Rezultat: Złączenie kolekcji Emps i Depts.
  233.         /// </summary>
  234.         public static IEnumerable<object> Task6()
  235.         {
  236.             IEnumerable<object> result = Emps.Join(Depts, x => x.Deptno, y => y.Deptno, (x, y) => new { Emps = x, Depts = y })
  237.                 .Select(x => new { x.Emps.Ename, x.Emps.Job, x.Depts.Dname });
  238.  
  239.             return result;
  240.         }
  241.  
  242.         /// <summary>
  243.         ///     SELECT Job AS Praca, COUNT(1) LiczbaPracownikow FROM Emps GROUP BY Job;
  244.         /// </summary>
  245.         public static IEnumerable<object> Task7()
  246.         {
  247.             IEnumerable<object> result = Emps.GroupBy(x => x.Job).Select(x => new
  248.             {
  249.                 Praca = x.Key,
  250.                 LiczbaPracownikow = x.Count()
  251.             });
  252.             return result;
  253.         }
  254.  
  255.         /// <summary>
  256.         ///     Zwróć wartość "true" jeśli choć jeden
  257.         ///     z elementów kolekcji pracuje jako "Backend programmer".
  258.         /// </summary>
  259.         public static bool Task8()
  260.         {
  261.             bool result = Emps.Any(x => x.Job == "Backend programmer");
  262.  
  263.             return result;
  264.         }
  265.  
  266.         /// <summary>
  267.         ///     SELECT TOP 1 * FROM Emp WHERE Job="Frontend programmer"
  268.         ///     ORDER BY HireDate DESC;
  269.         /// </summary>
  270.         public static Emp Task9()
  271.         {
  272.             Emp result = Emps.Where(x => x.Job == "Frontend programmer").OrderByDescending(x => x.HireDate).Take(1).First();
  273.  
  274.             return result;
  275.         }
  276.  
  277.         /// <summary>
  278.         ///     SELECT Ename, Job, Hiredate FROM Emps
  279.         ///     UNION
  280.         ///     SELECT "Brak wartości", null, null;
  281.         /// </summary>
  282.         public static IEnumerable<object> Task10()
  283.         {
  284.             IEnumerable<object> result = Emps
  285.                 .Select(x => new {x.Ename, x.Job, x.HireDate})
  286.                 .Union(Emps.Select(y => new
  287.                     {Ename = "Brak wartości", Job = string.Empty, HireDate = (DateTime?) null}));
  288.             return result;
  289.         }
  290.  
  291.         /// <summary>
  292.         /// Wykorzystując LINQ pobierz pracowników podzielony na departamenty pamiętając, że:
  293.         /// 1. Interesują nas tylko departamenty z liczbą pracowników powyżej 1
  294.         /// 2. Chcemy zwrócić listę obiektów o następującej srukturze:
  295.         ///    [
  296.         ///      {name: "RESEARCH", numOfEmployees: 3},
  297.         ///      {name: "SALES", numOfEmployees: 5},
  298.         ///      ...
  299.         ///    ]
  300.         /// 3. Wykorzystaj typy anonimowe
  301.         /// </summary>
  302.         public static IEnumerable<object> Task11()
  303.         {
  304.             IEnumerable<object> result = Depts
  305.                 .Join(Emps, x => x.Deptno, y => y.Deptno, (x,y) => new { Depts = x, Emps = y})
  306.                 .GroupBy(x => x.Depts.Dname)
  307.                 .Where(x => x.Count() > 1).Select(x => new
  308.             {
  309.                 Name = x.Key,
  310.                 NumOfEmployees = x.Count()
  311.             });
  312.  
  313.  
  314.             return result;
  315.         }
  316.  
  317.         /// <summary>
  318.         /// Napisz własną metodę rozszerzeń, która pozwoli skompilować się poniższemu fragmentowi kodu.
  319.         /// Metodę dodaj do klasy CustomExtensionMethods, która zdefiniowana jest poniżej.
  320.         ///
  321.         /// Metoda powinna zwrócić tylko tych pracowników, którzy mają min. 1 bezpośredniego podwładnego.
  322.         /// Pracownicy powinny w ramach kolekcji być posortowani po nazwisku (rosnąco) i pensji (malejąco).
  323.         /// </summary>
  324.         public static IEnumerable<Emp> Task12()
  325.         {
  326.             IEnumerable<Emp> result = Emps.GetEmpsWithSubordinates();
  327.  
  328.            
  329.             return result;
  330.         }
  331.  
  332.         /// <summary>
  333.         /// Poniższa metoda powinna zwracać pojedyczną liczbę int.
  334.         /// Na wejściu przyjmujemy listę liczb całkowitych.
  335.         /// Spróbuj z pomocą LINQ'a odnaleźć tę liczbę, które występuja w tablicy int'ów nieparzystą liczbę razy.
  336.         /// Zakładamy, że zawsze będzie jedna taka liczba.
  337.         /// Np: {1,1,1,1,1,1,10,1,1,1,1} => 10
  338.         /// </summary>
  339.         public static int Task13(int[] arr)
  340.         {
  341.             int result = 0;
  342.  
  343.             result = arr.GroupBy(x => x).Where(x => x.Count() % 2 != 0).Select(x => x.Key).First();
  344.  
  345.             return result;
  346.         }
  347.  
  348.         /// <summary>
  349.         /// Zwróć tylko te departamenty, które mają 5 pracowników lub nie mają pracowników w ogóle.
  350.         /// Posortuj rezultat po nazwie departament rosnąco.
  351.         /// </summary>
  352.         public static IEnumerable<Dept> Task14()
  353.         {
  354.             IEnumerable<Dept> result = Depts
  355.                 .Where(x => Emps.Count(y => y.Deptno == x.Deptno) == 5 || Emps.All(y => y.Deptno != x.Deptno))
  356.                 .OrderBy(x => x.Dname);
  357.  
  358.  
  359.             return result;
  360.         }
  361.     }
  362.  
  363.     public static class CustomExtensionMethods
  364.     {
  365.         //Put your extension methods here
  366.         public static IEnumerable<Emp> GetEmpsWithSubordinates(this IEnumerable<Emp> emps)
  367.         {
  368.             var result = emps.Where(e => emps.Any(e2 => e2.Mgr == e)).OrderBy(e => e.Ename).ThenByDescending(e => e.Salary);
  369.             return result;
  370.         }
  371.  
  372.     }
  373. }

Reply to "linq-sol"