using System;

using System.Globalization;

using System.Collections.Generic;

using System.Linq;

using Newtonsoft.Json;using System.IO;

​

public class Program

{

    public static void Main()

    {

        var date1 = new DateTime(2019, 1, 1);

        var date2 = new DateTime(2019, 1, 6);

        // Test Method 1

        var sameWeek = DatesAreInSameWeek(date1, date2);

        var snippet = sameWeek ? "in" : "NOT in";

        Console.WriteLine($"Method1: [{date1:ddd, dd-MM-yyyy}] and [{date2:ddd, dd-MM-yyyy}] are {snippet} same week.");

        // Test Method 2

        sameWeek = DatesAreInSameWeek2(date1, date2);

        snippet = sameWeek ? "in" : "NOT in";

        Console.WriteLine($"Method2: [{date1:ddd, dd-MM-yyyy}] and [{date2:ddd, dd-MM-yyyy}] are {snippet} same week.");

        // Test with Array and Permuations of Dates

        var listOfDates = BuildDatesTestList(new DateTime(2018, 12, 22), new DateTime(2019, 1, 15));

        var kPermutations = GetKCombs<DateTime>(listOfDates,2);

    }

​

    public static List<DateTime> BuildDatesTestList(DateTime from, DateTime to)

    {

        var result = new List<DateTime>();

        result = EachDay(from, to).ToList();

        return result;

    }

​

    // create list of dates between start and end

    public static IEnumerable<DateTime> EachDay(DateTime from, DateTime thru)

    {

        for (var day = from.Date; day.Date <= thru.Date; day = day.AddDays(1))

            yield return day;

    }

​

    // not so good logic to identify two dates being in same week

    public static bool DatesAreInSameWeek(DateTime a, DateTime b)

    {

        if (a.AddDays(7 - (int)a.DayOfWeek).Date.Equals(b.AddDays(7 - (int)b.DayOfWeek).Date))

        {

            // their int the same week

            return true;

        }

        else if (a.AddDays(7 - (int)a.DayOfWeek).Date.Equals(b.AddDays(-(int)b.DayOfWeek).Date))

        {

            return false;

        // a is in the last week of b

        }

​

        return false;

    }

​

    // better logic to identify two dates being in same week

    public static bool DatesAreInSameWeek2(DateTime a, DateTime b)

    {

        var cal = System.Globalization.DateTimeFormatInfo.CurrentInfo.Calendar;

        var weekA = GetCalendarWeek(a);

        var weekB = GetCalendarWeek(b);

        var diffDays = Math.Abs((a-b).TotalDays);

        //Console.WriteLine($"{weekA} {weekB}: {diffDays}");

        // week number must be same, but also date diff must be less than 7 days

        return weekA == weekB && diffDays < 7;

    }

​

    // UN specific settings

    // Monday first day of week

    // 1st week of year is 4 days

    public static int GetCalendarWeek(DateTime date)

    {

        var cal = System.Globalization.DateTimeFormatInfo.CurrentInfo.Calendar;

        return cal.GetWeekOfYear(date, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);

    }

​

    //-----------------------------------------------------------------------------------------------------

    // Permutations 

    // The outputs are for a list of {1, 2, 3, 4} and a length of 2.

    // Permutations with repetition

    // Output: {1,1} {1,2} {1,3} {1,4} {2,1} {2,2} {2,3} {2,4} {3,1} {3,2} {3,3} {3,4} {4,1} {4,2} {4,3} {4,4}

    static IEnumerable<IEnumerable<T>> GetPermutationsWithRept<T>(IEnumerable<T> list, int length)

    {

        if (length == 1)

            return list.Select(t => new T[]{t});

        return GetPermutationsWithRept(list, length - 1).SelectMany(t => list, (t1, t2) => t1.Concat(new T[]{t2}));

    }

​

    // Permutations

    // Output: {1,2} {1,3} {1,4} {2,1} {2,3} {2,4} {3,1} {3,2} {3,4} {4,1} {4,2} {4,3}

    static IEnumerable<IEnumerable<T>> GetPermutations<T>(IEnumerable<T> list, int length)

    {

        if (length == 1)

            return list.Select(t => new T[]{t});

        return GetPermutations(list, length - 1).SelectMany(t => list.Where(o => !t.Contains(o)), (t1, t2) => t1.Concat(new T[]{t2}));

    }

​

    // K-combinations with repetition

    // Output: {1,1} {1,2} {1,3} {1,4} {2,2} {2,3} {2,4} {3,3} {3,4} {4,4}

    static IEnumerable<IEnumerable<T>> GetKCombsWithRept<T>(IEnumerable<T> list, int length)where T : IComparable

    {

        if (length == 1)

            return list.Select(t => new T[]{t});

        return GetKCombsWithRept(list, length - 1).SelectMany(t => list.Where(o => o.CompareTo(t.Last()) >= 0), (t1, t2) => t1.Concat(new T[]{t2}));

    }

​

    // K-combinations

    // Output {1,2} {1,3} {1,4} {2,3} {2,4} {3,4}

    static IEnumerable<IEnumerable<T>> GetKCombs<T>(IEnumerable<T> list, int length)where T : IComparable

    {

        if (length == 1)

            return list.Select(t => new T[]{t});

        return GetKCombs(list, length - 1).SelectMany(t => list.Where(o => o.CompareTo(t.Last()) > 0), (t1, t2) => t1.Concat(new T[]{t2}));

    }

public static T JsonToT<T>(string json)

        {

            var ser = new DataContractJsonSerializer(typeof(T));

            var stream = new MemoryStream(Encoding.UTF8.GetBytes(json));

            stream.Position = 0;

            return (T)ser.ReadObject(stream);

        }

        public static string TtoJson<T>(T t)

        {

            var ser = new DataContractJsonSerializer(typeof(T));

            var stream = new MemoryStream();

​

            ser.WriteObject(stream, t);

​

            var db = new byte[stream.Length];

            stream.Position = 0;

            stream.Read(db, 0, (int)stream.Length);

            var dataString = Encoding.UTF8.GetString(db);

            return dataString;

        }                         

}