# 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, 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``;` `    ``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 :