Codestin Search App

Lexicographically Smallest Generated String - Problem

Imagine you're a puzzle master creating a word game with pattern matching rules! You have two strings: str1 (the pattern string) and str2 (the target string).

Your goal is to construct the lexicographically smallest string of length n + m - 1 that follows these rules:

When str1[i] == 'T': The substring starting at position i with length m must equal str2
When str1[i] == 'F': The substring starting at position i with length m must NOT equal str2

Think of it as placing characters one by one while respecting all the pattern constraints. If it's impossible to satisfy all conditions, return an empty string.

Example: If str1 = "TF" and str2 = "ab", you need a string of length 4 where positions 0-1 must be "ab" and positions 1-2 must NOT be "ab".

Input & Output

example_1.py — Basic Pattern Matching

$ Input: str1 = "TF", str2 = "ab"

› Output: "abaa"

💡 Note: We need a string of length 4. Position 0-1 must be 'ab' (T constraint), position 1-2 must NOT be 'ab' (F constraint). Starting with 'ab__', position 2 can be 'a' since 'ba' ≠ 'ab', and position 3 can be 'a' for the lexicographically smallest result.

example_2.py — Conflicting Constraints

$ Input: str1 = "TT", str2 = "ab"

› Output: "aba"

💡 Note: String length is 3. Both positions 0-1 and 1-2 must equal 'ab'. This forces: position 0-1 = 'ab', position 1-2 = 'ab'. The only solution is 'aba' where both constraints are satisfied.

example_3.py — Impossible Case

$ Input: str1 = "TF", str2 = "aa"

› Output: ""

💡 Note: We need length 4. Position 0-1 must be 'aa' (T), but position 1-2 must NOT be 'aa' (F). Starting with 'aa__', position 1-2 would be 'a?' where ? cannot be 'a' (else violates F), but positions are already fixed by T constraint, creating an impossible situation.

Constraints

1 ≤ str1.length ≤ 10³
1 ≤ str2.length ≤ 10³
str1[i] is either 'T' or 'F'
str2 consists only of lowercase English letters
str1.length + str2.length - 1 ≤ 10³

Visualization

Tap to expand

Understanding the Visualization

Set Required Pieces

Place all mandatory patterns first (T constraints)

Check Conflicts

Ensure forbidden patterns don't accidentally appear (F constraints)

Fill Gaps Optimally

Complete remaining positions with smallest valid letters

Validate Solution

Verify final string satisfies all original constraints

Key Takeaway

🎯 Key Insight: Use constraint propagation by handling mandatory placements first, then ensure conflicts are resolved, and finally fill gaps greedily for lexicographically smallest result.

Asked in

G Google 24 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses greedy construction with constraint propagation. First, process all 'T' constraints to place required substrings, then handle potential conflicts with 'F' constraints, and finally fill remaining positions with the lexicographically smallest valid characters. The key insight is that T constraints are mandatory and must be satisfied first, while F constraints act as validators that prevent certain patterns.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Strings)	O(26^(n+m-1) * n * m)	O(n + m)	Generate all possible strings and check constraints
Greedy Construction (Optimal)	O((n + m) * n * m)	O(n + m)	Build string character by character, choosing smallest valid option

Brute Force (Generate All Strings) — Algorithm Steps

Generate all possible strings of length n+m-1
For each string, check all constraints in str1
For 'T' at position i, verify substring equals str2
For 'F' at position i, verify substring doesn't equal str2
Return the lexicographically smallest valid string

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate String

Create string using all combinations of 'a'-'z'

Check Constraints

Verify each position in str1 against the generated string

Find First Valid

Return the first lexicographically valid string found

Code -

solution.c — C

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

bool isValid(char* word, char* str1, char* str2) {
    int n = strlen(str1), m = strlen(str2);
    int wordLen = strlen(word);
    
    for (int i = 0; i < n; i++) {
        if (i + m > wordLen) continue;
        
        bool match = true;
        for (int j = 0; j < m; j++) {
            if (word[i + j] != str2[j]) {
                match = false;
                break;
            }
        }
        
        if (str1[i] == 'T' && !match) return false;
        if (str1[i] == 'F' && match) return false;
    }
    return true;
}

void generateStrings(int pos, char* current, char* str1, char* str2, int targetLen, char* result) {
    if (strlen(result) > 0) return; // Already found
    
    if (pos == targetLen) {
        if (isValid(current, str1, str2)) {
            strcpy(result, current);
        }
        return;
    }
    
    for (char c = 'a'; c <= 'z'; c++) {
        current[pos] = c;
        current[pos + 1] = '\0';
        generateStrings(pos + 1, current, str1, str2, targetLen, result);
        if (strlen(result) > 0) return;
    }
}

int main() {
    char str1[] = "TF";
    char str2[] = "ab";
    int n = strlen(str1), m = strlen(str2);
    char current[1000] = {0};
    char result[1000] = {0};
    
    generateStrings(0, current, str1, str2, n + m - 1, result);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26^(n+m-1) * n * m)

Generate 26^(n+m-1) strings, each taking O(n*m) time to validate all constraints

✓ Linear Growth

Space Complexity

O(n + m)

Space for storing the current string and str2 for comparisons

⚡ Linearithmic Space

26.2K Views

Medium Frequency

~35 min Avg. Time

847 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

Brute Force (Generate All Strings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler