Custom Alphabetical Order — A C# Coding Challenge

Here's a fun challenge: you're given a list of words and a custom alphabetical order (e.g. not necessarily a–z). Your job is to write a function that returns whether the words are sorted according to that custom order.

The problem

• Input: An array (or list) of words, and a string (or sequence) defining the custom order of characters.
• Output: true if the words are in non-descending order according to the custom alphabet; otherwise false.

For example, if the custom order is "zyxwvutsrqponmlkjihgfedcba", then "zoo" should come before "apple" in that ordering, and your function should detect when a pair of adjacent words violates the order.

Approach

1. Map each character to its index in the custom alphabet so you can compare characters in O(1).
2. Walk through adjacent pairs of words. For each pair, determine the first character position where they differ.
3. Compare those characters using your custom order. If the first word’s character has a higher index (comes later) than the second’s, the list is not sorted — return false.
4. Handle prefixes: If one word is a prefix of the other, the shorter one must come first (e.g. "app" before "apple"), otherwise return false.
5. If all pairs are valid, return true.

Example solution in C#

public static bool IsSortedCustom(string[] words, string order)
{
    var orderIndex = new Dictionary<char, int>();
    for (int i = 0; i < order.Length; i++)
        orderIndex[order[i]] = i;

    for (int i = 0; i < words.Length - 1; i++)
    {
        string a = words[i], b = words[i + 1];
        int minLen = Math.Min(a.Length, b.Length);

        for (int j = 0; j < minLen; j++)
        {
            if (a[j] != b[j])
            {
                if (orderIndex[a[j]] > orderIndex[b[j]])
                    return false;
                break;
            }
        }
        // If we didn't break and a is longer than b, a should not come first
        if (a.Length > b.Length)
            return false;
    }

    return true;
}

• orderIndex gives O(1) lookup for “which position is this letter in the custom order?”
• We only compare the first differing character; if it’s in order we move on, if not we return false.
• The final check ensures that when one word is a prefix of the other, the shorter one is first.

Try it yourself

If you haven’t solved it yet, try implementing it from scratch or in another language. You can validate with examples like:

• Custom order "abcdefghijklmnopqrstuvwxyz" → behaves like normal dictionary order.
• Custom order "zyxwvutsrqponmlkjihgfedcba" → reversed order.

If you’ve got a different approach or a cleaner solution, I’d love to see it — drop a comment or share your version.