# 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