Find the K-th Character in String Game II

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

Find the K-th Character in String Game II

Alice and Bob are playing an exciting string transformation game! 🎮

Alice starts with a simple string word = "a". Bob gives her a sequence of operations to perform, and after all operations are complete, he wants to know what the k-th character in the final string will be.

The Rules:
• Operation 0: Append a copy of the current word to itself (e.g., "abc" → "abcabc")
• Operation 1: Generate a new string by shifting each character to its next letter in the alphabet, then append it to the original word (e.g., "abc" → "abcbcd")

Note: The letter 'z' wraps around to 'a' in operation 1.

Goal: Return the k-th character (1-indexed) in the final string after performing all operations in sequence.

Example walkthrough:
Starting with "a" and operations [1, 0]:
1. Operation 1: "a" becomes "ab" (append shifted version)
2. Operation 0: "ab" becomes "abab" (append copy)
Final string: "abab"

Input & Output

example_1.py — Basic Operations

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

› Output: 'c'

💡 Note: Starting with 'a': Operation 1 → 'ab', Operation 0 → 'abab', Operation 1 → 'ababcaca'. The 5th character is 'c'.

example_2.py — Simple Case

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

› Output: 'b'

💡 Note: Starting with 'a': Operation 1 creates shifted version 'b' and appends it → 'ab'. The 2nd character is 'b'.

example_3.py — Copy Operations

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

› Output: 'a'

💡 Note: Starting with 'a': Operation 0 → 'aa', Operation 0 → 'aaaa'. The 3rd character is 'a'.

Constraints

1 ≤ k ≤ 10¹⁴
1 ≤ operations.length ≤ 100
operations[i] is either 0 or 1
It is guaranteed that k is valid for the final string length

Visualization

Tap to expand

Understanding the Visualization

Identify Position

Start with target position k and current operation index

Binary Split Decision

Determine if k falls in the original half or the appended half of current string

Trace Backwards

If in second half, adjust position and potentially count a shift

Apply Accumulated Shifts

Once we reach base case 'a', apply all counted shifts to get final character

Key Takeaway

🎯 Key Insight: Instead of building exponentially growing strings, we use the binary tree structure of operations to mathematically navigate to any position in O(n) time!

Asked in

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

The optimal approach uses recursive bit manipulation to avoid building the entire string. Instead of simulating all operations, we trace backwards from position k to determine which original character it came from and count the number of shift operations applied to it. This reduces the problem from exponential time/space complexity to O(n) time and space, where n is the number of operations.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Bit Manipulation (Optimal)	O(n)	O(n)	Use recursion and bit manipulation to find the character without building the string
Brute Force (Simulate All Operations)	O(2^n)	O(2^n)	Build the entire string by performing each operation sequentially

Recursive Bit Manipulation (Optimal) — Algorithm Steps

Use recursion to trace back the origin of the k-th character
For each level, determine if k is in the first or second half of the string
If in the second half and the operation was 1, increment shift counter
Recursively find the original character and apply accumulated shifts
Return the final shifted character

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Target Position

Begin with k and work backwards through operations

Determine String Half

Check if k is in first or second half of current string

Apply Transformations

Count shifts needed based on operation type

Recurse to Base

Continue until reaching the original 'a' character

Code -

solution.c — C

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

char solve(long long k, int* operations, int opIndex) {
    if (opIndex < 0) {
        return 'a';
    }
    
    long long length = 1LL << (opIndex + 1);
    long long mid = length >> 1;
    
    if (k <= mid) {
        return solve(k, operations, opIndex - 1);
    } else {
        char ch = solve(k - mid, operations, opIndex - 1);
        
        if (operations[opIndex] == 1) {
            if (ch == 'z') {
                return 'a';
            } else {
                return ch + 1;
            }
        } else {
            return ch;
        }
    }
}

char kthCharacter(long long k, int* operations, int opSize) {
    return solve(k, operations, opSize - 1);
}

int main() {
    long long k;
    scanf("%lld", &k);
    
    int operations[100];
    int opSize = 0;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        operations[opSize++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    printf("%c", kthCharacter(k, operations, opSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each operation once in the recursive trace-back, where n is the number of operations

✓ Linear Growth

Space Complexity

O(n)

Recursive call stack depth equals the number of operations

⚡ Linearithmic Space

43.6K Views

High Frequency

~35 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 Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler