The k-th Lexicographical String of All Happy Strings of Length n

The k-th Lexicographical String of All Happy Strings of Length n - Problem

String Backtracking Medium

A happy string is a delightful sequence of characters that follows two simple rules:

It contains only the letters 'a', 'b', and 'c'
No two adjacent characters are the same (no consecutive duplicates!)

Examples of happy strings: "abc", "ac", "b", "abcbabcbcb"

Examples of sad strings: "aa", "baa", "ababbc"

Your Mission: Given two integers n (length) and k (position), imagine generating ALL possible happy strings of length n and sorting them in lexicographical (dictionary) order. Your task is to return the k-th string from this sorted list.

If there are fewer than k happy strings of length n, return an empty string "".

Goal: Find the k-th lexicographically smallest happy string of length n without generating all possible strings.

Input & Output

example_1.py — Basic Case

$ Input: n = 1, k = 3

› Output: "c"

💡 Note: Happy strings of length 1: ["a", "b", "c"]. The 3rd string is "c".

example_2.py — Multiple Characters

$ Input: n = 1, k = 4

› Output: ""

💡 Note: There are only 3 happy strings of length 1, so k=4 exceeds the count. Return empty string.

example_3.py — Length 3 String

$ Input: n = 3, k = 9

› Output: "cab"

💡 Note: All happy strings of length 3 sorted: ["aba", "abc", "aca", "acb", "bab", "bac", "bca", "bcb", "cab", "cac", "cba", "cbc"]. The 9th string is "cab".

Constraints

1 ≤ n ≤ 10
1 ≤ k ≤ 500
Happy strings use only characters 'a', 'b', 'c'
No two adjacent characters can be the same

Visualization

Tap to expand

Understanding the Visualization

Calculate Tree Size

For length n: 3 choices for first char × 2 choices for each remaining = 3×2^(n-1) total strings

Navigate by Subtree Counts

At each level, determine which character's subtree contains the k-th string

Direct Construction

Build the string character by character using mathematical calculation

Early Termination

If k exceeds total possible strings, return empty string immediately

Key Takeaway

🎯 Key Insight: By calculating subtree sizes mathematically, we can jump directly to the k-th string without generating all possibilities, making this an elegant O(n) solution.

Asked in

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

The optimal solution uses mathematical combinatorics to directly calculate which character should be at each position. Instead of generating all possible happy strings, we calculate how many strings start with each character and use this to navigate directly to the k-th string in O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Direct Construction (Optimal)	O(n)	O(1)	Calculate position directly using combinatorial math without generating all strings

Mathematical Direct Construction (Optimal) — Algorithm Steps

Calculate total number of possible happy strings of length n
If k exceeds total count, return empty string
For each position, calculate how many strings start with 'a', 'b', 'c'
Choose the character that contains the k-th string in its subtree
Update k to reflect position within the chosen subtree
Repeat until string is complete

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Subtree Sizes

Each character choice creates a subtree of predictable size

Choose Branch

Determine which character's subtree contains the k-th string

Update Position

Adjust k to reflect position within chosen subtree

Repeat

Continue for each position until string is complete

Code -

solution.c — C

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

char* getHappyString(int n, int k) {
    // Calculate total possible happy strings
    long long total = n > 0 ? 3LL * (1LL << (n - 1)) : 0;
    
    if (k > total) {
        char* empty = malloc(1);
        empty[0] = '\0';
        return empty;
    }
    
    char* result = malloc(n + 1);
    result[n] = '\0';
    k -= 1; // Convert to 0-indexed
    
    // For first character
    char chars[] = {'a', 'b', 'c'};
    long long stringsPerChar = n > 1 ? 1LL << (n - 1) : 1;
    
    // Determine first character
    int firstCharIdx = k / stringsPerChar;
    result[0] = chars[firstCharIdx];
    k %= stringsPerChar;
    
    // For remaining positions
    for (int i = 1; i < n; i++) {
        // Available characters (exclude previous character)
        char available[2];
        int availCount = 0;
        for (int j = 0; j < 3; j++) {
            if (chars[j] != result[i-1]) {
                available[availCount++] = chars[j];
            }
        }
        
        stringsPerChar = 1LL << (n - 1 - i);
        
        // Choose character based on k
        int charIdx = k / stringsPerChar;
        result[i] = available[charIdx];
        k %= stringsPerChar;
    }
    
    return result;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    char* result = getHappyString(n, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We make exactly n decisions, each taking constant time

✓ Linear Growth

Space Complexity

O(1)

Only store the result string and a few variables

✓ Linear Space

28.8K Views

Medium-High Frequency

~18 min Avg. Time

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

Mathematical Direct Construction (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler