Open In App

Largest number with binary representation is m 1’s and m-1 0’s

Improve
Improve
Like Article
Like
Save
Share
Report

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

C++




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




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




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




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


Javascript




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


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:

C++




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




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




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




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


Javascript




// 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)



Last Updated : 19 Dec, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads