Find i’th index character in a binary string obtained after n iterations

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 
?> 

Output:

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

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python3

C#

PHP

Recommended Posts: