For the below challenge from a programming site, I am bit confused.

Problem Statement:

A Professor of Physics gave projects to the students of his class. The students have to form a team of two for doing the project. The professor left the students to decide the teams. The number of students in a class will be even.

Each student has a knowledge level. It tells how much knowledge each student has. The knowledge level of a team is the sum of the knowledge levels of both the students.

The students decide to form groups such that the difference between the team with highest knowledge and the one with lowest knowledge is minimum.

Input

First line of the input will contain number of test cases t; In the next t lines the first number is n the number of students in the class followed by n integers denoting the knowledge levels of the n students

Output

Your output should be a single line containing the lowest possible difference between the team with highest knowledge and the one with lowest knowledge.

Sample Input

2

4 2 6 4 3

6 1 1 1 1 1 1

Sample Output

1

0

[My Attmept]

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

namespace ProjectTeam
{
    class Program
    {
        static void Main(string[] args)
        {
            int testCasesCount = Convert.ToInt32(Console.ReadLine());
            // Solve each test case
            for (int i = 0; i < testCasesCount; i++)
            {
                String line = Console.ReadLine();
                String[] components = line.Split(' ');
                int numberOfStudents = Convert.ToInt32(components[0]);
                int[] studentsKnowledge = new int[numberOfStudents];

                // Read input

                for (int j = 0; j < numberOfStudents; j++)
                {
                    studentsKnowledge[j] = Convert.ToInt32(components[j + 1]);
                }

                // Done

                // Solve
                List<int> listOfPossibleTeams = new List<int>();
                for (int k = 0; k < numberOfStudents; k+=2)
                {
                    int knowledge = studentsKnowledge[k] + studentsKnowledge[k + 1];

                    // Create others
                    if (k >= 2)
                    {
                        int toPair = studentsKnowledge[k];
                        for (int l = k-1; l >= 0; l--)
                        {
                            listOfPossibleTeams.Add(toPair + studentsKnowledge[l]);
                        }
                        toPair = studentsKnowledge[k + 1];
                        for (int l = k-1; l >= 0; l--)
                        {
                            listOfPossibleTeams.Add(toPair + studentsKnowledge[l]);
                        }
                    }
                    //
                    listOfPossibleTeams.Add(knowledge);
                }

                listOfPossibleTeams.Sort();

                // select minimum knowledge diff

                int minumimKnowledge = int.MaxValue;
                for (int m = 0; m <= listOfPossibleTeams.Count() - numberOfStudents / 2; m++)
                {
                    int diff = Math.Abs(listOfPossibleTeams[m] - listOfPossibleTeams[m +(numberOfStudents / 2) - 1]);
                    if (diff < minumimKnowledge)
                    {
                        minumimKnowledge = diff;
                    }
                }

                Console.WriteLine(minumimKnowledge);
            }
        }
    }
}

But the above solution fails for test case:

1

8 4 2 4 2 1 3 3 7

My Code outputs 0, while the actual answer is 2.

My Approach is to create all the possible valid combinations of teams, and get their knowledge, sort all the knowledge, and select n/2(n is number of students) contiguous elements having minimum difference between the boundaries of selection. But this doesn’t work.

Eventually I found the problem solved by someone in the internet, and I tried the solution and it worked. But I do not understand how does it work? The code below:

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

namespace ProjectTeam
{
    class Program
    {
        static void Main(string[] args)
        {
            int testCasesCount = Convert.ToInt32(Console.ReadLine());
            // Solve each test case
            for (int i = 0; i < testCasesCount; i++)
            {
                String line = Console.ReadLine();
                String[] components = line.Split(' ');
                int numberOfStudents = Convert.ToInt32(components[0]);
                List<int> studentsKnowledge = new List<int>();

                // Read input

                for (int j = 0; j < numberOfStudents; j++)
                {
                    studentsKnowledge.Add(Convert.ToInt32(components[j + 1]));
                }
                studentsKnowledge.Sort();
                // Done

                // Solve
                int diff = (studentsKnowledge[0] + studentsKnowledge[numberOfStudents - 1]);
                int max = diff, min = diff;
                for (int k = 1; k < studentsKnowledge.Count / 2; k++)
                {
                    diff = studentsKnowledge[k] + studentsKnowledge[numberOfStudents - 1 - k];
                    if (diff > max)
                        max = diff;
                    if (diff < min)
                        min = diff;
                }
                Console.WriteLine(max - min);
            }
        }
    }
}

I do not understand how does the above code works. The above code doesn’t even creates all the possible combinations. Is it using some mathematical concept which I am not able to think of, or is my interpretation of the problem wrong? Please help.