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

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)