Custom Sort String

Custom Sort String - Problem

You are given two strings order and s. All characters in order are unique and represent a custom sorting order.

Your task is to permute the characters of string s so that they follow the custom order defined by order.

More specifically:

If character x appears before character y in order, then x should appear before y in the result string
Characters in s that don't appear in order can be placed anywhere in the result

Return any valid permutation of s that satisfies this property.

Input & Output

Example 1 — Basic Custom Order

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

› Output: "ccbbaaaa"

💡 Note: Characters must follow order c→b→a. We have 2 c's, 2 b's, and 4 a's in s. Following the custom order: cc + bb + aaaa = "ccbbaaaa"

Example 2 — Extra Characters

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

› Output: "ccbbaaaa"

💡 Note: String s contains only characters c, b, a which are all in order. Result follows c→b→a priority: "ccbbaaaa"

Example 3 — Characters Not in Order

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

› Output: "kqeep"

💡 Note: Following order k→q→e→p: k(1) + q(1) + ee(2) + p(1) = "kqeep". All characters from s appear in order.

Constraints

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

Visualization

Tap to expand

Asked in

F Facebook 45 G Google 38 a Amazon 32 M Microsoft 28

The key insight is to use character frequency counting to avoid multiple scans. Count each character in string s, then build the result by following the order string and appending characters according to their frequency. Best approach uses frequency counting with Time: O(n + m), Space: O(k) where k is the number of unique characters.

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Brute Force - Linear Search for Each Character

⏱️ Time: O(n×m) Space: O(1)

Iterate through each character in the order string. For each character, scan the entire string s multiple times to find all occurrences and add them to the result. Then add any remaining characters not in order.

Custom Comparator Sorting

⏱️ Time: O(m log m) Space: O(m)

Create a custom comparator that ranks characters based on their position in the order string. Characters not in order get lower priority. Sort the characters of string s using this comparator.

Frequency Count (Optimal)

⏱️ Time: O(n + m) Space: O(k)

First, count the frequency of each character in string s using a hash map. Then iterate through the order string and append each character the number of times it appears in s. Finally, append any remaining characters that weren't in order.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_STATES 100000

typedef struct {
    int mask;
    int currentLen;
    char firstChar;
    char lastChar;
    int result;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

int joinLength(int xLen, char xLast, int yLen, char yFirst) {
    if (xLast == yFirst) {
        return xLen + yLen - 1;
    }
    return xLen + yLen;
}

int findMemo(int mask, int currentLen, char firstChar, char lastChar) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].mask == mask && memo[i].currentLen == currentLen &&
            memo[i].firstChar == firstChar && memo[i].lastChar == lastChar) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int mask, int currentLen, char firstChar, char lastChar, int result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].mask = mask;
        memo[memoSize].currentLen = currentLen;
        memo[memoSize].firstChar = firstChar;
        memo[memoSize].lastChar = lastChar;
        memo[memoSize].result = result;
        memoSize++;
    }
}

int dp(int mask, int currentLen, char firstChar, char lastChar, char words[][101], int n) {
    if (mask == (1 << n) - 1) {
        return currentLen;
    }
    
    int cached = findMemo(mask, currentLen, firstChar, lastChar);
    if (cached != -1) {
        return cached;
    }
    
    int minLen = INT_MAX;
    for (int i = 0; i < n; i++) {
        if (!(mask & (1 << i))) {
            char* word = words[i];
            char wordFirst = word[0];
            char wordLast = word[strlen(word) - 1];
            int wordLen = strlen(word);
            int newMask = mask | (1 << i);
            
            if (mask == 0) {
                int result = dp(newMask, wordLen, wordFirst, wordLast, words, n);
                if (result < minLen) minLen = result;
            } else {
                int newLen1 = joinLength(currentLen, lastChar, wordLen, wordFirst);
                int result1 = dp(newMask, newLen1, firstChar, wordLast, words, n);
                
                int newLen2 = joinLength(wordLen, wordLast, currentLen, firstChar);
                int result2 = dp(newMask, newLen2, wordFirst, lastChar, words, n);
                
                if (result1 < minLen) minLen = result1;
                if (result2 < minLen) minLen = result2;
            }
        }
    }
    
    addMemo(mask, currentLen, firstChar, lastChar, minLen);
    return minLen;
}

int solution(char words[][101], int n) {
    memoSize = 0;
    return dp(0, 0, ' ', ' ', words, n);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char words[10][101];
    int n = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL && n < 10) {
        while (*token == ' ' || *token == '"') token++;
        char* end = token + strlen(token) - 1;
        while (end > token && (*end == ' ' || *end == '"' || *end == '\n')) end--;
        *(end + 1) = '\0';
        strcpy(words[n], token);
        n++;
        token = strtok(NULL, ",]");
    }
    
    int result = solution(words, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

182.0K Views

Medium Frequency

~15 min Avg. Time

2.2K 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