find the next sparse number

Author: danrusei

README.md

@@ -100,7 +100,7 @@ WIP, the descriptions of the below `unsolved yet` problems can be found in the [
 - [] Count total set bits in all numbers from 1 to n
 - [x] [Rotate bits of a number](https://github.com/danrusei/algorithms_with_Go/tree/main/bitwise/rotate_bits)
 - [] Count number of bits to be flipped to convert A to B
-- [] Find Next Sparse Number
+- [x] [Find Next Sparse Number](https://github.com/danrusei/algorithms_with_Go/tree/main/bitwise/next_sparse)
 
 ## [String / Array](https://github.com/danrusei/algorithms_with_Go/tree/main/strings)
 

bitwise/next_sparse/README.md

@@ -0,0 +1,41 @@
+# Find Next Sparse Number 
+
+Source: [GeeksforGeeks](https://www.geeksforgeeks.org/given-a-number-find-next-sparse-number/amp/)  
+
+Given a number x, find the smallest Sparse number which greater than or equal to x.  
+A number is Sparse if there are no two adjacent 1s in its binary representation. For example 5 (binary representation: 101) is sparse, but 6 (binary representation: 110) is not sparse.
+
+## Example
+
+```bash
+Input: x = 6
+Output: Next Sparse Number is 8
+
+Input: x = 4
+Output: Next Sparse Number is 4
+
+Input: x = 38
+Output: Next Sparse Number is 40
+
+Input: x = 44
+Output: Next Sparse Number is 64
+```
+
+## Algorithm
+
+There is a simple solution which check if the number is sparse, if not it moves to the next decimal number and so on.  
+Although this is a valid solution is not so efficient, a more efficient solution is described below:
+
+* store the binary of a given number in a slice  
+* initialize the last finalized bit position as 0
+* traverse the slice, and start with least significatn bit (from right to left)
+  * if we find two adjacent 1's such that next (or third) bit is not 1, then:
+    * Make all bits after this 1 to last finalized bit 0
+    * Update last finalized bit as next bit
+
+## Result
+
+```bash
+$ go run main.go 
+next sparse number starting from 38 is 40
+```

bitwise/next_sparse/main.go

@@ -0,0 +1,52 @@
+package main
+
+import "fmt"
+
+func nextSparse(x int) int {
+
+	// bin store the binary representation of x
+	// bin[0] contains least significant bit
+	bin := []int{}
+	for x != 0 {
+		bin = append(bin, x&1)
+		x >>= 1
+	}
+
+	last := 0
+
+	for i := 1; i < len(bin); i++ {
+
+		if bin[i] == 1 && bin[i-1] == 1 && bin[i+1] != 1 {
+
+			// make the next bit 1
+			bin[i+1] = 1
+
+			// make all bits before current bit as 0 to make
+			// sure that we get the smallest next number
+			for j := i; j >= last; j-- {
+				bin[j] = 0
+
+			}
+
+			// store position of the bit set so that this bit
+			// and bits before it are not changed next time.
+			last = i + 1
+		}
+	}
+
+	//create and return the decimal equivalent of modified bin[]
+	result := 0
+	for i := 0; i < len(bin); i++ {
+		result += bin[i] * (1 << i)
+	}
+
+	return result
+}
+
+func main() {
+	x := 38
+	y := nextSparse(x)
+
+	fmt.Printf("next sparse number starting from %d is %d\n", x, y)
+
+}