Find the K-th Character in String Game I - Practice Coding Problems

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

Alice and Bob are playing an alphabet transformation game! Alice starts with a simple string word = "a", but Bob challenges her to keep expanding it using a special rule.

The Rule: In each operation, Alice must:

Take each character in the current string
Transform it to the next character in the alphabet (a→b, b→c, ..., z→a)
Append this transformed string to the original

Example transformations:

"a" becomes "ab" (a + b)
"ab" becomes "abbc" (ab + bc)
"abbc" becomes "abbcbccd" (abbc + bccd)

Your task: Given a positive integer k, find the k-th character (1-indexed) in the final string after performing enough operations to have at least k characters.

Input & Output

example_1.py — Basic case

$ Input: k = 5

› Output: b

💡 Note: String evolution: 'a' → 'ab' → 'abbc' → 'abbcbccd'. The 5th character (1-indexed) is 'b'.

example_2.py — First character

$ Input: k = 1

› Output: a

💡 Note: The first character is always 'a' since we start with word = 'a'.

example_3.py — Power of 2

$ Input: k = 4

› Output: c

💡 Note: After 2 operations: 'abbcbccd'. The 4th character is 'c', which underwent 2 transformations (a→b→c).

Constraints

1 ≤ k ≤ 10⁵
The answer will always be a lowercase English letter
k is 1-indexed (first character is at position 1)

Visualization

Tap to expand

Understanding the Visualization

Recognize the Pattern

String doubles each operation, following powers of 2

Binary Position Mapping

Each bit position corresponds to a generation of transformation

Count Transformations

Number of 1-bits = number of alphabet shifts applied

Key Takeaway

🎯 Key Insight: The binary representation of position k-1 directly tells us how many transformations to apply to 'a'!

Asked in

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

The optimal solution uses bit manipulation to count transformations without building the actual string. By analyzing the binary representation of position k-1, we can determine how many alphabet shifts occurred. Each 1-bit represents one transformation, making this an O(log k) time and O(1) space solution.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(2^log k)	O(2^log k)	Build the actual string by simulating each operation until we have k characters
Bit Manipulation Approach (Optimal)	O(log k)	O(1)	Use binary representation to find the character without building the string

Simulation Approach — Algorithm Steps

Initialize word = 'a'
While length of word < k:
Generate next_word by shifting each char in word by 1
Append next_word to word
Return word[k-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with 'a'

First Operation

'a' becomes 'ab' (append 'b')

Second Operation

'ab' becomes 'abbc' (append 'bc')

Find k-th Character

Return character at position k-1

Code -

solution.c — C

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

char kthCharacter(int k) {
    char* word = malloc(2000000 * sizeof(char));
    strcpy(word, "a");
    int len = 1;
    
    while (len < k) {
        int currentLen = len;
        for (int i = 0; i < currentLen; i++) {
            // Transform to next character (z wraps to a)
            char nextChar = (word[i] - 'a' + 1) % 26 + 'a';
            word[len + i] = nextChar;
        }
        len *= 2;
    }
    
    char result = word[k - 1];
    free(word);
    return result;
}

int main() {
    int k;
    scanf("%d", &k);
    printf("%c\n", kthCharacter(k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^log k)

String length doubles each iteration, and we need log k iterations

⚡ Linearithmic

Space Complexity

O(2^log k)

We store the entire string which grows exponentially

✓ Linear Space

24.3K Views

Medium Frequency

~15 min Avg. Time

892 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler