Merge branch 'master' into patch-2

Author: manishraj27

src/main/java/com/thealgorithms/bitmanipulation/ReverseBits.java

@@ -1,14 +1,33 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Converts any Octal Number to a Binary Number
+ * This class provides a method to reverse the bits of a 32-bit integer.
+ * Reversing the bits means that the least significant bit (LSB) becomes
+ * the most significant bit (MSB) and vice versa.
+ *
+ * Example:
+ * Input (binary): 00000010100101000001111010011100 (43261596)
+ * Output (binary): 00111001011110000010100101000000 (964176192)
+ *
+ * Time Complexity: O(32) - A fixed number of 32 iterations
+ * Space Complexity: O(1) - No extra space used
+ *
+ * Note:
+ * - If the input is negative, Java handles it using two’s complement representation.
+ * - This function works on 32-bit integers by default.
+ *
  * @author Bama Charan Chhandogi
  */
-
 public final class ReverseBits {
     private ReverseBits() {
     }
 
+    /**
+     * Reverses the bits of a 32-bit integer.
+     *
+     * @param n the integer whose bits are to be reversed
+     * @return the integer obtained by reversing the bits of the input
+     */
     public static int reverseBits(int n) {
         int result = 0;
         int bitCount = 32;

src/main/java/com/thealgorithms/bitmanipulation/SwapAdjacentBits.java

@@ -1,14 +1,45 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Swap every pair of adjacent bits of a given number.
- * @author Lakshyajeet Singh Goyal (https://github.com/DarkMatter-999)
+ * A utility class to swap every pair of adjacent bits in a given integer.
+ * This operation shifts the even-positioned bits to odd positions and vice versa.
+ *
+ * Example:
+ * - Input: 2 (binary: `10`) → Output: 1 (binary: `01`)
+ * - Input: 43 (binary: `101011`) → Output: 23 (binary: `010111`)
+ *
+ * **Explanation of the Algorithm:**
+ * 1. Mask even-positioned bits: Using `0xAAAAAAAA` (binary: `101010...`),
+ *    which selects bits in even positions.
+ * 2. Mask odd-positioned bits: Using `0x55555555` (binary: `010101...`),
+ *    which selects bits in odd positions.
+ * 3. Shift bits:
+ *    - Right-shift even-positioned bits by 1 to move them to odd positions.
+ *    - Left-shift odd-positioned bits by 1 to move them to even positions.
+ * 4. Combine both shifted results using bitwise OR (`|`) to produce the final result.
+ *
+ * Use Case: This algorithm can be useful in applications involving low-level bit manipulation,
+ * such as encoding, data compression, or cryptographic transformations.
+ *
+ * Time Complexity: O(1) (constant time, since operations are bitwise).
+ *
+ * Author: Lakshyajeet Singh Goyal (https://github.com/DarkMatter-999)
  */
-
 public final class SwapAdjacentBits {
     private SwapAdjacentBits() {
     }
 
+    /**
+     * Swaps every pair of adjacent bits of a given integer.
+     * Steps:
+     * 1. Mask the even-positioned bits.
+     * 2. Mask the odd-positioned bits.
+     * 3. Shift the even bits to the right and the odd bits to the left.
+     * 4. Combine the shifted bits.
+     *
+     * @param num the integer whose bits are to be swapped
+     * @return the integer after swapping every pair of adjacent bits
+     */
     public static int swapAdjacentBits(int num) {
         // mask the even bits (0xAAAAAAAA => 10101010...)
         int evenBits = num & 0xAAAAAAAA;

src/test/java/com/thealgorithms/bitmanipulation/ReverseBitsTest.java

@@ -2,14 +2,40 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import org.junit.jupiter.api.Test;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class ReverseBitsTest {
 
-    @Test
-    void testReverseBits() {
-        assertEquals(0, ReverseBits.reverseBits(0));
-        assertEquals(-1, ReverseBits.reverseBits(-1));
-        assertEquals(964176192, ReverseBits.reverseBits(43261596));
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    void testReverseBits(int input, int expected) {
+        assertEquals(expected, ReverseBits.reverseBits(input));
+    }
+
+    private static Stream<Arguments> provideTestCases() {
+        return Stream.of(
+            // Edge case: All bits are 0
+            Arguments.of(0, 0),
+
+            // Edge case: All bits are 1 (Two’s complement representation of -1)
+            Arguments.of(-1, -1),
+
+            // Case with random number 43261596
+            Arguments.of(43261596, 964176192),
+
+            // Case with maximum positive value for 32-bit integer
+            Arguments.of(Integer.MAX_VALUE, -2),
+
+            // Case with minimum value (all bits 1 except the sign bit)
+            Arguments.of(Integer.MIN_VALUE, 1),
+
+            // Case with a single bit set (2^0 = 1)
+            Arguments.of(1, Integer.MIN_VALUE),
+
+            // Case with alternating bits: 0b101010...10 (in binary)
+            Arguments.of(0xAAAAAAAA, 0x55555555));
     }
 }

src/test/java/com/thealgorithms/bitmanipulation/SwapAdjacentBitsTest.java

@@ -8,13 +8,20 @@
 class SwapAdjacentBitsTest {
 
     @ParameterizedTest
-    @CsvSource({
-        "2, 1", // 2 (10 in binary) should become 1 (01 in binary)
-        "43, 23", // 43 should become 23
-        "153, 102", // 153 should become 102
-        "15, 15", // 15 (1111) remains 15 (1111)
-        "0, 0" // 0 (0000) remains 0 (0000)
-    })
+    @CsvSource({"2, 1", // 2 (binary: 10) -> 1 (binary: 01)
+        "43, 23", // 43 (binary: 101011) -> 23 (binary: 010111)
+        "153, 102", // 153 (binary: 10011001) -> 102 (binary: 01100110)
+        "15, 15", // 15 (binary: 1111) -> 15 (binary: 1111) (no change)
+        "0, 0", // 0 (binary: 0000) -> 0 (binary: 0000) (no change)
+        "1, 2", // 1 (binary: 01) -> 2 (binary: 10)
+        "170, 85", // 170 (binary: 10101010) -> 85 (binary: 01010101)
+        "85, 170", // 85 (binary: 01010101) -> 170 (binary: 10101010)
+        "255, 255", // 255 (binary: 11111111) -> 255 (binary: 11111111) (no change)
+        "128, 64", // 128 (binary: 10000000) -> 64 (binary: 01000000)
+        "1024, 2048",
+        "-1, -1", // -1 (all bits 1) remains -1 (no change due to two's complement)
+        "-2, -3", // -2 (binary: ...1110) -> -3 (binary: ...1101)
+        "2147483647, -1073741825", "-2147483648, -1073741824"})
     void
     testSwapAdjacentBits(int input, int expected) {
         assertEquals(expected, SwapAdjacentBits.swapAdjacentBits(input));