Longest Happy String - Practice Coding Problems

Longest Happy String - Problem

The Longest Happy String Challenge

Imagine you're a string composer tasked with creating the longest possible "happy" string using only the characters 'a', 'b', and 'c'. But there's a catch - your string has strict happiness rules!

What makes a string happy?
🎵 It only contains letters 'a', 'b', and 'c'
🚫 It never contains three consecutive identical characters (no "aaa", "bbb", or "ccc")
📊 It respects the maximum usage limits for each character

Your mission: Given three integers representing the maximum number of 'a's, 'b's, and 'c's you can use, craft the longest possible happy string. If multiple solutions exist, any valid one works. If no happy string is possible, return an empty string.

Example: With limits a=1, b=1, c=7, you might create "ccaccbcc" or "ccbccacc" - both are valid happy strings of length 8!

Input & Output

example_1.py — Basic Case

$ Input: a = 1, b = 1, c = 7

› Output: "ccaccbcc"

💡 Note: With 7 c's, 1 a, and 1 b, we can create a string of length 9. We use c's greedily but avoid three consecutive by inserting a's and b's strategically.

example_2.py — Balanced Case

$ Input: a = 2, b = 2, c = 1

› Output: "aabbc"

💡 Note: More balanced counts allow for a simpler pattern. We can use pairs of abundant characters followed by singles.

example_3.py — Edge Case

$ Input: a = 7, b = 1, c = 0

› Output: "aabaa"

💡 Note: With only two character types available, we use them optimally while avoiding three consecutive a's.

Constraints

0 ≤ a, b, c ≤ 100
At least one of a, b, c must be positive for non-empty result
No three consecutive identical characters allowed

Visualization

Tap to expand

Understanding the Visualization

Setup Priority Queue

Initialize max-heap with character counts: [7:c, 1:b, 1:a]

Pick Abundant Character

Select 'c' and add "cc" since count is much higher than others

Strategic Switch

Can't add another 'c', so switch to second most abundant 'b'

Continue Pattern

Add 'c' again, then forced to use 'a', creating optimal length

Final Result

Constructed "ccbccacc" using all characters optimally

Key Takeaway

🎯 Key Insight: The greedy priority queue approach ensures optimal length by always choosing the most abundant character while strategically switching to prevent constraint violations. The algorithm achieves O(n) time complexity and produces the longest possible happy string.

Asked in

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

The optimal solution uses a greedy approach with priority queue to always select the most abundant character while avoiding three consecutive identical characters. The key insight is to use the second most abundant character when the most abundant would create a violation, and to strategically add two characters at once when one character count significantly exceeds others.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Backtracking	O(3^n)	O(n)	Try all possible character combinations recursively
Greedy with Priority Queue (Optimal)	O(n log 3)	O(1)	Use max-heap to always pick the most abundant character while avoiding three consecutive

Recursive Backtracking — Algorithm Steps

At each position, try adding 'a', 'b', or 'c'
Check if adding the character violates any rules
Recursively build the rest of the string
Backtrack if no valid continuation exists
Return the longest valid string found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Empty

Begin with empty string and full character counts

Try Each Character

At each level, attempt to add 'a', 'b', or 'c'

Check Constraints

Verify no three consecutive characters and counts available

Recurse or Backtrack

Continue building or return if invalid

Find Maximum

Return the longest valid string found

Code -

solution.c — C

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

char* backtrack(char* current, int len, int countA, int countB, int countC, int* maxLen) {
    if (countA == 0 && countB == 0 && countC == 0) {
        if (len > *maxLen) {
            *maxLen = len;
            char* result = malloc((len + 1) * sizeof(char));
            strcpy(result, current);
            return result;
        }
        return NULL;
    }
    
    char* best = NULL;
    
    // Try adding 'a'
    if (countA > 0 && (len < 2 || current[len-1] != 'a' || current[len-2] != 'a')) {
        current[len] = 'a';
        current[len+1] = '\0';
        char* result = backtrack(current, len + 1, countA - 1, countB, countC, maxLen);
        if (result && (!best || strlen(result) > strlen(best))) {
            if (best) free(best);
            best = result;
        } else if (result) {
            free(result);
        }
    }
    
    return best;
}

char* longestDiverseString(int a, int b, int c) {
    char* current = malloc(1000 * sizeof(char));
    current[0] = '\0';
    int maxLen = 0;
    char* result = backtrack(current, 0, a, b, c, &maxLen);
    free(current);
    return result ? result : "";
}

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    char* result = longestDiverseString(a, b, c);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

At each position, we try 3 characters, leading to 3^n possible combinations where n is the total character count

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to string length

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Recursive Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler