Ytukyg

I have a collection of items, here it is:

    ID    ELECT1        ELECT2

    1      FDI           AED     

    2      BPG           AED

    3      AED           FDI

    4      FDI           AED 

    5      GPH           AED

    6      AED           BPG

    7      GPH           FDI

And I would like to group elect1 and elect2 and than output the 2 most popular so like
These items are chosen 3 times

FDI AED 

AED FDI

FDI AED

And then the second most popular combination is

AED BPG

BPG AED

So the output would be

2 Most popular combinations are

    FDI AED 

    AED BPG

I have written some code but I don't know how I could possibly do this

var groups = cStudent.GroupBy(x => new { x.elective1, x.elective2 });    

foreach (var group in groups)

{

    Console.WriteLine("{0} / {1}:", group.Key.elective1, group.Key.elective2);

    foreach (var item in group)

    {

        Console.WriteLine("  {0} ({1})", item.elective1, item.elective2);

    }

}

So this is what I get with my code it is halfway there just don't know how to finish.
IMAGE

IMHO, the cleanest way to solve this is implementing a custom equality comparer that provides the needed equality semantics to solve your current problem:

class IgnoreElectiveOrderStudentEqualityComparer 

    : IEqualityComparer<Student>

{

    public bool Equals(Student x, Student y)

        => (x.ElectiveOne == y.ElectiveOne &&

            x.ElectiveTwo == y.ElectiveTwo) ||

           (x.ElectiveOne == y.ElectiveTwo &&

            x.ElectiveTwo == y.ElectiveOne);



    public int GetHashCode(Student obj)

        => obj.ElectiveOne.GetHashCode() ^

           obj.ElectiveTwo.GetHashCode();

}

And now you simply use GroupBy and the custom comparer:

var mostPopular = 

    students.GroupBy(s => s,

                     new IgnoreElectiveOrderStudentEqualityComparer())

            .OrderByDescending(g => g.Count())

            .Select(g => new

            {

                g.Key.ElectiveOne, 

                g.Key.ElectiveTwo

            })

            .Take(2);

The trick is to have the order of the two electives of not matter so the alpha first one is always first (thus if you have (math, art) it is the same as (art, math):

var most_pop = cStudent.GroupBy(x => { if (string.Compare(x.elective1,x.elecitive2) > 0) 

                                         return(new Tuple(x.elective1.x.elective2);

                                       else

                                         return(new Tuple(x.elective2,x.elective1);

                                     },

                                (b, a) => new {  Key = b, Count = a.Count() })

                .OrderyByDesending(x => x.Count).Take(2);

You could add a select of the key if you don't want an object with the count.

This should work for you:

cStudent

    .Select(x => new { x.elective1, x.elective2 }.OrderBy(y => y).ToArray())

    .GroupBy(x => Tuple.Create(x[0], x[1]), (k, g) => new { Elective = k, Count = g.Count() })

    .OrderByDescending(x => x.Count)

    .Select(x => new { elective1 = x.Elective.Item1, elective2 = x.Elective.Item2 })

    .Take(2)