# Check if a given number is sparse or not

Last Updated : 10 Nov, 2022

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.

Recommended Problem

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

## C++

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

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

 ``

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.

Previous
Next