38. Count and Say

The count-and-say sequence is a sequence of digit strings defined by the recursive formula:

• countAndSay(1) = “1”
• countAndSay(n) is the way you would “say” the digit string from countAndSay(n-1), which is then converted into a different digit string.

To determine how you “say” a digit string, split it into the minimal number of substrings such that each substring contains exactly one unique digit. Then for each substring, say the number of digits, then say the digit. Finally, concatenate every said digit.

For example, the saying and conversion for digit string “3322251”:

Given a positive integer n, return the $n^{th}$ term of the count-and-say sequence.
 

Example 1:

Input: n = 1
Output: “1”
Explanation: This is the base case.

Example 2:

Input: n = 4
Output: “1211”
Explanation:
countAndSay(1) = “1”
countAndSay(2) = say “1” = one 1 = “11”
countAndSay(3) = say “11” = two 1’s = “21”
countAndSay(4) = say “21” = one 2 + one 1 = “12” + “11” = “1211”

Constraints:

• 1 <= n <= 30

From: LeetCode
Link: 38. Count and Say

---

Solution:

Ideas:

1. Base Case: If n is 1, the function returns the string “1”, since the first term of the sequence is always “1”.
2. Recursive Call: For n greater than 1, the function calls itself to calculate the (n-1)th term. This is because to say the nth term, you need to know the (n-1)th term first.
3. Calculating the Length: It then calculates the length of the (n-1)th term to determine how much memory to allocate for the nth term. The allocation is generous to ensure there’s enough space since the length of the sequence can grow with each term. The malloc function is used to allocate the memory, and the sprintf function is used to convert the counts and digits into a string format.
4. Building the nth Term: The function iterates through the digits of the (n-1)th term. For each group of the same digit, it counts how many times that digit appears consecutively (count). It then writes the count and the digit itself into the result string. The sprintf function returns the number of characters written (excluding the null terminator), which is used to update the result_index to know where to write the next characters.
5. Ending the String: Once all groups of digits have been processed, a null terminator (‘\0’) is added to the end of the result string to properly terminate it.
6. Memory Management: The function then frees the memory allocated for the (n-1)th term since it is no longer needed. This is important to prevent memory leaks.
7. Return Result: Finally, the nth term, now stored in result, is returned to the caller. The caller, in this case, the main function, is responsible for freeing this memory after it’s done using it.

Code:

char* countAndSay(int n) {
    if(n == 1) return strdup("1");
    
    // Recursively call countAndSay to get the previous term
    char* prev_term = countAndSay(n - 1);
    int length = strlen(prev_term);
    
    // Calculate the maximum length of the result
    // In the worst case, the length doubles (e.g., "1" -> "11")
    char* result = malloc(2 * length + 1);
    int result_index = 0;

    for(int i = 0; i < length; i++) {
        int count = 1;
        // Count the number of identical digits
        while(i + 1 < length && prev_term[i] == prev_term[i + 1]) {
            count++;
            i++;
        }
        // Append count and digit to the result string
        result_index += sprintf(result + result_index, "%d%c", count, prev_term[i]);
    }

    // Free the memory allocated for previous term
    free(prev_term);

    // Add the null terminator to the result string
    result[result_index] = '\0';
    
    return result;
}