Given n, find the greatest number which is strictly not more than n and whose binary representation consists of m consecutive ones, then m-1 consecutive zeros and nothing else
Examples:
Input : n = 7 Output : 6 Explanation: 6's binary representation is 110, and 7's is 111, so 6 consists of 2 consecutive 1's and then 1 consecutive 0. Input : 130 Output : 120 Explanation: 28 and 120 are the only numbers <=120, 28 is 11100 consists of 3 consecutive 1's and then 2 consecutive 0's. 120 is 1111000 consists of 4 consecutive 1's and then 3 consecutive 0's. So 120 is the greatest of number<=120 which meets the given condition.
A naive approach will be to traverse from 1 to N and check for every binary representation which consists of m consecutive 1’s and m-1 consecutive 0’s and store the largest of them which meets the given condition.
An efficient approach is to observe a pattern of numbers,
[1(1), 6(110), 28(11100), 120(1111000), 496(111110000), ….]
To get the formula for the numbers which satisfies the conditions we take 120 as an example-
120 is represented as 1111000 which has m = 4 1’s and m = 3 0’s. Converting 1111000 to decimal we get:
2^3+2^4+2^5+2^6 which can be represented as (2^m-1 + 2^m+ 2^m+1 + … 2^m+2, 2^2*m)
2^3*(1+2+2^2+2^3) which can be represented as (2^(m-1)*(1+2+2^2+2^3+..2^(m-1))
2^3*(2^4-1) which can be represented as [2^(m-1) * (2^m -1)].
So all the numbers that meet the given condition can be represented as
[2^(m-1) * (2^m -1)]
We can iterate till the number does not exceeds N and print the largest of all possible elements. A closer observation will shows that at m = 33 it will exceed the 10^18 mark , so we are calculating the number in unit’s time as log(32) is near to constant which is required in calculating the pow .
So, the overall complexity will be O(1).
// CPP program to find largest number // smaller than equal to n with m set // bits then m-1 0 bits. #include <bits/stdc++.h> using namespace std;
// Returns largest number with m set // bits then m-1 0 bits. long long answer( long long n)
{ // Start with 2 bits.
long m = 2;
// initial answer is 1
// which meets the given condition
long long ans = 1;
long long r = 1;
// check for all numbers
while (r < n) {
// compute the number
r = ( int )( pow (2, m) - 1) * ( pow (2, m - 1));
// if less than N
if (r < n)
ans = r;
// increment m to get the next number
m++;
}
return ans;
} // driver code to check the above condition int main()
{ long long n = 7;
cout << answer(n);
return 0;
} |
// java program to find largest number // smaller than equal to n with m set // bits then m-1 0 bits. public class GFG {
// Returns largest number with
// m set bits then m-1 0 bits.
static long answer( long n)
{
// Start with 2 bits.
long m = 2 ;
// initial answer is 1 which
// meets the given condition
long ans = 1 ;
long r = 1 ;
// check for all numbers
while (r < n) {
// compute the number
r = (( long )Math.pow( 2 , m) - 1 ) *
(( long )Math.pow( 2 , m - 1 ));
// if less than N
if (r < n)
ans = r;
// increment m to get
// the next number
m++;
}
return ans;
}
// Driver code
public static void main(String args[]) {
long n = 7 ;
System.out.println(answer(n));
}
} // This code is contributed by Sam007 |
# Python3 program to find # largest number smaller # than equal to n with m # set bits then m-1 0 bits. import math
# Returns largest number # with m set bits then # m-1 0 bits. def answer(n):
# Start with 2 bits.
m = 2 ;
# initial answer is
# 1 which meets the
# given condition
ans = 1 ;
r = 1 ;
# check for all numbers
while r < n:
# compute the number
r = ( int )(( pow ( 2 , m) - 1 ) *
( pow ( 2 , m - 1 )));
# if less than N
if r < n:
ans = r;
# increment m to get
# the next number
m = m + 1 ;
return ans;
# Driver Code print (answer( 7 ));
# This code is contributed by mits. |
// C# program to find largest number // smaller than equal to n with m set // bits then m-1 0 bits. using System;
class GFG {
// Returns largest number with // m set bits then m-1 0 bits. static long answer( long n)
{ // Start with 2 bits.
long m = 2;
// initial answer is 1 which
// meets the given condition
long ans = 1;
long r = 1;
// check for all numbers
while (r < n) {
// compute the number
r = (( long )Math.Pow(2, m) - 1) *
(( long )Math.Pow(2, m - 1));
// if less than N
if (r < n)
ans = r;
// increment m to get
// the next number
m++;
}
return ans;
} // Driver Code
static public void Main ()
{
long n = 7;
Console.WriteLine(answer(n));
}
} // This code is contributed by vt_m. |
<?php // PHP program to find largest number // smaller than equal to n with m set // bits then m-1 0 bits. // Returns largest number with m set // bits then m-1 0 bits. function answer( $n )
{ // Start with 2 bits.
$m = 2;
// initial answer is 1
// which meets the
// given condition
$ans = 1;
$r = 1;
// check for all numbers
while ( $r < $n )
{
// compute the number
$r = (pow(2, $m ) - 1) *
(pow(2, $m - 1));
// if less than N
if ( $r < $n )
$ans = $r ;
// increment m to get
// the next number
$m ++;
}
return $ans ;
} // Driver Code
$n = 7;
echo answer( $n );
// This code is contributed by Ajit. ?> |
<script> // Javascript program to find largest number // smaller than equal to n with m set // bits then m-1 0 bits. // Returns largest number with
// m set bits then m-1 0 bits.
function answer(n)
{
// Start with 2 bits.
let m = 2;
// initial answer is 1 which
// meets the given condition
let ans = 1;
let r = 1;
// check for all numbers
while (r < n) {
// compute the number
r = (Math.pow(2, m) - 1) *
(Math.pow(2, m - 1));
// if less than N
if (r < n)
ans = r;
// increment m to get
// the next number
m++;
}
return ans;
}
// Driver code let n = 7;
document.write(answer(n));
</script> |
6
Time Complexity: O(1)
Auxiliary Space: O(1)
Efficient approach:
This problem can be solved with at most two comparisons, by using the following logic:
1. For a number with n bits, the answer with m set bits followed by m – 1 bits can have a total of n bits, ie, m = ?(n + 1)/2 ? (as m + m – 1 = n).
2. The result can then be computed as 2 (m + m – 1) – 2 (m – 1).
3. However, if the n – bit number is in the range [2 (m + m – 2), 2 (m + m – 1) – 2 (m – 1) – 1], then m must be adjusted to m – 1.
Below is the implementation of the above approach:
// CPP program to find largest number // smaller than equal to n with m set // bits then m-1 0 bits. #include <bits/stdc++.h> using namespace std;
// Returns largest number with m set // bits then m-1 0 bits. long long answer( long long n)
{ // Calculating the number of bits
int bits_no = 1 + ( int )( log (n)/ log (2));
// if m + m - 1 = bits_no, then m = (bits_no + 1) / 2
int m = (bits_no + 1) / 2;
// A number with m set bits and m - 1 unset bits can be calculated as
// (2 ^ (m + m - 1)) - (2 ^ (m - 1))
int ans = (1 << (m + m - 1)) - (1 << (m - 1));
if (ans <= n)
return ans;
// If the result is too large, adjust m by applying decrement operation
m--;
return (1 << (m + m - 1)) - (1 << (m - 1));
} // driver code to check the above condition int main()
{ long long n = 7;
cout << answer(n);
return 0;
} |
// Java program to find largest number // smaller than equal to n with m set // bits then m-1 0 bits. import java.util.*;
class GFG
{ // Returns largest number with m set
// bits then m-1 0 bits.
static int answer( int n)
{
// Calculating the number of bits
int bits_no = 1 + ( int )(Math.log(n)/Math.log( 2 ));
// if m + m - 1 = bits_no, then m = (bits_no + 1) / 2
int m = (bits_no + 1 ) / 2 ;
// A number with m set bits and m - 1
// unset bits can be calculated as
// (2 ^ (m + m - 1)) - (2 ^ (m - 1))
int ans = ( 1 << (m + m - 1 )) - ( 1 << (m - 1 ));
if (ans <= n)
return ans;
// If the result is too large, adjust m
// by applying decrement operation
m--;
return ( 1 << (m + m - 1 )) - ( 1 << (m - 1 ));
}
// driver code to check the above condition
public static void main(String[] args)
{
int n = 7 ;
System.out.println(answer(n));
}
} // This code is contributed by phasing17. |
# Python3 program to find largest number # smaller than equal to n with m set # bits then m-1 0 bits. import math
# Returns largest number with m set # bits then m-1 0 bits. def answer( n):
# Calculating the number of bits
bits_no = 1 + int (math.log(n) / math.log( 2 ));
# if m + m - 1 = bits_no, then m = (bits_no + 1) / 2
m = int ((bits_no + 1 ) / 2 );
# A number with m set bits and m - 1 unset bits can be calculated as
# (2 ^ (m + m - 1)) - (2 ^ (m - 1))
ans = ( 1 << (m + m - 1 )) - ( 1 << (m - 1 ));
if (ans < = n):
return ans;
# If the result is too large, adjust m by applying decrement operation
m - = 1 ;
return ( 1 << (m + m - 1 )) - ( 1 << (m - 1 ));
# driver code to check the above condition n = 7 ;
print (answer(n));
# This code is contributed by phasing17. |
// C# program to find largest number // smaller than equal to n with m set // bits then m-1 0 bits. using System;
using System.Collections.Generic;
class GFG
{ // Returns largest number with m set
// bits then m-1 0 bits.
static int answer( int n)
{
// Calculating the number of bits
int bits_no = 1 + ( int )(Math.Log(n)/Math.Log(2));
// if m + m - 1 = bits_no, then m = (bits_no + 1) / 2
int m = (bits_no + 1) / 2;
// A number with m set bits and m - 1
// unset bits can be calculated as
// (2 ^ (m + m - 1)) - (2 ^ (m - 1))
int ans = (1 << (m + m - 1)) - (1 << (m - 1));
if (ans <= n)
return ans;
// If the result is too large, adjust m
// by applying decrement operation
m--;
return (1 << (m + m - 1)) - (1 << (m - 1));
}
// driver code to check the above condition
public static void Main( string [] args)
{
int n = 7;
Console.WriteLine(answer(n));
}
} // This code is contributed by phasing17. |
// JS program to find largest number // smaller than equal to n with m set // bits then m-1 0 bits. // Returns largest number with m set // bits then m-1 0 bits. function answer( n)
{ // Calculating the number of bits
let bits_no = 1 + Math.floor(Math.log(n)/Math.log(2));
// if m + m - 1 = bits_no, then m = (bits_no + 1) / 2
let m = (bits_no + 1) / 2;
// A number with m set bits and m - 1 unset bits can be calculated as
// (2 ^ (m + m - 1)) - (2 ^ (m - 1))
let ans = (1 << (m + m - 1)) - (1 << (m - 1));
if (ans <= n)
return ans;
// If the result is too large, adjust m by applying decrement operation
m--;
return (1 << (m + m - 1)) - (1 << (m - 1));
} // driver code to check the above condition let n = 7; console.log(answer(n)); // This code is contributed by phasing17. |
6
Time Complexity: O(1)
Auxiliary Space: O(1)