Generate a String With Characters That Have Odd Counts

Generate a String With Characters That Have Odd Counts - Problem

String Easy

Generate a String With Characters That Have Odd Counts

You're tasked with creating a balanced string puzzle! Given an integer n, you need to construct a string containing exactly n characters where every unique character appears an odd number of times.

The Challenge:

Your string must be exactly n characters long
Only lowercase English letters (a-z) are allowed
Each unique character must appear 1, 3, 5, 7... times (odd occurrences only)
Multiple valid solutions exist - return any one of them

Example: For n = 4, you could return "aaab" where 'a' appears 3 times and 'b' appears 1 time (both odd counts).

This problem tests your understanding of mathematical patterns and string construction strategies.

Input & Output

example_1.py — Basic odd case

$ Input: n = 4

› Output: "aaab"

💡 Note: n=4 is even, so we use (4-1)=3 copies of 'a' and 1 copy of 'b'. Both 3 and 1 are odd counts.

example_2.py — Basic even case

$ Input: n = 5

› Output: "aaaaa"

💡 Note: n=5 is odd, so we can use all 5 characters as the same letter. Count of 'a' is 5 (odd).

example_3.py — Minimal case

$ Input: n = 1

› Output: "a"

💡 Note: n=1 is odd, so we use 1 copy of 'a'. Count of 'a' is 1 (odd).

Visualization

Tap to expand

Understanding the Visualization

Check total invitations

If n is odd, put everyone in one group. If n is even, you need at least two groups.

Apply the rule

For even n: create one big group with (n-1) people and one small group with 1 person.

Verify constraints

Both groups have odd sizes, and total equals n. Perfect!

Key Takeaway

🎯 Key Insight: Every even number can be expressed as the sum of two odd numbers (n-1 and 1), while odd numbers are already perfect as-is. This mathematical property gives us an O(n) solution!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Only need to construct the string once, which takes O(n) time

✓ Linear Growth

Space Complexity

O(n)

Space needed for the output string of length n

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 500
The returned string must contain only lowercase English letters
Each character must appear an odd number of times
Multiple valid answers exist - return any one

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses pattern recognition: if n is odd, use n copies of the same character; if n is even, use (n-1) copies of one character and 1 copy of another. This ensures all characters have odd counts since odd numbers remain odd, and even numbers can be split into two odd parts.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(2^n)	O(n)	Try all possible combinations of characters with odd counts until finding a valid solution
Pattern Recognition (Optimal)	O(n)	O(n)	Use mathematical insight: if n is odd use all same chars, if even use (n-1) + 1

Brute Force (Generate All Combinations) — Algorithm Steps

Generate all partitions of n into odd numbers
For each partition, assign characters to each part
Construct the string by repeating each character its assigned count
Return the first valid string found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with n=4

Generate all ways to partition 4 into odd numbers

Try partitions

Partitions: [1,1,1,1], [1,3], [3,1]

Build strings

Convert each partition to a string using consecutive letters

Code -

solution.c — C

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

char* generateTheString(int n) {
    // Simple brute force approach for small n
    char* result = (char*)malloc((n + 1) * sizeof(char));
    result[n] = '\0';
    
    if (n % 2 == 1) {
        // n is odd, use all 'a'
        for (int i = 0; i < n; i++) {
            result[i] = 'a';
        }
    } else {
        // n is even, use (n-1) 'a' and 1 'b'
        for (int i = 0; i < n - 1; i++) {
            result[i] = 'a';
        }
        result[n - 1] = 'b';
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We potentially explore all partitions of n, which can be exponential

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to store the result string and recursive call stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 500
The returned string must contain only lowercase English letters
Each character must appear an odd number of times
Multiple valid answers exist - return any one

23.8K Views

Medium Frequency

~8 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

Generate a String With Characters That Have Odd Counts

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler