Add Power of Four Check using bit manipulation

- Implements isPowerOfFour method using bit manipulation
- Checks if number is power of two and has bit at even position
- Includes comprehensive unit tests
- Fixes TheAlgorithms#6940

Author: krishna-medapati

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

@@ -0,0 +1,36 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * Utility class for checking if a number is a power of four.
+ * A power of four is a number that can be expressed as 4^n where n is a non-negative integer.
+ * This class provides a method to determine if a given integer is a power of four using bit manipulation.
+ *
+ * @author krishna-medapati (https://github.com/krishna-medapati)
+ */
+public final class PowerOfFour {
+    private PowerOfFour() {
+    }
+
+    /**
+     * Checks if the given integer is a power of four.
+     *
+     * A number is considered a power of four if:
+     * 1. It is greater than zero
+     * 2. It has exactly one '1' bit in its binary representation (power of two)
+     * 3. The '1' bit is at an even position (0, 2, 4, 6, ...)
+     *
+     * The method uses the mask 0x55555555 (binary: 01010101010101010101010101010101)
+     * to check if the set bit is at an even position.
+     *
+     * @param number the integer to check
+     * @return true if the number is a power of four, false otherwise
+     */
+    public static boolean isPowerOfFour(int number) {
+        if (number <= 0) {
+            return false;
+        }
+        boolean isPowerOfTwo = (number & (number - 1)) == 0;
+        boolean hasEvenBitPosition = (number & 0x55555555) != 0;
+        return isPowerOfTwo && hasEvenBitPosition;
+    }
+}

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

@@ -0,0 +1,35 @@
+package com.thealgorithms.bitmanipulation;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;
+
+class PowerOfFourTest {
+    
+    @Test
+    void testPowersOfFour() {
+        assertTrue(PowerOfFour.isPowerOfFour(1));
+        assertTrue(PowerOfFour.isPowerOfFour(4));
+        assertTrue(PowerOfFour.isPowerOfFour(16));
+        assertTrue(PowerOfFour.isPowerOfFour(64));
+        assertTrue(PowerOfFour.isPowerOfFour(256));
+        assertTrue(PowerOfFour.isPowerOfFour(1024));
+    }
+    
+    @Test
+    void testNonPowersOfFour() {
+        assertFalse(PowerOfFour.isPowerOfFour(2));
+        assertFalse(PowerOfFour.isPowerOfFour(3));
+        assertFalse(PowerOfFour.isPowerOfFour(5));
+        assertFalse(PowerOfFour.isPowerOfFour(8));
+        assertFalse(PowerOfFour.isPowerOfFour(15));
+        assertFalse(PowerOfFour.isPowerOfFour(32));
+    }
+    
+    @Test
+    void testEdgeCases() {
+        assertFalse(PowerOfFour.isPowerOfFour(0));
+        assertFalse(PowerOfFour.isPowerOfFour(-1));
+        assertFalse(PowerOfFour.isPowerOfFour(-4));
+    }
+}