How to sort a dictionary with three values in sequence

Question

so I have a list of numbers and color values.

[1, Red]
[4, Yellow]
[5, Red]
[6, Yellow]
[8, White]
[9, Red]
[10, Yellow]
[13, White]
etc. etc.

The dictionary ints are originally generated randomly within a range between 1 - 100 using Enumerable. var lstNumbers = Enumerable .Range(1, 100).OrderBy(n => Guid.NewGuid().GetHashCode()) .ToList();

The dictionary is created and used to assign ColorType Values to each of the numbers in Sequence Red, Yellow, White, Red, Yellow, White, etc., etc. to all of the numbers in the list.var map = new Dictionary<int, ColorType>();

I then Remove items a few different ways which brings me to the sorting. I need to sort the final list from this dictionary by value with White results being at the top, Yellow in the middle, and red at the bottom. Red < Yellow < White

Then display.

I figured I could use some if statements for sequencing the colors or maybe setting parameters for each color then use Orderby in a way to sort the results by the color value.

I'm having a hard time figuring out the efficient way of sorting these particular values in this way.

Any ideas?

Answer 1

Here's an implementation based on this answer:

public class CustomerComparer : IComparer<KeyValuePair<int, string>>
{
    private List<string> orderedColors = new List<string>() { "White", "Yellow", "Red" };

    public int Compare(KeyValuePair<int, string> str1, KeyValuePair<int, string> str2)
    {
        return orderedColors.IndexOf(str1.Value) - orderedColors.IndexOf(str2.Value);
    }
}

class Program
{
    static void Main(string[] args)
    {
        var unsorted = new Dictionary<int, string>()
        {
            {1, "Red"},
            {4, "Yellow"},
            {5, "Red"},
            {6, "Yellow"},
            {8, "White"},
            {9, "Red"},
            {10, "Yellow"},
            {13, "White"}
        };

        var sorted = unsorted.OrderBy(x => x, new CustomerComparer());

        foreach (var entry in sorted)
        {
            Console.WriteLine("{0}: {1}", entry.Key, entry.Value);
        }
        Console.ReadKey();
    }
}

You can take a look at this article.

Update

Based on comments on this answer, the value for which order the dictionary seems to be a number which comes from a Enum.

Updated code:

public class CustomerComparer : IComparer<KeyValuePair<int, ColorType>>
{
    private List<ColorType> orderedLetters = new List<ColorType>() { ColorType.White, ColorType.Yellow, ColorType.Red };

    public int Compare(KeyValuePair<int, ColorType> str1, KeyValuePair<int, ColorType> str2)
    {
        return orderedLetters.IndexOf(str1.Value) - orderedLetters.IndexOf(str2.Value);
    }
}

public enum ColorType
{
    Red,
    Yellow,
    White
}

class Program
{
    static void Main(string[] args)
    {
        var unsorted = new Dictionary<int, ColorType>()
        {
            {1, ColorType.Red},
            {4, ColorType.Yellow},
            {5, ColorType.Red},
            {6, ColorType.Yellow},
            {8, ColorType.White},
            {9, ColorType.Red},
            {10, ColorType.Yellow},
            {13, ColorType.White}
        };

        var sorted = unsorted.OrderBy(x => x, new CustomerComparer());

        foreach (var entry in sorted)
        {
            Console.WriteLine("{0}: {1}", entry.Key, entry.Value);
        }
        Console.ReadKey();
    }
}

Answer 2

Here's a hint:

Red = 100
Yellow = 110
White = 111

(Just to say that the color order you want is already implicit by the RGB values of the colors you mentioned. So it should be a good source for a order-value.)

Answer 3

You can use Enum, to sort colors that suit your needs. If identifier is just a string value, you have to find by string value and convert it to int value. If there will be more colors in future, or order will have to change, just modify Enum. Of course need to update, if color is not found in Enum, but that is not the case to add for this question...

 public enum ColorCodes
{
    White = 1,
    Yellow = 2,
    Red = 3
}

class Program
{
    /// <summary>
    /// Sorts dictionary by color enum int sequence
    /// </summary>
    /// <param name="toOrder"></param>
    /// <returns></returns>
    public static Dictionary<int, string> DictionarySorter(Dictionary<int, string> toOrder)
    {
        return toOrder.OrderBy(x => (int)(ColorCodes)Enum.Parse(typeof(ColorCodes), x.Value)).ToDictionary(x => x.Key, x => x.Value);
    }


    static void Main(string[] args)
    {

        Dictionary<int, string> unsortedColors = new Dictionary<int, string>();
        unsortedColors.Add(1, "Red");
        unsortedColors.Add(4, "Yellow");
        unsortedColors.Add(5, "Red");
        unsortedColors.Add(6, "Yellow");
        unsortedColors.Add(8, "White");
        unsortedColors.Add(9, "Red");
        unsortedColors.Add(10, "Yellow");
        unsortedColors.Add(13, "White");


        var sortedDic = DictionarySorter(unsortedColors);
        foreach (var entry in sortedDic)
        {
            Console.WriteLine(string.Format("{0} - {1}", entry.Key, entry.Value));
        }
        Console.Read();
    }
}

As others pointed out -dictionary is not sorted in order, so inplace of Dictionary sorter can use:

 public static List<KeyValuePair<int,string>> DictionarySorter(Dictionary<int, string> toOrder)
    {
        return toOrder.OrderBy(x => (int)(ColorCodes)Enum.Parse(typeof(ColorCodes), x.Value)).ToList();
    }