Find the K-th Character in String Game II - Problem

Alice and Bob are playing a game. Initially, Alice has a string word = "a". You are given a positive integer k and an integer array operations, where operations[i] represents the type of the i-th operation.

Now Bob will ask Alice to perform all operations in sequence:

If operations[i] == 0, append a copy of word to itself.
If operations[i] == 1, generate a new string by changing each character in word to its next character in the English alphabet, and append it to the original word.

For example, performing operation 1 on "c" generates "cd" and performing operation 1 on "zb" generates "zbac".

Return the value of the k-th character in word after performing all the operations. Note that the character 'z' can be changed to 'a' in the second type of operation.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [0,1,1,1], k = 5

› Output: b

💡 Note: Start with 'a'. Op[0]: 'a' → 'aa'. Op[1]: 'aa' → 'aabb'. Op[2]: 'aabb' → 'aabbbbcc'. Op[3]: 'aabbbbcc' → 'aabbbbccbbccccdd'. The 5th character is 'b'.

Example 2 — Only Copies

$ Input: operations = [0,0,0], k = 1

› Output: a

💡 Note: Start with 'a'. Each operation just copies the string: 'a' → 'aa' → 'aaaa' → 'aaaaaaaa'. The 1st character is always 'a'.

Example 3 — Single Shift

$ Input: operations = [1], k = 2

› Output: b

💡 Note: Start with 'a'. Op[1]: shift and append → 'ab'. The 2nd character is 'b'.

Constraints

1 ≤ operations.length ≤ 40
operations[i] is either 0 or 1
1 ≤ k ≤ 2^{operations.length}

Visualization

Tap to expand

Asked in

G Google 15 M Meta 12 a Amazon 8

The key insight is that the string grows exponentially but we only need one character. Instead of building the full string, we can work backwards from the target position k through the operations to determine which character it represents. The optimal approach uses an iterative method to trace the path in O(n) time and O(1) space.

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force - Simulate All Operations

⏱️ Time: O(2ⁿ) Space: O(2ⁿ)

Start with 'a' and for each operation, either duplicate the string or duplicate with alphabet shift. Keep building until we have the complete final string.

Optimized Iterative Approach

⏱️ Time: O(n) Space: O(1)

Start from the target position k and work backwards through operations. For each operation, determine which half k falls into and accumulate alphabet shifts as needed.

Recursive with Memoization

⏱️ Time: O(2ⁿ) Space: O(n)

Instead of building the entire string, recursively determine which half the k-th position falls into and whether it needs alphabet shifting based on the operation type.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

long long lengths[60]; // Store length after each operation
int ops[60];
int numOps;

char findKthChar(long long k, int opIndex) {
    if (opIndex < 0) {
        return 'a'; // Base case: original string is "a"
    }
    
    long long prevLen = (opIndex == 0) ? 1 : lengths[opIndex - 1];
    
    if (k <= prevLen) {
        // k is in the first half (original part)
        return findKthChar(k, opIndex - 1);
    } else {
        // k is in the second half (appended part)
        long long pos = k - prevLen; // position in the appended part
        char ch = findKthChar(pos, opIndex - 1);
        
        if (ops[opIndex] == 1) {
            // Operation 1: increment character
            if (ch == 'z') {
                return 'a';
            } else {
                return ch + 1;
            }
        } else {
            // Operation 0: just copy
            return ch;
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse operations array
    numOps = 0;
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        ops[numOps++] = (int)strtol(p, &p, 10);
    }
    
    long long k;
    scanf("%lld", &k);
    
    // Calculate lengths after each operation
    lengths[0] = 2; // After first operation, length becomes 2
    for (int i = 1; i < numOps; i++) {
        lengths[i] = lengths[i-1] * 2;
        // Prevent overflow by capping at a large value
        if (lengths[i] > 1000000000000LL) {
            lengths[i] = 1000000000000LL;
        }
    }
    
    char result = findKthChar(k, numOps - 1);
    printf("%c\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

8.8K Views

Medium Frequency

~25 min Avg. Time

234 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