Custom Sort String - Practice Coding Problems

Custom Sort String - Problem

Imagine you have your own custom alphabet where letters are ordered differently than the standard A-Z sequence. You're given a string order that represents this custom alphabet ordering, and another string s containing characters you need to sort.

Your task: Rearrange all characters in string s to follow the custom ordering defined by order.

Key Rules:

If character x appears before character y in order, then x must appear before y in your result
Characters in s that don't appear in order can be placed anywhere
All characters from order are unique

Example: If order = "cba" and s = "abcd", then c should come first, then b, then a, and d can go anywhere since it's not in the custom order.

Input & Output

example_1.py — Basic Custom Sort

$ Input: order = "cba", s = "abcd"

› Output: "cbad"

💡 Note: Characters 'c', 'b', 'a' follow the custom order. Character 'd' is not in the custom order, so it can be placed anywhere (here at the end).

example_2.py — Multiple Same Characters

$ Input: order = "cbafg", s = "abcd"

› Output: "cbad"

💡 Note: Even though the order string is longer, we only sort characters that exist in string s. The result follows the custom priority: c→b→a, with d at the end.

example_3.py — Duplicate Characters

$ Input: order = "kqep", s = "pekeq"

› Output: "kqeep"

💡 Note: All characters from s exist in order. Following the custom priority k→q→e→p, we get k(1), q(1), e(2), p(1) = "kqeep".

Constraints

1 ≤ order.length ≤ 26
1 ≤ s.length ≤ 1000
order and s consist of lowercase English letters only
All characters of order are unique

Visualization

Tap to expand

Understanding the Visualization

Count Your Books

First, count how many of each book type you have on your current messy shelf

Follow Priority Order

Place books on the new shelf following your custom priority list

Add Remaining

Any books not in your priority list go at the end

Key Takeaway

🎯 Key Insight: By counting character frequencies first, then following the custom order to build the result, we avoid expensive sorting operations and achieve optimal O(n + m) time complexity.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a hash table (or array) to count character frequencies in O(n) time, then builds the result by following the custom order in O(m) time. This achieves O(n + m) time complexity with O(k) extra space, where k is the number of unique characters. The key insight is avoiding expensive sorting operations by leveraging the given custom order directly.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n + m)	O(k)	Count character frequencies first, then build result following custom order
One-Pass Hash Table (Optimal)	O(n + m)	O(k)	Count frequencies and build result in a streamlined single workflow
Brute Force (Repeated Character Finding)	O(n×m)	O(1)	For each character in order, find and collect all occurrences from string s

Two-Pass Hash Table — Algorithm Steps

Count frequency of each character in string s
Iterate through custom order and add characters to result based on counts
Add any remaining characters not in custom order
Return the constructed result string

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Phase

Count frequency of each character in string s

Build Phase

Construct result following custom order

Remaining

Add characters not in custom order

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char* customSortString(char* order, char* s) {
    // Count frequency (assuming ASCII characters)
    int charCount[256] = {0};
    for (int i = 0; s[i]; i++) {
        charCount[(int)s[i]]++;
    }
    
    char* result = (char*)malloc((strlen(s) + 1) * sizeof(char));
    int resultIdx = 0;
    
    // Add characters in custom order
    for (int i = 0; order[i]; i++) {
        char orderChar = order[i];
        int count = charCount[(int)orderChar];
        for (int j = 0; j < count; j++) {
            result[resultIdx++] = orderChar;
        }
        charCount[(int)orderChar] = 0; // Mark as used
    }
    
    // Add remaining characters
    for (int i = 0; i < 256; i++) {
        while (charCount[i] > 0) {
            result[resultIdx++] = (char)i;
            charCount[i]--;
        }
    }
    
    result[resultIdx] = '\0';
    return result;
}

int main() {
    char order[1001], s[1001];
    fgets(order, sizeof(order), stdin);
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newlines
    order[strlen(order)-1] = '\0';
    s[strlen(s)-1] = '\0';
    memmove(order, order+1, strlen(order));
    memmove(s, s+1, strlen(s));
    order[strlen(order)-1] = '\0';
    s[strlen(s)-1] = '\0';
    
    char* result = customSortString(order, s);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

One pass to count characters (n) + one pass through order (m)

✓ Linear Growth

Space Complexity

O(k)

Hash table stores at most k unique characters from string s

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler