Lexicographically Smallest String After a Swap

Lexicographically Smallest String After a Swap - Problem

String Greedy Easy

Imagine you're given a string of digits and you want to make it as lexicographically small as possible. You have one powerful move: you can swap any two adjacent digits that have the same parity (both odd or both even) exactly once.

Parity Rules:
• Even digits: 0, 2, 4, 6, 8
• Odd digits: 1, 3, 5, 7, 9
• You can only swap adjacent digits of the same type

Goal: Find the lexicographically smallest string possible after performing at most one swap.

Example: "4321" → "2341" (swap adjacent 4 and 2, both even)

Input & Output

example_1.py — Basic Swap

$ Input: "4312"

› Output: "4132"

💡 Note: We can swap adjacent digits 3 and 1 (both odd) to get "4132", which is lexicographically smaller than the original.

example_2.py — No Valid Swap

$ Input: "4321"

› Output: "4321"

💡 Note: No adjacent digits have the same parity (4-3, 3-2, 2-1 are all even-odd pairs), so no swap is possible.

example_3.py — Multiple Options

$ Input: "8642"

› Output: "2648"

💡 Note: We can swap 8 and 6 (both even) to get "6842", or 6 and 4 to get "8462", or 4 and 2 to get "8624". The optimal choice is swapping 8 and 6 to get "6842", but actually we want the globally smallest, which requires swapping the leftmost beneficial pair.

Constraints

2 ≤ s.length ≤ 100
s consists of digits only (0-9)
You can perform at most one swap
Only adjacent digits with the same parity can be swapped

Visualization

Tap to expand

Understanding the Visualization

Identify Parity Groups

Classify each digit as even (blue) or odd (green)

Scan for Opportunities

Look for adjacent same-parity pairs where left > right

Execute First Beneficial Swap

Make the leftmost beneficial swap for optimal lexicographical result

Optimal Result Achieved

Early positions have more impact on lexicographical ordering

Key Takeaway

🎯 Key Insight: Since lexicographical comparison prioritizes earlier positions, the first beneficial swap from left to right always produces the optimal result. This greedy approach eliminates the need to check all possibilities.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy approach - scan from left to right and perform the first beneficial swap found between adjacent digits of the same parity. This works because lexicographical comparison prioritizes earlier positions, making the leftmost improvement always optimal. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Adjacent Swaps)	O(n²)	O(n)	Try every possible adjacent swap and return the lexicographically smallest result
One-Pass Greedy (Optimal)	O(n)	O(1)	Scan left to right and make the first beneficial swap found

Brute Force (Try All Adjacent Swaps) — Algorithm Steps

Iterate through each adjacent pair in the string
Check if both digits have the same parity (both odd or both even)
If swappable, create a new string with these digits swapped
Keep track of the lexicographically smallest string found
Return the best result (original string if no beneficial swap exists)

Visualization

Tap to expand

Step-by-Step Walkthrough

Check First Pair

Compare digits at positions 0 and 1, check if same parity

Try Swap

If valid, create new string with swapped digits

Compare Results

Keep the lexicographically smallest string found

Continue

Repeat for all adjacent pairs

Code -

solution.c — C

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

char* smallestStringWithSwaps(char* s) {
    int n = strlen(s);
    char* result = malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    
    // Try every adjacent pair
    for (int i = 0; i < n - 1; i++) {
        int digit1 = s[i] - '0';
        int digit2 = s[i + 1] - '0';
        
        // Check if same parity (both odd or both even)
        if (digit1 % 2 == digit2 % 2) {
            // Create new string with swap
            char* swapped = malloc((n + 1) * sizeof(char));
            strcpy(swapped, s);
            char temp = swapped[i];
            swapped[i] = swapped[i + 1];
            swapped[i + 1] = temp;
            
            // Keep lexicographically smallest
            if (strcmp(swapped, result) < 0) {
                strcpy(result, swapped);
            }
            free(swapped);
        }
    }
    
    return result;
}

int main() {
    char s[1001];
    scanf("%s", s);
    
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 2);
        s[len - 2] = '\0';
    }
    
    char* result = smallestStringWithSwaps(s);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to check each adjacent pair, O(n) to create each new string, O(n) to compare strings

⚠ Quadratic Growth

Space Complexity

O(n)

Creating new strings for each potential swap

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~12 min Avg. Time

892 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 (Try All Adjacent Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler