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