Open In App

Check if all the set bits of the binary representation of N are at least K places away

Improve
Improve
Like Article
Like
Save
Share
Report

Given numbers N and K, The task is to check if all the set bits of the binary representation of N are at least K places away.

Examples:  

Input: N = 5, K = 1 
Output: YES
Explanation: 
Binary of 5 is 101.
The 1's are 1 place far from each other.

Input: N = 10, K = 2
Output: NO
Explanation:
Binary of 10 is 1010.
The 1's are not at least 2 places far from each other.

Approach: 

  1. Iterate Over all the bits in the binary representation of N and maintain a variable ‘count’ initialize to 0.
  2. Whenever you find a set bit(1), check if count <= K. If not return false.
  3. If you find a unset bit(0), increases the value of count by 1. 

Below is the implementation of the above approach.

C++




// C++ program to check if all the set
// bits of the binary representation
// of N are at least K places away.
#include <bits/stdc++.h>
using namespace std;
 
bool CheckBits(int N, int K)
{
    // Initialize check and count
    // with 0
    int check = 0;
    int count = 0;
 
    for (int i = 31; i >= 0; i--)
    {
 
        // The i-th bit is a set bit
        if ((1 << i) & N)
        {
 
            // This is the first set bit so,
            // start calculating all the
            // distances between consecutive
            // bits from here
            if (check == 0)
            {
                check = 1;
            }
            else
            {
                // If count is less than K
                // return false
                if (count < K)
                {
                    return false;
                }
            }
            count = 0;
        }
        else
        {
            // Adding the count as the
            // number of zeroes increase
            // between set bits
            count++;
        }
    }
 
    return true;
}
// Driver code
int main()
{
 
    int N = 5;
    int K = 1;
 
    if(CheckBits(N, K))
    {
        cout << "YES";
    }
    else
    {
        cout << "NO";
    }
 
 
 
    return 0;
}


Java




// Java program to check if all the set
// bits of the binary representation
// of N are at least K places away.
import java.util.*;
 
class GFG{
 
static boolean CheckBits(int N, int K)
{
     
    // Initialize check and count
    // with 0
    int check = 0;
    int count = 0;
 
    for(int i = 31; i >= 0; i--)
    {
         
        // The i-th bit is a set bit
        if (((1 << i) & N) > 0)
        {
             
            // This is the first set bit so,
            // start calculating all the
            // distances between consecutive
            // bits from here
            if (check == 0)
            {
                check = 1;
            }
            else
            {
                 
                // If count is less than K
                // return false
                if (count < K)
                {
                    return false;
                }
            }
            count = 0;
        }
        else
        {
             
            // Adding the count as the
            // number of zeroes increase
            // between set bits
            count++;
        }
    }
    return true;
}
 
// Driver code
public static void main(String[] args)
{
    int N = 5;
    int K = 1;
 
    if (CheckBits(N, K))
    {
        System.out.print("YES");
    }
    else
    {
        System.out.print("NO");
    }
}
}
 
// This code is contributed by shikhasingrajput


Python3




# Python3 program to check if all the set
# bits of the binary representation
# of N are at least K places away.
def CheckBits(N, K):
     
    # Initialize check and count
    # with 0
    check = 0
    count = 0
 
    for i in range(31, -1, -1):
 
        # The i-th bit is a set bit
        if ((1 << i) & N):
 
            # This is the first set bit so,
            # start calculating all the
            # distances between consecutive
            # bits from here
            if (check == 0):
                check = 1
 
            else:
 
                # If count is less than K
                # return false
                if (count < K):
                    return False
 
            count = 0
 
        else:
 
            # Adding the count as the
            # number of zeroes increase
            # between set bits
            count += 1
 
    return True
 
# Driver code
if __name__ == "__main__":
     
    N = 5
    K = 1
 
    if (CheckBits(N, K)):
        print("YES")
    else:
        print("NO")
 
# This code is contributed by chitranayal


C#




// C# program to check if all the set
// bits of the binary representation
// of N are at least K places away.
using System;
public class GFG{
 
  static bool CheckBits(int N, int K)
  {
 
    // Initialize check and count
    // with 0
    int check = 0;
    int count = 0;
 
    for(int i = 31; i >= 0; i--)
    {
 
      // The i-th bit is a set bit
      if (((1 << i) & N) > 0)
      {
 
        // This is the first set bit so,
        // start calculating all the
        // distances between consecutive
        // bits from here
        if (check == 0)
        {
          check = 1;
        }
        else
        {
 
          // If count is less than K
          // return false
          if (count < K)
          {
            return false;
          }
        }
        count = 0;
      }
      else
      {
 
        // Adding the count as the
        // number of zeroes increase
        // between set bits
        count++;
      }
    }
    return true;
  }
 
  // Driver code
 
  static public void Main ()
  {
 
    int N = 5;
    int K = 1;
 
    if (CheckBits(N, K))
    {
      Console.Write("YES");
    }
    else
    {
      Console.Write("NO");
    }
 
 
  }
}
 
// This code is contributed by avanitrachhadiya2155


Javascript




<script>
 
// Javascript program to check if all the set
// bits of the binary representation
// of N are at least K places away.
function CheckBits(N, K)
{
     
    // Initialize check and count
    // with 0
    var check = 0;
    var count = 0;
 
    for(var i = 31; i >= 0; i--)
    {
         
        // The i-th bit is a set bit
        if (((1 << i) & N) > 0)
        {
             
            // This is the first set bit so,
            // start calculating all the
            // distances between consecutive
            // bits from here
            if (check == 0)
            {
                check = 1;
            }
            else
            {
                 
                // If count is less than K
                // return false
                if (count < K)
                {
                    return false;
                }
            }
            count = 0;
        }
        else
        {
             
            // Adding the count as the
            // number of zeroes increase
            // between set bits
            count++;
        }
    }
    return true;
}
 
// Driver Code
var N = 5;
var K = 1;
 
if (CheckBits(N, K))
{
    document.write("YES");
}
else
{
    document.write("NO");
}
 
// This code is contributed by Ankita saini
 
</script>


Output: 

YES

 

Time complexity: O(1)
Auxiliary space: O(1)



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