Bit at an Index After Repeated Binary Expansion

Start with a binary string bits. In one expansion round, replace every character independently:
0 becomes 00.
1 becomes 10.
After exactly rounds expansions, return the bit at the zero-based position index. The position is guaranteed to exist in the expanded string.

Function
expandedBit(bits: String, rounds: int, index: int) → int

Examples
Example 1
bits = "01"
rounds = 1
index = 2
return = 1
One expansion produces 0010, whose zero-based index 2 contains 1.
Example 2
bits = "1"
rounds = 2
index = 3
return = 0
The two expansions are 1 -> 10 -> 1000, and its last bit is 0.
Example 3
bits = "101"
rounds = 0
index = 2
return = 1
With zero rounds, query the original string directly.

Constraints
1 <= bits.length <= 10^5
bits contains only 0 and 1.
0 <= rounds <= 30
0 <= index <= 10^9
index < bits.length * 2^rounds.

Every original character expands into a block of exactly 2^rounds characters. So the source character is bits[index >> rounds], and the offset inside the block is index & (2^rounds - 1). Now look at the block. A 0 becomes all zeros, because 00 stays 00 forever. A 1 becomes 1 followed by zeros: 1, 10, 1000, and so on. So the answer is 1 only if the source bit is 1 and the offset is 0. Otherwise it's 0. That's O(1) after parsing. The common pitfall is simulating the expansion, or recursing round by round. Another trap is using int for 2^rounds. 2^30 fits, but be careful with shifts elsewhere. Check example 2: index 3 with rounds 2 gives offset 3, so the answer is 0. StealthCoder is the hedge if the shift logic slips under pressure in the live OA.

If this hits your live OA and you blank, StealthCoder solves it in seconds, invisible to the proctor.