using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks.Dataflow;

​

namespace leagueplanner

{

    class Program

    {

        static void Main(string[] args)

        {

            var allTeams = GetInitialisedTeams(10);

            //7 sessions per week, 5 weeks

            var totalSessions = 35;

​

            var allSessions = new Session[totalSessions];

            for (int i = 0; i < totalSessions; i++)

            {

                //generate table A

                var tableA = GetTable(allTeams);

                //generate table B

                var tableB = GetTable(allTeams, tableA.TeamNumbers);

                //add session

                allSessions[i] = new Session(tableA, tableB);

                //update counts

                foreach (int team in tableA.TeamNumbers)

                {

                    allTeams[team].IncrementCountsFor(tableA.TeamNumbers, team);

                }

                foreach (int team in tableB.TeamNumbers)

                {

                    allTeams[team].IncrementCountsFor(tableB.TeamNumbers, team);

                }

            }

​

            Console.WriteLine("Generated Sessions:");

            Console.WriteLine(PrintSessions(allSessions));

            Console.WriteLine();

            for (int i = 0; i < allTeams.Length; i++)

            {

                Console.WriteLine($"Team {i} playcounts: {allTeams[i].GetPlaycountString()}");

            }

​

            var shuffledSessions = ShuffleSessions(allSessions);

            Console.WriteLine();

            Console.WriteLine("---------------------------------------------");

            Console.WriteLine();

            Console.WriteLine("Randomized Sessions");

            Console.WriteLine(PrintSessions(shuffledSessions));

        }

​

        public static Session[] ShuffleSessions(Session[] currentSessions)

        {

            var newSessions = currentSessions;

            Random rand = new Random();

            for (int i = 0; i < newSessions.Length - 1; i++)

            {

                int j = rand.Next(i, newSessions.Length);

                var temp = newSessions[i];

                newSessions[i] = newSessions[j];

                newSessions[j] = temp;

            }

            return newSessions;

        }

​

        public static string PrintSessions(Session[] allSessions)

        {

            StringBuilder builder = new StringBuilder();

            for (int i = 0; i < allSessions.Length; i++)

            {

                builder.Append(allSessions[i].ToString(i)).Append("\r\n");

            }

            return builder.ToString();

        }

​

        public static Table GetTable(Team[] allTeams, params int[] excludedTeams)

        {

            List<int> excluded = new List<int>(excludedTeams);

            //first get team with lowest playcount

            var a = GetLowestPlayCount(allTeams, excludedTeams);

            excluded.Add(a);

            //now fill remainder with teams with lowest play count with the current teams

            var b = GetLowestPlayCountWithTeams(allTeams, new[] { a }, excluded.ToArray());

            excluded.Add(b);

            var c = GetLowestPlayCountWithTeams(allTeams, new[] { a, b }, excluded.ToArray());

            excluded.Add(c);

            var d = GetLowestPlayCountWithTeams(allTeams, new[] { a, b, c }, excluded.ToArray());

            return new Table(a, b, c, d);

        }

​

        public static int GetLowestPlayCount(Team[] allTeams, int[] excludedTeams)

        {

            int teamIndex = -1;

            int teamPlaycount = int.MaxValue;

            for (int i = 0; i < allTeams.Length; i++)

            {

                if (!excludedTeams.Contains(i))

                {

                    var nextPlaycount = allTeams[i].GetTotalPlayedCount();

                    if (nextPlaycount < teamPlaycount)

                    {

                        teamIndex = i;

                        teamPlaycount = nextPlaycount;

                    }

                }

            }

            return teamIndex;

        }

        public static int GetLowestPlayCountWithTeams(Team[] allTeams, int[] matchingTeams, params int[] excludedTeams)

        {

            int teamIndex = -1;

            int teamPlaycount = int.MaxValue;

            for (int i = 0; i < allTeams.Length; i++)

            {

                if (!excludedTeams.Contains(i))

                {

                    var nextPlaycount = allTeams[i].GetPlayedCountForTeams(matchingTeams);

                    if (nextPlaycount < teamPlaycount)

                    {

                        teamIndex = i;

                        teamPlaycount = nextPlaycount;

                    }

                }

            }

            return teamIndex;

        }

​

        public static Team[] GetInitialisedTeams(int numberOfTeams)

        {

            var teams = new Team[numberOfTeams];

            for (int i = 0; i < numberOfTeams; i++)

            {

                teams[i] = new Team(numberOfTeams);

            }

            return teams;

        }

​

        public class Team

        {

            public int[] PlayedWithCount;

​

            public Team(int totalTeams)

            {

                PlayedWithCount = new int[totalTeams];

            }

​

            public int GetTotalPlayedCount()

            {

                int res = 0;

                foreach (int v in PlayedWithCount)

                {

                    res += v;

                }

                return res;

            }

​

            public int GetPlayedCountForTeams(params int[] teams)

            {

                int res = 0;

                foreach (int i in teams)

                {

                    res += PlayedWithCount[i];

                }

                return res;

            }

​

            public void IncrementCountsFor(int[] teams, int thisIndex)

            {

                foreach (int team in teams)

                {

                    if (team != thisIndex)

                    {

                        PlayedWithCount[team]++;

                    }

                    else

                    {

                        PlayedWithCount[team] = 999;

                    }

                }

            }

​

            public string GetPlaycountString()

            {

                return $"[{string.Join(", ", PlayedWithCount)}]";

            }

        }

​

        public class Session

        {

            public readonly Table TableA;

            public readonly Table TableB;

​

            public Session(Table a, Table b)

            {

                TableA = a;

                TableB = b;

            }

            public string ToString(int index)

            {

                return $"[Session {index} - A: {TableA}, B: {TableB}";

            }

        }

​

        public class Table

        {

            public readonly int[] TeamNumbers;

​

            public Table(int a, int b, int c, int d)

            {

                TeamNumbers = new[] { a, b, c, d };

            }

​

            override

            public string ToString()

            {

                return $"[{string.Join(", ", TeamNumbers)}]";

            }

        }

    }

}

​