Increasing Decreasing String - Practice Coding Problems

Increasing Decreasing String - Problem

You are given a string s containing lowercase English letters. Your task is to reorder the characters using a specific zigzag pattern algorithm that creates an interesting wave-like arrangement.

The algorithm works as follows:

Ascending Phase: Start by picking the smallest available character, then keep picking the next smallest character that's larger than the previously picked one, continuing until no such character exists.
Descending Phase: Switch direction and pick the largest available character, then keep picking the next largest character that's smaller than the previously picked one, continuing until no such character exists.
Repeat: Continue alternating between ascending and descending phases until all characters are used.

For example, with s = "aaaabbbbcccc", the algorithm creates: "abccbaabccba" - notice the beautiful zigzag pattern!

Goal: Return the resulting string after applying this reordering algorithm.

Input & Output

example_1.py — Basic Mixed Characters

$ Input: s = "aaaabbbbcccc"

› Output: "abccbaabccba"

💡 Note: First round: ascending gives 'abc', descending gives 'cba'. Second round: ascending gives 'abc', descending gives 'cba'. Result: 'abc' + 'cba' + 'abc' + 'cba' = 'abccbaabccba'

example_2.py — Single Character Type

$ Input: s = "rat"

› Output: "art"

💡 Note: All characters are different. First round ascending: 'a' (smallest), 'r' (next), 't' (next). No descending phase needed since all are used. Result: 'art'

example_3.py — Edge Case Single Character

$ Input: s = "leetcode"

› Output: "cdelotee"

💡 Note: Round 1: ascending 'cde', descending 'o'. Round 2: ascending 'e', descending 'e'. Round 3: ascending 'lt'. Result combines all phases: 'cdelotee'

Visualization

Tap to expand

Understanding the Visualization

Count Skills

Count how many hikers of each skill level (a=2, b=2, c=2)

Ascending Trail

Pick lowest to highest available: a→b→c

Descending Trail

Pick highest to lowest available: c→b→a

Repeat Pattern

Continue zigzag until all hikers are arranged

Key Takeaway

🎯 Key Insight: Use frequency counters + bidirectional alphabet traversal to efficiently create the zigzag pattern without repeatedly searching for characters.

Time & Space Complexity

Time Complexity

⏱️

O(n)

One pass to count frequencies O(n), then O(n) to process all characters with O(1) alphabet traversals

✓ Linear Growth

Space Complexity

O(1)

Only need frequency array of size 26 (constant space for lowercase letters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 500
s consists of lowercase English letters only
Characters can repeat multiple times

Asked in

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

The optimal approach uses a frequency counter to track character counts, then alternates between ascending (a→z) and descending (z→a) phases until all characters are used. This achieves O(n) time complexity with O(1) space (only 26 counters needed).

Common Approaches

Approach	Time	Space	Notes
✓ Frequency Counter with Ordered Traversal	O(n)	O(1)	Count character frequencies, then traverse alphabet bidirectionally
Brute Force (Repeated String Scanning)	O(n²)	O(n)	Repeatedly scan the remaining string to find next character according to rules

Frequency Counter with Ordered Traversal — Algorithm Steps

Count frequency of each character in the input string
Repeat until all characters are used:
Ascending phase: iterate a→z, take one char of each available type
Descending phase: iterate z→a, take one char of each available type
Build result string by appending selected characters

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build frequency array: a=2, b=2, c=2

Ascending Phase

Go a→z, take one of each: abc

Descending Phase

Go z→a, take one of each: cba

Repeat

Continue until frequencies are zero

Code -

solution.c — C

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

char* sortString(char* s) {
    int len = strlen(s);
    int freq[26] = {0};
    
    // Count character frequencies
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int resultIdx = 0;
    
    // Continue until all characters are used
    while (true) {
        bool hasChars = false;
        for (int i = 0; i < 26; i++) {
            if (freq[i] > 0) {
                hasChars = true;
                break;
            }
        }
        if (!hasChars) break;
        
        // Ascending phase: a to z
        for (int i = 0; i < 26; i++) {
            if (freq[i] > 0) {
                result[resultIdx++] = (char)(i + 'a');
                freq[i]--;
            }
        }
        
        // Descending phase: z to a
        for (int i = 25; i >= 0; i--) {
            if (freq[i] > 0) {
                result[resultIdx++] = (char)(i + 'a');
                freq[i]--;
            }
        }
    }
    
    result[resultIdx] = '\0';
    return result;
}

int main() {
    char s[501];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    char* result = sortString(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

One pass to count frequencies O(n), then O(n) to process all characters with O(1) alphabet traversals

✓ Linear Growth

Space Complexity

O(1)

Only need frequency array of size 26 (constant space for lowercase letters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 500
s consists of lowercase English letters only
Characters can repeat multiple times

32.4K Views

Medium Frequency

~15 min Avg. Time

985 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

Frequency Counter with Ordered Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler