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.
<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>
<?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.
?>
Output
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.
Output
6
Time Complexity: O(1)
Auxiliary Space: O(1)
