[PW] Lab 4 (23-03-2016), Lab 5 (30-03-2016), Lab 6, Lab7

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Globalization;


namespace ConsoleApplication2
{
    public static class Extensions
    {
        public static IEnumerable<T> BelowAverage<T>(this IEnumerable<T> collection, Func<T, double> func)
        {
            List<T> l = new List<T>();
            var avg = collection.Average(func);

            foreach (var i in collection)
            {
                if (func(i) < avg) l.Add(i);
            }
            return l;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            string _path = "C:\\Users\\inf117288\\Desktop\\tabele\\";
            var zespoly = from l in File.ReadAllLines(_path + "ZESPOLY.csv").Skip(1)
                          let x = l.Split(';')
                          select new
                          {
                              ID_ZESP = int.Parse(x[0]),
                              NAZWA = x[1],
                              ADMINISTRACJA = x[2]
                          };
            var etaty = from l in File.ReadAllLines(_path + "ETATY.csv").Skip(1)
                        let x = l.Split(';')
                        select new
                        {
                            NAZWA = x[0],
                            PLACA_MIN = double.Parse(x[1]),
                            PLACA_MAX = double.Parse(x[2])
                        };
            var pracownicy = from l in File.ReadAllLines(_path + "PRACOWNICY.csv").Skip(1)
                             let x = l.Split(';')
                             select new
                             {
                                 ID_PRAC = int.Parse(x[0]),
                                 NAZWISKO = x[1],
                                 ETAT = x[2],
                                 ID_SZEFA = x[3] != "NULL" ? (new Nullable<int>(int.Parse(x[3]))) : (null),
                                 ZATRUDNIONY = DateTime.ParseExact(x[4], "dd-MM-yy", CultureInfo.InvariantCulture),
                                 PLACA_POD = double.Parse(x[5]),
                                 PLACA_DOD = (x[6] != "NULL") ? new Nullable<double>(double.Parse(x[6])) : (null),
                                 ID_ZESP = int.Parse(x[7])
                             };

            /* var g = from p in pracownicy
                           let z = p.PLACA_POD + (p.PLACA_DOD ?? 0)
                           orderby z descending
                           select new
                           {
                               x = p.NAZWISKO,
                               y = z
                           };
              g.ToList().ForEach(x => Console.WriteLine(x));*/

            /*  var g = from p in pracownicy
                      group p by p.ID_ZESP into q
                      join z in zespoly on q.Key equals z.ID_ZESP
                      select new
                      {
                          x = z.NAZWA,
                          List = q.ToList().Count
                      };

              g.ToList().ForEach(x => {
                  Console.WriteLine(x.x + ": " + x.List);
              });*/

            /*
            var g = from p in pracownicy
                    let placa_s = (from pr in pracownicy select pr.PLACA_POD).Average()
                    where (p.PLACA_POD > placa_s)
                    select p;

            g.ToList().ForEach(x =>
            {
                Console.WriteLine(x);
            });*/


            //////////////////////////////////////////////////////////////////////////////////////////////////////////////

            /*  ZAD 1 Wypisać ID_PRAC i NAZWISKO */
            /*var q = pracownicy.Select(p => new { p.ID_PRAC, p.NAZWISKO  });
            q.ToList().ForEach(x => Console.WriteLine(x));*/


            /* ZAD 2 Wypisać osoby tych co mają PLAC_POD > 400 */
            /*var q = pracownicy.Where(p => p.PLACA_POD > 400);
            q.ToList().ForEach(x => Console.WriteLine(x));*/


            /* ZAD 3 Posortuj elementy z kolekcji po PLACA_POD + PLACA_DOD */
            /*var q = pracownicy
                .OrderByDescending(p => p.PLACA_POD + (p.PLACA_DOD ?? 0))
                .Select(p => new {Nazwisko = p.NAZWISKO, Placa = p.PLACA_POD + (p.PLACA_DOD ?? 0)})
                .Distinct()
                .ToArray();
            q.ToList().ForEach(x => Console.WriteLine(x));*/


            /* ZAD 4 Wykonaj to samo, upraszczając zapis */
            /*var q = pracownicy
                .Select(p => new { Nazwisko = p.NAZWISKO, Placa = p.PLACA_POD + (p.PLACA_DOD ?? 0)})
                .OrderByDescending(p => p.Placa)
                .Distinct()
                .ToArray();
            q.ToList().ForEach(x => Console.WriteLine(x));*/


            /* ZAD 5 Wypisać ilu pracowników ma nazwisko zaczynające się na daną literę */
            /*var q = pracownicy
                .GroupBy(p => p.NAZWISKO.First())
                .Select(p => new { l = p.Key, Ile = p.Count() });
            q.ToList().ForEach(x => Console.WriteLine(x));*/


            /* ZAD 6 Znajdź ilu pracowników jest w danym zespole i wypisz jego nazwę */
            /*var q = pracownicy
                .GroupBy(p => p.ID_ZESP)
                .Join(zespoly, p => p.Key, z => z.ID_ZESP, (p, z) => new { p, z })
                .Select(y => new {nazwa = y.z.NAZWA, ile = y.p.Count()});
            q.ToList().ForEach(x => Console.WriteLine(x));*/


            /* ZAD 7 Wypisz takich pracowników co mają płacę podstawową powyżej średniej wszystkich pracowników */
            /*var q = pracownicy
                .SelectMany(p1 => pracownicy.Where(p2 => p2.PLACA_POD > pracownicy.Select(p3 => p3.PLACA_POD).Average()), (p1, p2) => new { p1, p2 })
                .Select(p => new { p.p2.NAZWISKO, p.p2.PLACA_POD })
                .Distinct();
             *
             * ALTERNATIVE *
             *
             var q = pracownicy.Where(x => x.PLACA_POD > (pracownicy.Select(p => p.PLACA_POD).Average())).Select(x => x.NAZWISKO);
            q.ToList().ForEach(x => Console.WriteLine(x));*/

            //////////////////////////////////////////////////////////////////////////////////////////////////////////////

            /* ZAD 1 Wartość średniej pensji wszystkich szefów i odjąć od niej średnią płacę wszystkich podwładnych */
            /*var s1 = pracownicy.Where(p => pracownicy.Where(d => d.ID_SZEFA == p.ID_PRAC).Count() > 0).Average(p => p.PLACA_POD);
            var s2 = pracownicy.Where(p => p.ID_SZEFA != null).Average(p => p.PLACA_POD);
            Console.WriteLine(s1 - s2);
             */

            /* ZAD 2 Dla każdego zespołu podaj różnicę między drugim najlepiej zarabiającym pracownikiem tego zespołu, a drugim najgorzej zarabiającym pracownikiem tego zespołu */
            /*var zm1 = pracownicy.GroupBy(p => p.ID_ZESP).Select(x => new { x.Key, roznica = (x.OrderByDescending(z => z.PLACA_POD).Select(a => a.PLACA_POD).ElementAtOrDefault(1) - x.OrderBy(z => z.PLACA_POD).Select(a => a.PLACA_POD).ElementAtOrDefault(1)) });

            foreach (var e in zm1)
            {
                Console.WriteLine(e.Key + " " + e.roznica);
            }*/

            /* ZAD 3  Metoda rozszerzająca isPalindrom sprawdzajaca, czy dany ciag jest palindromem */
            /* MUSI BYC W NAMESPACE ŻEBY DZIAŁAŁO
            public static class Extensions
            {
                public static bool isPalindrom(this String str)
                {
                    return str.SequenceEqual(str.Reverse());
                }
            }

            Console.WriteLine("kajaka".isPalindrom());
            */

            /*
            public static class Extensions
            {
                public static bool isPalindrom <T> (this IEnumerable<T> collection)
                {
                    int dl = collection.Count();
                    --dl;

                    for (int i = 0; i < dl / 2; i++)
                        if (!collection.ElementAt(i).Equals(collection.ElementAt(dl - i))) return false;
                    return true;
                }
            }
             *
             *
            char[] list = new char[5];
            list[0] = 'K';
            list[1] = 'A';
            list[2] = 'J';
            list[3] = 'A';
            list[4] = 'K';

            int[] list2 = new int[3];
            list2[0] = 1;
            list2[1] = 0;
            list2[2] = 1;

            Console.WriteLine(list2.isPalindrom());*/

    //////////////////////////////////////////////////////////////////////////////////////////////////////////////

            /* ZAD 1 Zwróć dominantę z dowolnej kolekcji */
            /*
            public static class Extensions
            {
                public static T findDominant <T> (this IEnumerable<T> collection)
                {
                    int dl = collection.Count();
                    if (dl == 0) return default(T);
                    int top = 0;
                    int topIdx = 0;

                    for (int i = 0; i < dl; i++)
                    {
                        int wystapil = 0;
                        for (int j = 0; j < dl; j++)
                        {
                            if (collection.ElementAt(j).Equals(collection.ElementAt(i)))
                            {
                                wystapil++;
                            }
                            if (wystapil > top)
                            {
                                top = wystapil;
                                topIdx = i;
                            }
                        }
                    }

                    return collection.ElementAt(topIdx);
                }
            }*/

            /* ZAD 2 To samo co wyżej, tym razem z wykorzystaniem slownika, zlozonosc O(nlogn) a nie O(n^3) jak wczesniej */
            /*
            public static class Extensions
            {
                    public static T findDominant <T> (this IEnumerable<T> collection)
                    {
                        int len = collection.Count();
                        if (len == 0) return default(T);

                        Dictionary<T, int> dict = new Dictionary<T,int>();

                        for (int i = 0; i < len; i++)
                        {
                            if (dict.ContainsKey(collection.ElementAt(i)))
                            {
                                dict[collection.ElementAt(i)] += 1;
                            }
                            else
                            {
                                dict.Add(collection.ElementAt(i), 1);
                            }
                        }
                        return dict.Keys.Max();
                    }
            }
            char[] list = new char[5];
            list[0] = 'K';
            list[1] = 'A';
            list[2] = 'K';
            list[3] = 'A';
            list[4] = 'K';

            Console.WriteLine(list.findDominant());
             */

            /* ZAD 3 ZNAJDZ DOMINUJACY ETAT W DANYM ZESPOLE */
            /*var q = pracownicy
                .GroupBy(p => p.ID_ZESP)
                .Select(x => new { x.Key, etat = pracownicy.Select(p2 => p2.ETAT).findDominant() });

            q.ToList().ForEach(x => Console.WriteLine(x));*/

            /* ZAD 4 STWORZ METODE ROZSZERZAJACA KTORA ZWROCI KOLEKCJE ELEMENTOW PONIZEJ SREDNIEJ */
            /*public static class Extensions
            {
                public static IEnumerable<T> BelowAverage<T>(this IEnumerable<T> collection, Func<T, double> func)
                {
                    List<T> l = new List<T>();
                    var avg = collection.Average(func);

                    foreach (var i in collection)
                    {
                        if (func(i) < avg) l.Add(i);
                    }
                    return l;
                }
            } */

            /* ALTERNATYWNIE   BY KRZYSZTOF PRICE */
            /*public static class Extensions
            {
                public static IEnumerable<T> BelowAverage<T>(this IEnumerable<T> collection, Func<T, double> func)
                {
                    return collection.Where(x => func(x) < collection.Average(func));
                }
            }*/

        }
    }
}