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

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: 1ExplanationIn 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: **1**0 **0**1 **1** 0, distance = 2

2nd iteration: 1001 **0**110 **1**001, distance = 4

3rd iteration: **1**0010110 **0**1101001 **1**0010110, 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 <bits/stdc++.h>` `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

`<?php` `// PHP program to find i’th Index character` `// in a binary string obtained after n iterations` `// Function to find the i-th character` `function` `KthCharacter(` `$m` `, ` `$n` `, ` `$k` `)` `{` ` ` `// distance between two consecutive` ` ` `// elements after N iterations` ` ` `$distance` `= pow(2, ` `$n` `);` ` ` `$Block_number` `= ` `intval` `(` `$k` `/ ` `$distance` `);` ` ` `$remaining` `= ` `$k` `% ` `$distance` `;` ` ` `$s` `= ` `array` `(32);` ` ` `$x` `= 0;` ` ` `// binary representation of M` ` ` `for` `(; ` `$m` `> 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

`<script>` `// Javascript program to find ith` `// Index character in a binary` `// string obtained after n iterations` `// Function to find` `// the i-th character` `function` `KthCharacter(m, n, k)` `{` ` ` `// distance between two` ` ` `// consecutive elements` ` ` `// after N iterations` ` ` `let distance = Math.pow(2, n);` ` ` `let Block_number = Math.floor(k / distance);` ` ` `let remaining = k % distance;` ` ` ` ` `let s = ` `new` `Array(32).fill(0);` ` ` `let x = 0;` ` ` ` ` `// binary representation of M` ` ` `for` `(; m > 0; x++)` ` ` `{` ` ` `s[x] = m % 2;` ` ` `m = Math.floor(m / 2);` ` ` `}` ` ` ` ` `// kth digit will be` ` ` `// derived from root` ` ` `// for sure` ` ` `let root = s[x - 1 -` ` ` `Block_number];` ` ` ` ` `if` `(remaining == 0)` ` ` `{` ` ` `document.write(root);` ` ` `return` `;` ` ` `}` ` ` ` ` `// Check whether there is` ` ` `// need to flip root or not` ` ` `let flip = ` `true` `;` ` ` `while` `(remaining > 1)` ` ` `{` ` ` `if` `((remaining & 1) > 0)` ` ` `{` ` ` `flip = !flip;` ` ` `}` ` ` `remaining = remaining >> 1;` ` ` `}` ` ` ` ` `if` `(flip)` ` ` `{` ` ` `document.write((root > 0)?0:1);` ` ` `}` ` ` `else` ` ` `{` ` ` `document.write(root);` ` ` `}` `}` `// driver program ` ` ` `let m = 5, k = 5, n = 3;` ` ` `KthCharacter(m, n, k);` ` ` ` ` `// This code is contributed by susmitakundugoaldanga.` `</script>` |

**Output:**

1

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.