Lexicographically Smallest String After a Swap

Lexicographically Smallest String After a Swap - Problem

String Greedy Easy

Given a string s containing only digits, return the lexicographically smallest string that can be obtained after swapping adjacent digits in s with the same parity at most once.

Digits have the same parity if both are odd or both are even. For example, 5 and 9, as well as 2 and 4, have the same parity, while 6 and 9 do not.

Input & Output

Example 1 — Basic Swap

$ Input: s = "4321"

› Output: "4312"

💡 Note: We can swap 2 and 1 (both even) to get "4312", which is lexicographically smaller than the original

Example 2 — No Beneficial Swap

$ Input: s = "1234"

› Output: "1234"

💡 Note: Already in ascending order. Any adjacent same-parity swap would make it lexicographically larger

Example 3 — Multiple Options

$ Input: s = "8742"

› Output: "8742"

💡 Note: We can check adjacent pairs: 8 and 7 have different parity, 7 and 4 have different parity, 4 and 2 have same parity (both even). Swapping 4 and 2 gives "8724" which is lexicographically larger, so we don't perform the swap and return the original string.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of digits only

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is that since we can only swap once, we should make the first beneficial adjacent swap that improves lexicographical order. The optimal approach uses a greedy strategy scanning left to right. Time: O(n), Space: O(n)

Common Approaches

✓ Prefix Sum

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

Brute Force - Try All Swaps

⏱️ Time: O(n²) Space: O(n)

Generate all possible strings by swapping each pair of adjacent digits with same parity, then compare all results to find the smallest lexicographically. This ensures we don't miss the optimal solution.

Greedy - First Beneficial Swap

⏱️ Time: O(n) Space: O(n)

Since we can only swap once, we want to make the most impactful change. Scan from left to right and perform the first swap where a smaller digit can move to an earlier position.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char* solution(char* s) {
    int len = strlen(s);
    char* result = (char*)malloc((len + 1) * sizeof(char));
    strcpy(result, s);
    
    // Try to find the first beneficial swap of adjacent digits with same parity
    for (int i = 0; i < len - 1; i++) {
        int digit1 = result[i] - '0';
        int digit2 = result[i + 1] - '0';
        
        // Check if digits have same parity and swapping would make it smaller
        if ((digit1 % 2 == digit2 % 2) && (digit1 > digit2)) {
            // Swap the digits
            char temp = result[i];
            result[i] = result[i + 1];
            result[i + 1] = temp;
            break; // Only one swap allowed
        }
    }
    
    return result;
}

int main() {
    char s[1001]; // Assuming reasonable string length limit
    scanf("%s", s);
    
    char* result = solution(s);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

890 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