leetcode

Author: ayoubzulfiqar

BitwiseAndOfNumbersRange/bitwise_and_of_numbers_range.dart

@@ -0,0 +1,47 @@
+/*
+
+
+-* 201 Bitwise AND of Numbers Range *-
+
+
+Given two integers left and right that represent the range [left, right], return the bitwise AND of all numbers in this range, inclusive.
+
+ 
+
+Example 1:
+
+Input: left = 5, right = 7
+Output: 4
+Example 2:
+
+Input: left = 0, right = 0
+Output: 0
+Example 3:
+
+Input: left = 1, right = 2147483647
+Output: 0
+ 
+
+Constraints:
+
+0 <= left <= right <= 231 - 1
+
+*/
+
+class Solution {
+ int rangeBitwiseAnd(int left, int right) {
+ int shiftCount = 0;
+ while (left < right) {
+ left >>= 1;
+ right >>= 1;
+ shiftCount += 1;
+ }
+ return left << shiftCount;
+ }
+ int rangeBitwiseAnd2(int left, int right) {
+ while (right > left) {
+ right &= (right - 1);
+ }
+ return right;
+ }
+}

BitwiseAndOfNumbersRange/bitwise_and_of_numbers_range.go

@@ -0,0 +1,17 @@
+package main
+
+func rangeBitwiseAnd(left int, right int) int {
+var shift_count int = 0
+for left < right {
+left >>= 1
+right >>= 1
+shift_count += 1
+}
+return left << shift_count
+
+for left < right {
+right &= (right - 1)
+
+}
+return right
+}

BitwiseAndOfNumbersRange/bitwise_and_of_numbers_range.md

@@ -0,0 +1,39 @@
+# 🔥 Bitwise AND of Numbers Range 🔥 || Simple Fast and Easy || with Explanation
+
+### Intuition and Approach
+
+This code aims to find the bitwise AND of all numbers within the given range [left, right], inclusive. The approach used in this code is to iteratively reduce the `right` number by unsetting its least significant bit until `left` becomes equal to or greater than `right`. Since the range is contiguous, unsetting the least significant bit eventually leads to the common prefix of `left` and `right`, which represents the bitwise AND of all numbers in the range.
+
+### Time Complexity
+
+The time complexity of this approach depends on the number of bits in the input numbers. In the worst case, the loop iterates until `left` becomes equal to or greater than `right`. Each iteration of the loop involves unsetting the least significant bit of `right` using the operation `right &= (right - 1)`, which takes O(1) time. Therefore, the overall time complexity is O(log n), where n is the maximum of `left` and `right`.
+
+### Space Complexity
+
+The space complexity of this code is O(1), as it only uses a constant amount of extra space for storing temporary variables and does not depend on the input size.
+
+This code offers a more efficient approach compared to directly iterating through the range of numbers, making it suitable for finding the bitwise AND of large ranges. However, both approaches aim to achieve the same result.
+
+## Code
+
+```go
+func rangeBitwiseAnd(left int, right int) int {
+ for left < right {
+ right &= (right - 1)
+ }
+ return right
+}
+
+// Another Implementation
+func rangeBitwiseAnd(left int, right int) int {
+var shift_count int = 0
+for left < right {
+left >>= 1
+right >>= 1
+shift_count += 1
+}
+return left << shift_count
+}
+```
+
+## [GitHub](https://github.com/ayoubzulfiqar/leetcode)