using System;

public class Program

{

    public static void Main()

    {       

        Console.WriteLine("Please Enter Number Of Teams");

        int numberOfTeams = Convert.ToInt32(Console.ReadLine());

        Console.WriteLine();

        Program p = new Program();

        int[,] result = p.GenerateRoundRobin(numberOfTeams);

        for (int k = 0; k < result.GetLength(1); k++)

        {

            Console.WriteLine("Round {0}", k + 1);

            for (int i = 0; i < result.GetLength(0); i++)

            {

                for (int j = 0; j < result.GetLength(1); j++)

                {

                    if(j == k)

                    {

                        if(result[i,j] != -1)

                        {

                            Console.WriteLine("Team {0} vs Team {1}", i + 1, result[i,j] + 1);

                        }

                    }

                }

            }

            Console.WriteLine();

        }

    }   

​

    private const int BYE = -1;

    // Return an array where results(i, j) gives

    // the opponent of team i in round j.

    // Note: num_teams must be odd.

    private int [,] GenerateRoundRobinOdd(int num_teams)

    {

        int n2 = (int)((num_teams - 1) / 2);

        int[,] results = new int[num_teams, num_teams];

        // Initialize the list of teams.

        int[] teams = new int[num_teams];

        for (int i = 0; i < num_teams; i++) teams[i] = i;

        // Start the rounds.

        for (int round = 0; round < num_teams; round++)

        {

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

            {

                int team1 = teams[n2 - i];

                int team2 = teams[n2 + i + 1];

                results[team1, round] = team2;

                results[team2, round] = team1;

            }

            // Set the team with the bye.

            results[teams[0], round] = BYE;

            // Rotate the array.

            RotateArray(teams);

        }

        return results;

    }

    // Rotate the entries one position.

    private void RotateArray(int[] teams)

    {

        int tmp = teams[teams.Length - 1];

        Array.Copy(teams, 0, teams, 1, teams.Length - 1);

        teams[0] = tmp;

    }

    private int[,] GenerateRoundRobinEven(int num_teams)

    {

        // Generate the result for one fewer teams.

        int[,] results = GenerateRoundRobinOdd(num_teams - 1);

        // Copy the results into a bigger array,

        // replacing the byes with the extra team.

        int[,] results2 = new int[num_teams, num_teams - 1];

        for (int team = 0; team < num_teams - 1; team++)

        {

            for (int round = 0; round < num_teams - 1; round++)

            {

                if (results[team, round] == BYE)

                {

                    // Change the bye to the new team.

                    results2[team, round] = num_teams - 1;

                    results2[num_teams - 1, round] = team;

                }

                else

                {

                    results2[team, round] = results[team, round];

                }

            }

        }

        return results2;

    }

    private int[,] GenerateRoundRobin(int num_teams)

    {

        if (num_teams % 2 == 0)

            return GenerateRoundRobinEven(num_teams);

        else

            return GenerateRoundRobinOdd(num_teams);

    }

}