# Find i’th index character in a binary string obtained after n iterations | Set 2

• Difficulty Level : Hard
• Last Updated : 11 Aug, 2021

Given a decimal number m, convert it into a binary string and apply n iterations, in each iteration 0 becomes “01” and 1 becomes “10”. Find ith(based indexing) index character in the string after nth iteration.
Examples

Input: m = 5 i = 5 n = 3
Output: 1
Explanation
In the first case m = 5, i = 5, n = 3.
Initially, the string is  101  ( binary equivalent of 5 )
After 1st iteration -   100110
After 2nd iteration - 100101101001
After 3rd iteration -   100101100110100110010110
The character at index 5 is 1, so 1 is the answer

Input: m = 11 i = 6 n = 4
Output: 1

A naive approach to this problem has been discussed in the previous post.
Efficient algorithm: The first step will be to find which block the i-th character will be after N iterations are performed. In the n’th iteration distance between any two consecutive characters initially will always be equal to 2^n. For a general number m, the number of blocks will be ceil(log m). If M was 3, the string gets divided into 3 blocks. Find the block number in which kth character will lie by k / (2^n), where n is the number of iterations. Consider m=5, then the binary representation is 101. Then the distance between any 2 consecutive marked characters in any i’th iteration will be as follows
0th iteration: 101, distance = 0
1st iteration: 10 01 1 0, distance = 2
2nd iteration: 1001 0110 1001, distance = 4
3rd iteration: 10010110 01101001 10010110, distance = 8
In the example k = 5 and n = 3, so Block_number, when k is 5, will be 0, as 5 / (2^3) = 0
Initially, block numbers will be

Original String :    1   0    1
Block_number    :    0   1    2

There is no need to generate the entire string, only computing in the block in which the i-th character is present will give the answer. Let this character be root root = s[Block_number], where s is the binary representation of “m”. Now in the final string, find the distance of the kth character from the block number, call this distance as remaining. So remaining = k % (2^n) will be the index of i-th character in the block. If remaining is 0, the root will be the answer. Now, in order to check whether the root is the actual answer use a boolean variable flip which whether we need to flip our answer or not. Following the below algorithm will give the character at the i-th index.

bool flip = true;
while(remaining > 1){
if( remaining is odd )
flip = !flip
remaining = remaining/2;
}

Below is the implementation of the above approach:

## C++

 // C++ program to find i’th Index character // in a binary string obtained after n iterations #include using namespace std;   // Function to find the i-th character void KthCharacter(int m, int n, int k) {     // distance between two consecutive     // elements after N iterations     int distance = pow(2, n);     int Block_number = k / distance;     int remaining = k % distance;       int s[32], x = 0;       // binary representation of M     for (; m > 0; x++) {         s[x] = m % 2;         m = m / 2;     }       // kth digit will be derived from root for sure     int root = s[x - 1 - Block_number];       if (remaining == 0) {         cout << root << endl;         return;     }       // Check whether there is need to     // flip root or not     bool flip = true;     while (remaining > 1) {         if (remaining & 1) {             flip = !flip;         }         remaining = remaining >> 1;     }       if (flip) {         cout << !root << endl;     }     else {         cout << root << endl;     } }   // Driver Code int main() {     int m = 5, k = 5, n = 3;     KthCharacter(m, n, k);     return 0; }

## Java

 // Java program to find ith // Index character in a binary // string obtained after n iterations import java.io.*;   class GFG { // Function to find // the i-th character static void KthCharacter(int m,                          int n, int k) {     // distance between two     // consecutive elements     // after N iterations     int distance = (int)Math.pow(2, n);     int Block_number = k / distance;     int remaining = k % distance;       int s[] = new int[32];     int x = 0;       // binary representation of M     for (; m > 0; x++)     {         s[x] = m % 2;         m = m / 2;     }       // kth digit will be     // derived from root     // for sure     int root = s[x - 1 -                  Block_number];       if (remaining == 0)     {         System.out.println(root);         return;     }       // Check whether there is     // need to flip root or not     Boolean flip = true;     while (remaining > 1)     {         if ((remaining & 1) > 0)         {             flip = !flip;         }         remaining = remaining >> 1;     }       if (flip)     {         System.out.println((root > 0)?0:1);     }     else     {         System.out.println(root);     } }   // Driver Code public static void main (String[] args) {     int m = 5, k = 5, n = 3;     KthCharacter(m, n, k); } }   // This code is contributed // by anuj_67.

## Python3

 # Python3 program to find # i’th Index character in # a binary string obtained # after n iterations   # Function to find # the i-th character def KthCharacter(m, n, k):       # distance between two     # consecutive elements     # after N iterations     distance = pow(2, n)     Block_number = int(k / distance)     remaining = k % distance       s = [0] * 32     x = 0       # binary representation of M     while(m > 0) :         s[x] = m % 2         m = int(m / 2)         x += 1               # kth digit will be derived     # from root for sure     root = s[x - 1 - Block_number]           if (remaining == 0):         print(root)         return           # Check whether there     # is need to flip root     # or not     flip = True     while (remaining > 1):         if (remaining & 1):             flip = not(flip)                   remaining = remaining >> 1           if (flip) :         print(not(root))           else :         print(root)       # Driver Code m = 5 k = 5 n = 3 KthCharacter(m, n, k)   # This code is contributed # by smita

## C#

 // C# program to find ith // Index character in a // binary string obtained // after n iterations using System;   class GFG { // Function to find // the i-th character static void KthCharacter(int m,                          int n,                          int k) {     // distance between two     // consecutive elements     // after N iterations     int distance = (int)Math.Pow(2, n);     int Block_number = k / distance;     int remaining = k % distance;       int []s = new int[32];     int x = 0;       // binary representation of M     for (; m > 0; x++)     {         s[x] = m % 2;         m = m / 2;     }       // kth digit will be     // derived from root     // for sure     int root = s[x - 1 -                  Block_number];       if (remaining == 0)     {         Console.WriteLine(root);         return;     }       // Check whether there is     // need to flip root or not     Boolean flip = true;     while (remaining > 1)     {         if ((remaining & 1) > 0)         {             flip = !flip;         }                   remaining = remaining >> 1;     }       if (flip)     {         Console.WriteLine(!(root > 0));     }     else     {         Console.WriteLine(root);     } }   // Driver Code public static void Main () {     int m = 5, k = 5, n = 3;     KthCharacter(m, n, k); } }   // This code is contributed // by anuj_67.

## PHP

 0; \$x++)     {         \$s[\$x] = \$m % 2;         \$m = intval(\$m / 2);     }       // kth digit will be derived from     // root for sure     \$root = \$s[\$x - 1 - \$Block_number];       if (\$remaining == 0)     {         echo \$root . "\n";         return;     }       // Check whether there is need to     // flip root or not     \$flip = true;     while (\$remaining > 1)     {         if (\$remaining & 1)         {             \$flip = !\$flip;         }         \$remaining = \$remaining >> 1;     }       if (\$flip)     {         echo !\$root . "\n";     }     else     {         echo \$root . "\n";     } }   // Driver Code \$m = 5; \$k = 5; \$n = 3; KthCharacter(\$m, \$n, \$k);   // This code is contributed by ita_c ?>

## Javascript



Output:

1

Time Complexity: O(log Z), where Z is the distance between initially consecutive bits after N iterations
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :