Increasing Decreasing String

Increasing Decreasing String - Problem

You are given a string s. Reorder the string using the following algorithm:

Remove the smallest character from s and append it to the result.
Remove the smallest character from s that is greater than the last appended character, and append it to the result.
Repeat step 2 until no more characters can be removed.
Remove the largest character from s and append it to the result.
Remove the largest character from s that is smaller than the last appended character, and append it to the result.
Repeat step 5 until no more characters can be removed.
Repeat steps 1 through 6 until all characters from s have been removed.

If the smallest or largest character appears more than once, you may choose any occurrence to append to the result.

Return the resulting string after reordering s using this algorithm.

Input & Output

Example 1 — Basic Case

$ Input: s = "aaaabbbbcccc"

› Output: "abccbaabccba"

💡 Note: First cycle: ascending a→b→c, descending c→b→a. Second cycle: ascending a→b→c, descending c→b→a. Result: abccbaabccba

Example 2 — Single Character

$ Input: s = "rat"

› Output: "art"

💡 Note: Ascending phase picks 'a', then 'r', then 't'. No characters left for descending phase. Result: art

Example 3 — Repeated Pattern

$ Input: s = "leetcode"

› Output: "cdelotee"

💡 Note: First ascending: c→d→e→l→o→t. Then descending: e→e. All characters used. Result: cdelotee

Constraints

1 ≤ s.length ≤ 500
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The key insight is to count character frequencies first, then alternate between ascending and descending phases efficiently. Best approach uses frequency counter with O(n × k) time where k=26 for lowercase letters, effectively O(n). Space: O(k) = O(1).

Common Approaches

✓ Brute Force with String Scanning

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

For each step, scan through the entire remaining string to find the appropriate character (smallest ascending, largest descending). Remove found character and repeat until string is empty.

Frequency Counter Approach

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

Count all character frequencies upfront. Then alternate between ascending and descending phases, picking characters from the frequency map without repeatedly scanning the string.

Brute Force with String Scanning — Algorithm Steps

Convert string to list for easy removal
Alternate between ascending and descending phases
In each phase, scan remaining characters to find next valid one
Remove found character and append to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with input string 'aaaabbbbcccc'

Sort & Pick

Sort remaining chars, pick smallest for ascending phase

Result Built

Continue until all characters processed

Code -

solution.c — C

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

#define MAX_CHARS 256
#define MAX_LEN 100000

int compareAsc(const void* a, const void* b) {
    return *(char*)a - *(char*)b;
}

int compareDesc(const void* a, const void* b) {
    return *(char*)b - *(char*)a;
}

char* solution(char* s) {
    int len = strlen(s);
    int freq[MAX_CHARS] = {0};
    
    // Count frequency of each character
    for (int i = 0; i < len; i++) {
        freq[(unsigned char)s[i]]++;
    }
    
    char* result = malloc((len + 1) * sizeof(char));
    int resultIdx = 0;
    
    while (1) {
        // Check if any characters remain
        int hasChars = 0;
        for (int i = 0; i < MAX_CHARS; i++) {
            if (freq[i] > 0) {
                hasChars = 1;
                break;
            }
        }
        if (!hasChars) break;
        
        // Ascending phase
        char chars[MAX_CHARS];
        int charCount = 0;
        
        for (int i = 0; i < MAX_CHARS; i++) {
            if (freq[i] > 0) {
                chars[charCount++] = (char)i;
            }
        }
        
        qsort(chars, charCount, sizeof(char), compareAsc);
        
        char lastChar = '\0';
        int firstChar = 1;
        
        for (int i = 0; i < charCount; i++) {
            if (firstChar || chars[i] > lastChar) {
                result[resultIdx++] = chars[i];
                freq[(unsigned char)chars[i]]--;
                lastChar = chars[i];
                firstChar = 0;
            }
        }
        
        // Check if any characters remain
        hasChars = 0;
        for (int i = 0; i < MAX_CHARS; i++) {
            if (freq[i] > 0) {
                hasChars = 1;
                break;
            }
        }
        if (!hasChars) break;
        
        // Descending phase
        charCount = 0;
        for (int i = 0; i < MAX_CHARS; i++) {
            if (freq[i] > 0) {
                chars[charCount++] = (char)i;
            }
        }
        
        qsort(chars, charCount, sizeof(char), compareDesc);
        
        for (int i = 0; i < charCount; i++) {
            if (chars[i] < lastChar) {
                result[resultIdx++] = chars[i];
                freq[(unsigned char)chars[i]]--;
                lastChar = chars[i];
            }
        }
    }
    
    result[resultIdx] = '\0';
    return result;
}

int main() {
    char line[MAX_LEN];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline if present
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
    }
    
    char* result = solution(line);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n characters, we scan the remaining string which averages n/2 characters

✓ Linear Growth

Space Complexity

O(n)

Converting string to list for manipulation requires O(n) extra space

✓ Linear Space

28.4K Views

Medium Frequency

~15 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 with String Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler