Skip to content
Related Articles

Related Articles

Improve Article

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

  • Difficulty Level : Hard
  • Last Updated : 30 Apr, 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 <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.



My Personal Notes
arrow_drop_up
Next

Find i'th Index character in a binary string obtained after n iterations
Recommended Articles
Page :
Find i'th Index character in a binary string obtained after n iterations
19, Feb 18
Construct a matrix such that union of ith row and ith column contains every element from 1 to 2N-1
18, Mar 20
Find Binary string by converting all 01 or 10 to 11 after M iterations
20, Jul 21
Find the sum of remaining sticks after each iterations
11, Nov 19
Find the number obtained after concatenation of binary representation of M and N
02, Jan 20
String obtained by reversing and complementing a Binary string K times
09, Apr 20
Fill array with 1's using minimum iterations of filling neighbors
06, Jun 17
Find the final number obtained after performing the given operation
10, Dec 19
Distinct Numbers obtained by generating all permutations of a Binary String
05, Apr 21
Maximum array sum that can be obtained after exactly k changes
26, Mar 19
Program to find the kth character after decrypting a string
19, Mar 19
Find the number obtained by concatenating binary representations of all numbers up to N
05, Jan 21
Check if a string can be obtained by rotating another string 2 places
16, Mar 17
Count of substrings having the most frequent character in the string as first character
05, Nov 20
Sum of numbers obtained by the count of set and non-set bits in diagonal matrix elements
19, Feb 21
Find the count of M character words which have at least one character repeated
11, Jul 19
Minimum sum of squares of character counts in a given string after removing k characters
10, Jun 17
Find array sum using Bitwise OR after splitting given array in two halves after K circular shifts
18, Jun 20
Check if it is possible to reach to the index with value K when start index is given
25, Jun 20
Queries for number of distinct elements from a given index till last index in an array
17, Jun 19
Most frequent element in Array after replacing given index by K for Q queries
02, Jul 20
Lexicographically smallest string formed by appending a character from the first K characters of a given string
20, Jul 18
Maximum contiguous decreasing sequence obtained by removing any one element
18, Mar 20
Minimum sum obtained by choosing N number from given N pairs
02, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
mayank2498
@mayank2498
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox