Merge remote-tracking branch 'origin/master'

Author: sherlockwayne

DIRECTORY.md

@@ -26,9 +26,11 @@
             * [BcdConversion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/BcdConversion.java)
             * [BinaryPalindromeCheck](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/BinaryPalindromeCheck.java)
             * [BitSwap](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/BitSwap.java)
+            * [BooleanAlgebraGates](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/BooleanAlgebraGates.java)
             * [ClearLeftmostSetBit](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/ClearLeftmostSetBit.java)
             * [CountLeadingZeros](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/CountLeadingZeros.java)
             * [CountSetBits](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/CountSetBits.java)
+            * [FindNthBit](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java)
             * [GrayCodeConversion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/GrayCodeConversion.java)
             * [HammingDistance](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/HammingDistance.java)
             * [HigherLowerPowerOfTwo](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/HigherLowerPowerOfTwo.java)
@@ -47,6 +49,7 @@
             * [SingleElement](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/SingleElement.java)
             * [SwapAdjacentBits](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/SwapAdjacentBits.java)
             * [TwosComplement](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/TwosComplement.java)
+            * [Xs3Conversion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/Xs3Conversion.java)
           * ciphers
             * a5
               * [A5Cipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/a5/A5Cipher.java)
@@ -55,6 +58,7 @@
               * [CompositeLFSR](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/a5/CompositeLFSR.java)
               * [LFSR](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/a5/LFSR.java)
               * [Utils](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/a5/Utils.java)
+            * [ADFGVXCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/ADFGVXCipher.java)
             * [AES](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/AES.java)
             * [AESEncryption](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/AESEncryption.java)
             * [AffineCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/AffineCipher.java)
@@ -134,6 +138,7 @@
               * [FordFulkerson](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/FordFulkerson.java)
               * [Graphs](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/Graphs.java)
               * [HamiltonianCycle](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/HamiltonianCycle.java)
+              * [JohnsonsAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/JohnsonsAlgorithm.java)
               * [KahnsAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/KahnsAlgorithm.java)
               * [Kosaraju](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/Kosaraju.java)
               * [Kruskal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/Kruskal.java)
@@ -341,6 +346,7 @@
             * [EulersFunction](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/EulersFunction.java)
             * [Factorial](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/Factorial.java)
             * [FactorialRecursion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FactorialRecursion.java)
+            * [FastExponentiation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FastExponentiation.java)
             * [FastInverseSqrt](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FastInverseSqrt.java)
             * [FFT](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FFT.java)
             * [FFTBluestein](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FFTBluestein.java)
@@ -658,9 +664,11 @@
             * [BcdConversionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/BcdConversionTest.java)
             * [BinaryPalindromeCheckTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/BinaryPalindromeCheckTest.java)
             * [BitSwapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/BitSwapTest.java)
+            * [BooleanAlgebraGatesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/BooleanAlgebraGatesTest.java)
             * [ClearLeftmostSetBitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/ClearLeftmostSetBitTest.java)
             * [CountLeadingZerosTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/CountLeadingZerosTest.java)
             * [CountSetBitsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/CountSetBitsTest.java)
+            * [FindNthBitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/FindNthBitTest.java)
             * [GrayCodeConversionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/GrayCodeConversionTest.java)
             * [HammingDistanceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/HammingDistanceTest.java)
             * [HigherLowerPowerOfTwoTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/HigherLowerPowerOfTwoTest.java)
@@ -679,11 +687,13 @@
             * [SingleElementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/SingleElementTest.java)
             * [SwapAdjacentBitsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/SwapAdjacentBitsTest.java)
             * [TwosComplementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/TwosComplementTest.java)
+            * [Xs3ConversionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/Xs3ConversionTest.java)
           * ciphers
             * a5
               * [A5CipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/a5/A5CipherTest.java)
               * [A5KeyStreamGeneratorTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/a5/A5KeyStreamGeneratorTest.java)
               * [LFSRTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/a5/LFSRTest.java)
+            * [ADFGVXCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/ADFGVXCipherTest.java)
             * [AESEncryptionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/AESEncryptionTest.java)
             * [AffineCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/AffineCipherTest.java)
             * [AtbashTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/AtbashTest.java)
@@ -752,6 +762,7 @@
               * [FloydWarshallTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/FloydWarshallTest.java)
               * [FordFulkersonTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/FordFulkersonTest.java)
               * [HamiltonianCycleTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/HamiltonianCycleTest.java)
+              * [JohnsonsAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/JohnsonsAlgorithmTest.java)
               * [KosarajuTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/KosarajuTest.java)
               * [TarjansAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithmTest.java)
               * [WelshPowellTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/WelshPowellTest.java)
@@ -904,6 +915,7 @@
             * [EulersFunctionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/EulersFunctionTest.java)
             * [FactorialRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FactorialRecursionTest.java)
             * [FactorialTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FactorialTest.java)
+            * [FastExponentiationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FastExponentiationTest.java)
             * [FastInverseSqrtTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FastInverseSqrtTests.java)
             * [FFTTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FFTTest.java)
             * [FibonacciJavaStreamsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FibonacciJavaStreamsTest.java)
@@ -1012,6 +1024,7 @@
             * [SkylineProblemTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/SkylineProblemTest.java)
             * [SudokuTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/SudokuTest.java)
             * [TestPrintMatrixInSpiralOrder](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TestPrintMatrixInSpiralOrder.java)
+            * [TowerOfHanoiTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TowerOfHanoiTest.java)
             * [TwoPointersTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TwoPointersTest.java)
             * [WorstFitCPUTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/WorstFitCPUTest.java)
           * Recursion

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

@@ -0,0 +1,58 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * This class provides methods to convert between XS-3 (Excess-3) and binary.
+ *
+ * Excess-3, also called XS-3, is a binary-coded decimal (BCD) code in which each decimal digit is represented by its corresponding 4-bit binary value plus 3.
+ *
+ * For more information, refer to the
+ * <a href="https://en.wikipedia.org/wiki/Excess-3">Excess-3</a> Wikipedia page.
+ *
+ * <b>Example usage:</b>
+ * <pre>
+ * int binary = Xs3Conversion.xs3ToBinary(0x4567);
+ * System.out.println("XS-3 0x4567 to binary: " + binary); // Output: 1234
+ *
+ * int xs3 = Xs3Conversion.binaryToXs3(1234);
+ * System.out.println("Binary 1234 to XS-3: " + Integer.toHexString(xs3)); // Output: 0x4567
+ * </pre>
+ */
+public final class Xs3Conversion {
+    private Xs3Conversion() {
+    }
+    /**
+     * Converts an XS-3 (Excess-3) number to binary.
+     *
+     * @param xs3 The XS-3 number.
+     * @return The corresponding binary number.
+     */
+    public static int xs3ToBinary(int xs3) {
+        int binary = 0;
+        int multiplier = 1;
+        while (xs3 > 0) {
+            int digit = (xs3 & 0xF) - 3; // Extract the last 4 bits (one XS-3 digit) and subtract 3
+            binary += digit * multiplier;
+            multiplier *= 10;
+            xs3 >>= 4; // Shift right by 4 bits to process the next XS-3 digit
+        }
+        return binary;
+    }
+
+    /**
+     * Converts a binary number to XS-3 (Excess-3).
+     *
+     * @param binary The binary number.
+     * @return The corresponding XS-3 number.
+     */
+    public static int binaryToXs3(int binary) {
+        int xs3 = 0;
+        int shift = 0;
+        while (binary > 0) {
+            int digit = (binary % 10) + 3; // Extract the last decimal digit and add 3
+            xs3 |= (digit << (shift * 4)); // Shift the digit to the correct XS-3 position
+            binary /= 10; // Remove the last decimal digit
+            shift++;
+        }
+        return xs3;
+    }
+}

src/main/java/com/thealgorithms/others/TowerOfHanoi.java

@@ -1,29 +1,65 @@
 package com.thealgorithms.others;
 
-import java.util.Scanner;
+import java.util.List;
 
+/**
+ * The {@code TowerOfHanoi} class provides a recursive solution to the Tower of Hanoi puzzle.
+ * This puzzle involves moving a set of discs from one pole to another, following specific rules:
+ * 1. Only one disc can be moved at a time.
+ * 2. A disc can only be placed on top of a larger disc.
+ * 3. All discs must start on one pole and end on another.
+ *
+ * This implementation recursively calculates the steps required to solve the puzzle and stores them
+ * in a provided list.
+ *
+ * <p>
+ * For more information about the Tower of Hanoi, see
+ * <a href="https://en.wikipedia.org/wiki/Tower_of_Hanoi">Tower of Hanoi on Wikipedia</a>.
+ * </p>
+ *
+ * The {@code shift} method takes the number of discs and the names of the poles,
+ * and appends the steps required to solve the puzzle to the provided list.
+ * Time Complexity: O(2^n) - Exponential time complexity due to the recursive nature of the problem.
+ * Space Complexity: O(n) - Linear space complexity due to the recursion stack.
+ * Wikipedia: https://en.wikipedia.org/wiki/Tower_of_Hanoi
+ */
 final class TowerOfHanoi {
+
     private TowerOfHanoi() {
     }
 
-    public static void shift(int n, String startPole, String intermediatePole, String endPole) {
-        // if n becomes zero the program returns thus ending the loop.
+    /**
+     * Recursively solve the Tower of Hanoi puzzle by moving discs between poles.
+     *
+     * @param n                The number of discs to move.
+     * @param startPole        The name of the start pole from which discs are moved.
+     * @param intermediatePole The name of the intermediate pole used as a temporary holding area.
+     * @param endPole          The name of the end pole to which discs are moved.
+     * @param result           A list to store the steps required to solve the puzzle.
+     *
+     *                         <p>
+     *                         This method is called recursively to move n-1 discs
+     *                         to the intermediate pole,
+     *                         then moves the nth disc to the end pole, and finally
+     *                         moves the n-1 discs from the
+     *                         intermediate pole to the end pole.
+     *                         </p>
+     *
+     *                         <p>
+     *                         Time Complexity: O(2^n) - Exponential time complexity due to the recursive nature of the problem.
+     *                         Space Complexity: O(n) - Linear space complexity due to the recursion stack.
+     *                         </p>
+     */
+    public static void shift(int n, String startPole, String intermediatePole, String endPole, List<String> result) {
         if (n != 0) {
-            // Shift function is called in recursion for swapping the n-1 disc from the startPole to
-            // the intermediatePole
-            shift(n - 1, startPole, endPole, intermediatePole);
-            System.out.format("Move %d from %s to %s%n", n, startPole, endPole); // Result Printing
-            // Shift function is called in recursion for swapping the n-1 disc from the
-            // intermediatePole to the endPole
-            shift(n - 1, intermediatePole, startPole, endPole);
-        }
-    }
+            // Move n-1 discs from startPole to intermediatePole
+            shift(n - 1, startPole, endPole, intermediatePole, result);
 
-    public static void main(String[] args) {
-        System.out.print("Enter number of discs on Pole 1: ");
-        Scanner scanner = new Scanner(System.in);
-        int numberOfDiscs = scanner.nextInt(); // input of number of discs on pole 1
-        shift(numberOfDiscs, "Pole1", "Pole2", "Pole3"); // Shift function called
-        scanner.close();
+            // Add the move of the nth disc from startPole to endPole
+            result.add(String.format("Move %d from %s to %s", n, startPole, endPole));
+
+            // Move the n-1 discs from intermediatePole to endPole
+            shift(n - 1, intermediatePole, startPole, endPole, result);
+        }
     }
 }

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

@@ -0,0 +1,65 @@
+package com.thealgorithms.bitmanipulation;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for the Xs3Conversion class.
+ */
+public class Xs3ConversionTest {
+
+    /**
+     * Test the xs3ToBinary method with an XS-3 number.
+     */
+    @Test
+    public void testXs3ToBinary() {
+        int binary = Xs3Conversion.xs3ToBinary(0x4567);
+        assertEquals(1234, binary); // XS-3 0x4567 should convert to binary 1234
+    }
+
+    /**
+     * Test the binaryToXs3 method with a binary number.
+     */
+    @Test
+    public void testBinaryToXs3() {
+        int xs3 = Xs3Conversion.binaryToXs3(1234);
+        assertEquals(0x4567, xs3); // Binary 1234 should convert to XS-3 0x4567
+    }
+
+    /**
+     * Test the xs3ToBinary method with zero.
+     */
+    @Test
+    public void testXs3ToBinaryZero() {
+        int binary = Xs3Conversion.xs3ToBinary(0x0);
+        assertEquals(0, binary); // XS-3 0x0 should convert to binary 0
+    }
+
+    /**
+     * Test the binaryToXs3 method with zero.
+     */
+    @Test
+    public void testBinaryToXs3Zero() {
+        int xs3 = Xs3Conversion.binaryToXs3(0);
+        assertEquals(0x0, xs3); // Binary 0 should convert to XS-3 0x0
+    }
+
+    /**
+     * Test the xs3ToBinary method with a single digit XS-3 number.
+     */
+    @Test
+    public void testXs3ToBinarySingleDigit() {
+        int binary = Xs3Conversion.xs3ToBinary(0x5);
+        assertEquals(2, binary); // XS-3 0x5 should convert to binary 2
+    }
+
+    /**
+     * Test the binaryToXs3 method with a single digit binary number.
+     */
+    @Test
+    public void testBinaryToXs3SingleDigit() {
+        int xs3 = Xs3Conversion.binaryToXs3(2);
+        assertEquals(0x5, xs3); // Binary 2 should convert to XS-3 0x5
+    }
+}