Open In App
Related Articles

Check if a given number is sparse or not

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Write a function to check if a given number is Sparse or not.

A number is said to be a sparse number if in the binary representation of the number no two or more consecutive bits are set.

Example: 

Input:  x  = 72
Output: true
Explanation:  Binary representation of 72 is 01001000. 
There are no two consecutive 1’s in binary representation

Input:  x  = 12
Output: false
Explanation:  Binary representation of 12 is 1100. 
Third and fourth bits (from end) are set.

Naive Approach:  The idea is to check the consecutive bits of the number until the number becomes 0.

C++

#include <iostream>
using namespace std;
 
// Function to check if the number
// is sparse or not.
bool isSparse(int n)
{
    int prev;
 
    if (n == 1)
        return true;
 
    while (n > 0) {
        prev = n & 1;
        n = n >> 1;
        int curr = n & 1;
        if (prev == curr && prev == 1)
            return false;
        prev = curr;
    }
 
    return true;
}
 
// Driver Code
int main()
{
 
    int n = 100;
    if (isSparse(n)) {
        cout << "Sparse";
    }
    else {
        cout << "Not Sparse";
    }
 
    return 0;
}

                    

Java

// "static void main" must be defined in a public class.
public class GFG {
 
    // Function to check if the number
    // is sparse or not.
    static boolean isSparse(int n)
    {
        int prev;
 
        if (n == 1)
            return true;
 
        while (n > 0) {
            prev = n & 1;
            n = n >> 1;
            int curr = n & 1;
            if (prev == curr && prev == 1)
                return false;
            prev = curr;
        }
 
        return true;
    }
 
    public static void main(String[] args)
    {
        int n = 100;
        if (isSparse(n)) {
            System.out.println("Sparse");
        }
        else {
            System.out.println("Not Sparse");
        }
    }
}
 
// This code is contributed by garg28harsh.

                    

Python3

# Python Code to Check if a given
# number is sparse or not
def isSparse(n):
    if (n == 1):
        return true
    global prev
    while(n > 0):
        prev = n & 1
        n = n >> 1
        curr = n & 1
        if(prev == curr and prev == 1):
            return False
        prev = curr
 
    return True
 
# Driver code
n = 100
if (isSparse(n)):
    print("Sparse")
 
else:
    print("Not Sparse")
 
# This code is contributed by karandeep1234

                    

C#

// C# Code to Check if a given
// number is sparse or not
using System;
 
public class GFG {
 
  // Function to check if the number
  // is sparse or not.
  static bool isSparse(int n)
  {
    int prev;
 
    if (n == 1)
      return true;
 
    while (n > 0) {
      prev = n & 1;
      n = n >> 1;
      int curr = n & 1;
      if (prev == curr && prev == 1)
        return false;
      prev = curr;
    }
 
    return true;
  }
 
  public static void Main(string[] args)
  {
    int n = 100;
    if (isSparse(n)) {
      Console.WriteLine("Sparse");
    }
    else {
      Console.WriteLine("Not Sparse");
    }
  }
}
 
// This code is contributed by karandeep1234

                    

Javascript

// Function to check if the number
// is sparse or not.
function isSparse(n)
{
    let prev;
 
    if (n == 1)
        return true;
 
    while (n > 0) {
        prev = n & 1;
        n = n >> 1;
        let curr = n & 1;
        if (prev == curr && prev == 1)
            return false;
        prev = curr;
    }
 
    return true;
}
 
// Driver Code
    let n = 100;
    if (isSparse(n)) {
        console.log( "Sparse");
    }
    else {
        console.log( "Not Sparse");
    }
     
    // This code is contributed by garg28harsh.

                    

Output
Not Sparse

Time Complexity: O(Log2n)
Auxiliary Space: O(1)

Efficient Approach: To solve the problem follow the below idea:

If we observe carefully, then we can notice that if we can use bitwise AND of the binary representation of the “given number, then it’s “right-shifted number”(i.e., half the given number) to figure out whether the number is sparse or not. The result of AND operator would be 0 if the number is sparse and non-zero if not sparse.

 


Below is the implementation of the above approach:

C++

// C++ program to check if n is sparse or not
#include <bits/stdc++.h>
using namespace std;
 
// Return true if n is sparse, else false
bool checkSparse(int n)
{
    // n is not sparse if there is set
    // in AND of n and n/2
    if (n & (n >> 1))
        return false;
 
    return true;
}
 
// Driver code
int main()
{
    // Function call
    cout << checkSparse(72) << endl;
    cout << checkSparse(12) << endl;
    cout << checkSparse(2) << endl;
    cout << checkSparse(3) << endl;
    return 0;
}

                    

Java

// JAVA Code to Check if a
// given number is sparse or not
import java.util.*;
 
class GFG {
 
    // Return true if n is
    // sparse,else false
    static int checkSparse(int n)
    {
 
        // n is not sparse if there
        // is set in AND of n and n/2
        if ((n & (n >> 1)) >= 1)
            return 0;
 
        return 1;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        // Function call
        System.out.println(checkSparse(72));
        System.out.println(checkSparse(12));
        System.out.println(checkSparse(2));
        System.out.println(checkSparse(3));
    }
}
 
// This code is contributed by Arnav Kr. Mandal.

                    

Python3

# Python program to check
# if n is sparse or not
 
# Return true if n is
# sparse, else false
 
 
def checkSparse(n):
 
    # n is not sparse if there is set
    # in AND of n and n/2
    if (n & (n >> 1)):
        return 0
 
    return 1
 
 
# Driver code
if __name__ == "__main__":
 
    # Function call
    print(checkSparse(72))
    print(checkSparse(12))
    print(checkSparse(2))
    print(checkSparse(30))
 
# This code is contributed
# by Anant Agarwal.

                    

C#

// C# Code to Check if a given
// number is sparse or not
using System;
 
class GFG {
 
    // Return true if n is
    // sparse,else false
    static int checkSparse(int n)
    {
 
        // n is not sparse if there
        // is set in AND of n and n/2
        if ((n & (n >> 1)) >= 1)
            return 0;
 
        return 1;
    }
 
    // Driver code
    public static void Main()
    {
        // Function call
        Console.WriteLine(checkSparse(72));
        Console.WriteLine(checkSparse(12));
        Console.WriteLine(checkSparse(2));
        Console.WriteLine(checkSparse(3));
    }
}
 
// This code is contributed by Sam007.

                    

PHP

<?php
// PHP program to check if
// n is sparse or not
// Return true if n is sparse,
// else false
 
function checkSparse($n)
{
    // n is not sparse if
    // there is set in AND
    // of n and n/2
    if ($n & ($n >> 1))
        return 0;
 
    return 1;
}
 
// Driver Code
 
// Function call
echo checkSparse(72), "\n";
echo checkSparse(12), "\n";
echo checkSparse(2), "\n";
echo checkSparse(3), "\n";
 
// This code is contributed by Ajit.
?>

                    

Javascript

<script>
 
    // Javascript program to check if n is sparse or not
     
    // Return true if n is sparse, else false
    function checkSparse(n)
    {
        // n is not sparse if there is set
        // in AND of n and n/2
        if ((n & (n>>1)) > 0)
            return 0;
 
        return 1;
    }
     
    document.write(checkSparse(72) + "</br>");
    document.write(checkSparse(12) + "</br>");
    document.write(checkSparse(2) + "</br>");
    document.write(checkSparse(3) + "</br>");
     
</script>

                    

Output
1
0
1
0

Time Complexity: O(1)
Auxiliary Space: O(1)

Note: Instead of the right shift, we could have used the left shift also, but the left shift might lead to an overflow in some cases.



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