The bitwise AND operation identifies common bit patterns among numbers. When applied to a range of numbers, it effectively highlights the highest common bits, essentially finding the "common prefix" of the binary representations within the range.
+ *This is useful in cases where you need to compress data or perform range-based operations, such as in networking (for subnet calculations), IP range checks, or optimizing certain computations that rely on binary prefixes.
+ *In some algorithmic problems, you might want to check commonalities between consecutive numbers in a range. Instead of iterating over the entire range and performing individual AND operations, this algorithm helps compress that into a single step, improving performance.
+ *In certain mathematical or data compression problems, grouping numbers based on their common binary patterns can be helpful. The bitwise AND of numbers over a range can act as a first step toward identifying such groups.
+ *This operation can save time in situations where you're performing repetitive bitwise operations over large data sets, as it helps identify the "stable" bits across numbers in a range without computing it for every single pair.
+ *
+ * int result = BitWiseAndInRange.rangeBitwiseAnd(5, 7);
+ * System.out.println("Bitwise AND of range [5, 7]: " + result); // Output: 4
+ *
+ * @author Tanmay Singh
+ */
+public final class BitWiseAndInRange {
+ private BitWiseAndInRange() {
+ }
+
+ /**
+ * Computes the bitwise AND of all integers within the given range [m, n].
+ *
+ * @param m the start of the range (inclusive)
+ * @param n the end of the range (inclusive)
+ * @return the bitwise AND of all integers in the range [m, n]
+ */
+ public static int rangeBitwiseAnd(int m, int n) {
+ while (m < n) {
+ // Turn off the rightmost 1-bit of n
+ n = n & (n - 1);
+ }
+ return n;
+ }
+}
diff --git a/src/test/java/com/thealgorithms/bitmanipulation/BitWiseAndInRangeTest.java b/src/test/java/com/thealgorithms/bitmanipulation/BitWiseAndInRangeTest.java
new file mode 100644
index 000000000000..d502da7b5b50
--- /dev/null
+++ b/src/test/java/com/thealgorithms/bitmanipulation/BitWiseAndInRangeTest.java
@@ -0,0 +1,56 @@
+package com.thealgorithms.bitmanipulation;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for the BitWiseAndInRange class.
+ */
+public class BitWiseAndInRangeTest {
+
+ /**
+ * Test the rangeBitwiseAnd method with a range that includes multiple numbers.
+ */
+ @Test
+ public void testRangeBitwiseAndMultipleNumbers() {
+ int result = BitWiseAndInRange.rangeBitwiseAnd(5, 7);
+ assertEquals(4, result); // Bitwise AND of range [5, 7] should be 4
+ }
+
+ /**
+ * Test the rangeBitwiseAnd method with a range that includes a single number.
+ */
+ @Test
+ public void testRangeBitwiseAndSingleNumber() {
+ int result = BitWiseAndInRange.rangeBitwiseAnd(5, 5);
+ assertEquals(5, result); // Bitwise AND of range [5, 5] should be 5
+ }
+
+ /**
+ * Test the rangeBitwiseAnd method with a range that includes zero.
+ */
+ @Test
+ public void testRangeBitwiseAndIncludesZero() {
+ int result = BitWiseAndInRange.rangeBitwiseAnd(0, 1);
+ assertEquals(0, result); // Bitwise AND of range [0, 1] should be 0
+ }
+
+ /**
+ * Test the rangeBitwiseAnd method with a large range.
+ */
+ @Test
+ public void testRangeBitwiseAndLargeRange() {
+ int result = BitWiseAndInRange.rangeBitwiseAnd(0, 2147483647);
+ assertEquals(0, result); // Bitwise AND of range [0, 2147483647] should be 0
+ }
+
+ /**
+ * Test the rangeBitwiseAnd method with a range that includes negative numbers.
+ */
+ @Test
+ public void testRangeBitwiseAndNegativeNumbers() {
+ int result = BitWiseAndInRange.rangeBitwiseAnd(-5, -3);
+ assertEquals(-8, result); // Bitwise AND of range [-5, -3] should be -8
+ }
+}