Check If a String Can Break Another String

Check If a String Can Break Another String - Problem

You are given two strings s1 and s2 of equal length. Your task is to determine if some permutation of s1 can "break" some permutation of s2, or vice versa.

A string x can break string y (both of size n) if x[i] >= y[i] (in alphabetical order) for all positions i from 0 to n-1.

Think of it as a character-by-character comparison where each character in string x must be alphabetically greater than or equal to the corresponding character in string y.

Example: String "cbd" can break string "abc" because 'c' >= 'a', 'b' >= 'b', and 'd' >= 'c'.

Input & Output

example_1.py — Basic Case

$ Input: s1 = "abc", s2 = "xya"

› Output: true

💡 Note: We can arrange s1 as "ayx" and s2 as "abc". Then "yxa" can break "abc" since y≥a, x≥b, a≥c is false, but "yxa" vs "abc" gives us y≥a(true), x≥b(true), a≥c(false). Actually, s2="xya" can be arranged as "yxa" which can break s1="abc" arranged as "abc".

example_2.py — Cannot Break

$ Input: s1 = "abe", s2 = "acd"

› Output: false

💡 Note: No permutation of s1 can break any permutation of s2, and vice versa. Best case for s1: "eba" vs s2: "acd" gives e≥a(true), b≥c(false). Best case for s2: "dca" vs s1: "abe" gives d≥a(true), c≥b(true), a≥e(false).

example_3.py — Edge Case Equal

$ Input: s1 = "leetcodee", s2 = "interview"

› Output: true

💡 Note: String s2 can break s1. When optimally arranged: s2 sorted desc vs s1 sorted asc allows s2 to break s1 since we have enough strong characters in s2 to match weak characters in s1.

Visualization

Tap to expand

Understanding the Visualization

Deal the cards

Each player gets letter cards: Player 1 has 'cab', Player 2 has 'def'

Optimal strategy

To win, Player 1 arranges strongest cards first: 'c', 'b', 'a'. Player 2 arranges weakest first: 'd', 'e', 'f'

Battle comparison

Compare position by position: c vs d (lose), b vs e (lose), a vs f (lose). Player 1 cannot win.

Reverse roles

Now Player 2 tries to win: arranges 'f', 'e', 'd' vs Player 1's 'a', 'b', 'c'. All battles won!

Key Takeaway

🎯 Key Insight: Use greedy sorting strategy - arrange strongest characters against weakest opponents to maximize breaking potential in O(n log n) time instead of O(n!) permutation generation.

Time & Space Complexity

Time Complexity

⏱️

O(n! × n! × n)

Generate n! permutations for each string, then compare each pair in O(n) time

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Store all permutations of both strings

⚠ Quadratic Space

Constraints

s1.length == s2.length
1 ≤ s1.length ≤ 10⁵
All strings consist of lowercase English letters only

Asked in

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

The optimal solution uses a greedy sorting approach in O(n log n) time. Sort one string in descending order (strongest characters first) and the other in ascending order (weakest characters first), then compare character by character. This maximizes the breaking potential without generating all permutations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! × n! × n)	O(n! × n)	Generate all permutations of both strings and check every combination
Greedy Sorting Approach (Optimal)	O(n log n)	O(n)	Sort both strings and use greedy comparison strategy

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all permutations of string s1
Generate all permutations of string s2
For each permutation of s1, check against all permutations of s2
Check if s1_perm[i] >= s2_perm[i] for all positions
If found, return true; also check reverse case
If no valid combination found, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate s1 permutations

Create all possible arrangements of string s1

Generate s2 permutations

Create all possible arrangements of string s2

Test combinations

Check each s1 permutation against each s2 permutation

Character comparison

For each pair, compare characters position by position

Code -

solution.c — C

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

void swap(char* a, char* b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

bool canBreak(const char* s1, const char* s2, int len) {
    for (int i = 0; i < len; i++) {
        if (s1[i] < s2[i]) return false;
    }
    return true;
}

bool checkPermutations(char* s1, char* s2, int len, int pos1, int pos2) {
    if (pos1 == len && pos2 == len) {
        return canBreak(s1, s2, len) || canBreak(s2, s1, len);
    }
    
    if (pos1 == len) {
        for (int i = pos2; i < len; i++) {
            swap(&s2[pos2], &s2[i]);
            if (checkPermutations(s1, s2, len, pos1, pos2 + 1)) return true;
            swap(&s2[pos2], &s2[i]);
        }
        return false;
    }
    
    for (int i = pos1; i < len; i++) {
        swap(&s1[pos1], &s1[i]);
        if (checkPermutations(s1, s2, len, pos1 + 1, 0)) return true;
        swap(&s1[pos1], &s1[i]);
    }
    return false;
}

int main() {
    char s1[1001], s2[1001];
    scanf("%s", s1);
    scanf("%s", s2);
    
    // Remove quotes if present
    char* start1 = s1[0] == '"' ? s1 + 1 : s1;
    char* start2 = s2[0] == '"' ? s2 + 1 : s2;
    int len1 = strlen(start1);
    int len2 = strlen(start2);
    if (len1 > 0 && start1[len1-1] == '"') start1[len1-1] = '\0';
    if (len2 > 0 && start2[len2-1] == '"') start2[len2-1] = '\0';
    
    printf("%s\n", checkPermutations(start1, start2, strlen(start1), 0, 0) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n! × n)

Generate n! permutations for each string, then compare each pair in O(n) time

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Store all permutations of both strings

⚠ Quadratic Space

Constraints

s1.length == s2.length
1 ≤ s1.length ≤ 10⁵
All strings consist of lowercase English letters only

39.0K Views

Medium Frequency

~18 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler