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: 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 <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
Auxiliary Space: O(1)