order collection by given sort order

Question

I have a List of strings that I want to bring in a certain order. Let's say the list contains a random amount of the strings "A", "B" and "C". And I have another List of strings containing the sort order.

For Example: For input:

1. "A"

2. "A"

3. "C"

4. "B"

5. "B"

6. "C"

with sort order List:

1. "A"
2. "B"
3. "C"

I want to order this List that the output looks like this:

1. "A"
2. "B"
3. "C"
4. "A"
5. "B"
6. "C"

another example:

For Input:

1. "A"
2. "A"
3. "C"
4. "B"
5. "C"

with sort order List:

1. "A"
2. "C"
3. "B"

output should look like this:

1. "A"
2. "C"
3. "B"
4. "A"
5. "C"

Note: I chose A, B and C only for the sake of simplicity so in my real application I won't be able to make use of any alphabetical order.

Is there any way to achieve the desired result? I wrapped my head around this for days and didn't come up with a solution. I tried to implement IComparer but I was struggling with the conditions for compare - method.

Answer 1

I think this meets your needs:

        var list = new List<string> { "A", "B", "E", "A", "E", "A", "B", "E", "C", "B", "A", "D", "B", "E" };
        var sortOrder = new List<string> { "F", "E", "C", "A", "B", "D" };

        var resultSets = new List<List<string>> ();
        for (int i = 0; i < sortOrder.Count(); i++)
        {
            var currentLetter = sortOrder[i];
            for (int j = 0; j < list.Count(x=> x == currentLetter); j++)
            {
                if(resultSets.Count() < j + 1)
                {
                    resultSets.Add(new List<string>());
                }
                resultSets[j].Add(currentLetter);
            }
        }
        var result = string.Join(", ", resultSets.SelectMany(x => x));
        Console.WriteLine($"Results: { result}");

Answer 2

Although the accepted answer works, the performance is simply horrific if the input enumeration and/or pattern are large enough. You can get a significant increase in performance if you choose more adequate collections for the job::

public static IEnumerable<T> GetChunks<T>(this IEnumerable<T> source, IEnumerable<T> pattern)
    where T: IEquatable<T>
{
    var dictionary = pattern.ToDictionary(p => p, p => new Stack<T>());

    foreach (var item in source)
    {
        dictionary[item].Push(item);
    }

    var rest = source.Except(pattern);

    while (dictionary.Values.Any(q => q.Any()))
    {
        foreach (var p in pattern)
        {
            if (dictionary[p].Count  >0)
            {
                yield return dictionary[p].Pop();
            }
        }
    }

    foreach (var r in rest)
    {
        yield return r;
    }
}

The trick here is to build up front a cheap dictionary to leverage the faster look ups it provides.

I've also taken the liberty of deciding to add all unmatched elements to the end of the "ordered" result. This might not be what you want but the problem is underspecified in this area.