Merge branch 'master' into minstack2_new_algo

Author: alxkm

DIRECTORY.md

@@ -183,7 +183,7 @@
     <!-- See https://checkstyle.org/checks/misc/index.html -->
     <module name="ArrayTypeStyle"/>
     <!-- TODO <module name="FinalParameters"/> -->
-    <!-- TODO <module name="TodoComment"/> -->
+    <module name="TodoComment"/>
     <module name="UpperEll"/>
 
     <!-- https://checkstyle.org/filters/suppressionxpathfilter.html -->

checkstyle.xml

@@ -40,6 +40,13 @@
             <version>${assertj.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.14.1</version>
+            <scope>test</scope>
+        </dependency>
+
 
         <dependency>
             <groupId>org.junit.jupiter</groupId>

pom.xml

@@ -87,9 +87,6 @@
         <Bug pattern="RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE" />
     </Match>
     <!-- fb-contrib -->
-    <Match>
-        <Bug pattern="OCP_OVERLY_CONCRETE_PARAMETER" />
-    </Match>
     <Match>
         <Bug pattern="LSC_LITERAL_STRING_COMPARISON" />
     </Match>

spotbugs-exclude.xml

@@ -1,6 +1,7 @@
 package com.thealgorithms.backtracking;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -95,7 +96,7 @@ public static void removeWord(char[][] puzzle, String word, int row, int col, bo
      * @param words  The list of words to be placed.
      * @return true if the crossword is solved, false otherwise.
      */
-    public static boolean solveCrossword(char[][] puzzle, List<String> words) {
+    public static boolean solveCrossword(char[][] puzzle, Collection<String> words) {
         // Create a mutable copy of the words list
         List<String> remainingWords = new ArrayList<>(words);
 

src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java

@@ -1,56 +1,80 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * This class provides methods to convert between BCD (Binary-Coded Decimal) and binary.
+ * This class provides methods to convert between BCD (Binary-Coded Decimal) and decimal numbers.
  *
- * Binary-Coded Decimal (BCD) is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of binary digits, usually four or eight.
+ * BCD is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of binary digits, usually four or eight.
  *
  * For more information, refer to the
  * <a href="https://en.wikipedia.org/wiki/Binary-coded_decimal">Binary-Coded Decimal</a> Wikipedia page.
  *
  * <b>Example usage:</b>
  * <pre>
- * int binary = BcdConversion.bcdToBinary(0x1234);
- * System.out.println("BCD 0x1234 to binary: " + binary); // Output: 1234
+ * int decimal = BcdConversion.bcdToDecimal(0x1234);
+ * System.out.println("BCD 0x1234 to decimal: " + decimal); // Output: 1234
  *
- * int bcd = BcdConversion.binaryToBcd(1234);
- * System.out.println("Binary 1234 to BCD: " + Integer.toHexString(bcd)); // Output: 0x1234
+ * int bcd = BcdConversion.decimalToBcd(1234);
+ * System.out.println("Decimal 1234 to BCD: " + Integer.toHexString(bcd)); // Output: 0x1234
  * </pre>
  */
 public final class BcdConversion {
     private BcdConversion() {
     }
+
     /**
-     * Converts a BCD (Binary-Coded Decimal) number to binary.
+     * Converts a BCD (Binary-Coded Decimal) number to a decimal number.
+     * <p>Steps:
+     * <p>1. Validate the BCD number to ensure all digits are between 0 and 9.
+     * <p>2. Extract the last 4 bits (one BCD digit) from the BCD number.
+     * <p>3. Multiply the extracted digit by the corresponding power of 10 and add it to the decimal number.
+     * <p>4. Shift the BCD number right by 4 bits to process the next BCD digit.
+     * <p>5. Repeat steps 1-4 until the BCD number is zero.
      *
      * @param bcd The BCD number.
-     * @return The corresponding binary number.
+     * @return The corresponding decimal number.
+     * @throws IllegalArgumentException if the BCD number contains invalid digits.
      */
-    public static int bcdToBinary(int bcd) {
-        int binary = 0;
+    public static int bcdToDecimal(int bcd) {
+        int decimal = 0;
         int multiplier = 1;
+
+        // Validate BCD digits
         while (bcd > 0) {
-            int digit = bcd & 0xF; // Extract the last 4 bits (one BCD digit)
-            binary += digit * multiplier;
+            int digit = bcd & 0xF;
+            if (digit > 9) {
+                throw new IllegalArgumentException("Invalid BCD digit: " + digit);
+            }
+            decimal += digit * multiplier;
             multiplier *= 10;
-            bcd >>= 4; // Shift right by 4 bits to process the next BCD digit
+            bcd >>= 4;
         }
-        return binary;
+        return decimal;
     }
 
     /**
-     * Converts a binary number to BCD (Binary-Coded Decimal).
+     * Converts a decimal number to BCD (Binary-Coded Decimal).
+     * <p>Steps:
+     * <p>1. Check if the decimal number is within the valid range for BCD (0 to 9999).
+     * <p>2. Extract the last decimal digit from the decimal number.
+     * <p>3. Shift the digit to the correct BCD position and add it to the BCD number.
+     * <p>4. Remove the last decimal digit from the decimal number.
+     * <p>5. Repeat steps 2-4 until the decimal number is zero.
      *
-     * @param binary The binary number.
+     * @param decimal The decimal number.
      * @return The corresponding BCD number.
+     * @throws IllegalArgumentException if the decimal number is greater than 9999.
      */
-    public static int binaryToBcd(int binary) {
+    public static int decimalToBcd(int decimal) {
+        if (decimal < 0 || decimal > 9999) {
+            throw new IllegalArgumentException("Value out of bounds for BCD representation: " + decimal);
+        }
+
         int bcd = 0;
         int shift = 0;
-        while (binary > 0) {
-            int digit = binary % 10; // Extract the last decimal digit
-            bcd |= (digit << (shift * 4)); // Shift the digit to the correct BCD position
-            binary /= 10; // Remove the last decimal digit
+        while (decimal > 0) {
+            int digit = decimal % 10;
+            bcd |= (digit << (shift * 4));
+            decimal /= 10;
             shift++;
         }
         return bcd;

src/main/java/com/thealgorithms/bitmanipulation/BcdConversion.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/bitmanipulation/Xs3Conversion.java

@@ -0,0 +1,23 @@
+package com.thealgorithms.conversions;
+
+/**
+ * Converts between big-endian and little-endian formats.
+ * Big-endian is the most significant byte first, while little-endian is the least significant byte first.
+ * Big-endian to little-endian: 0x12345678 -> 0x78563412
+ *
+ * Little-endian to big-endian: 0x12345678 -> 0x78563412
+ *
+ * @author Hardvan
+ */
+public final class EndianConverter {
+    private EndianConverter() {
+    }
+
+    public static int bigToLittleEndian(int value) {
+        return Integer.reverseBytes(value);
+    }
+
+    public static int littleToBigEndian(int value) {
+        return Integer.reverseBytes(value);
+    }
+}

src/main/java/com/thealgorithms/conversions/EndianConverter.java

@@ -0,0 +1,58 @@
+package com.thealgorithms.conversions;
+
+/**
+ * Converts an IPv4 address to its binary equivalent and vice-versa.
+ * IP to Binary: Converts an IPv4 address to its binary equivalent.
+ * Example: 127.3.4.5 -> 01111111.00000011.00000100.00000101
+ *
+ * Binary to IP: Converts a binary equivalent to an IPv4 address.
+ * Example: 01111111.00000011.00000100.00000101 -> 127.3.4.5
+ *
+ * @author Hardvan
+ */
+public final class IPConverter {
+    private IPConverter() {
+    }
+
+    /**
+     * Converts an IPv4 address to its binary equivalent.
+     * @param ip The IPv4 address to convert.
+     * @return The binary equivalent of the IPv4 address.
+     */
+    public static String ipToBinary(String ip) {
+        StringBuilder binary = new StringBuilder();
+        for (String octet : ip.split("\\.")) {
+            binary.append(octetToBinary(Integer.parseInt(octet))).append(".");
+        }
+        return binary.substring(0, binary.length() - 1);
+    }
+
+    /**
+     * Converts a single octet to its 8-bit binary representation.
+     * @param octet The octet to convert (0-255).
+     * @return The 8-bit binary representation as a String.
+     */
+    private static String octetToBinary(int octet) {
+        char[] binary = {'0', '0', '0', '0', '0', '0', '0', '0'};
+        for (int i = 7; i >= 0; i--) {
+            if ((octet & 1) == 1) {
+                binary[i] = '1';
+            }
+            octet >>>= 1;
+        }
+        return new String(binary);
+    }
+
+    /**
+     * Converts a binary equivalent to an IPv4 address.
+     * @param binary The binary equivalent to convert.
+     * @return The IPv4 address of the binary equivalent.
+     */
+    public static String binaryToIP(String binary) {
+        StringBuilder ip = new StringBuilder();
+        for (String octet : binary.split("\\.")) {
+            ip.append(Integer.parseInt(octet, 2)).append(".");
+        }
+        return ip.substring(0, ip.length() - 1);
+    }
+}

src/main/java/com/thealgorithms/conversions/IPConverter.java

@@ -0,0 +1,98 @@
+package com.thealgorithms.conversions;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Converts text to Morse code and vice-versa.
+ * Text to Morse code: Each letter is separated by a space and each word is separated by a pipe (|).
+ * Example: "HELLO WORLD" -> ".... . .-.. .-.. --- | .-- --- .-. .-.. -.."
+ *
+ * Morse code to text: Each letter is separated by a space and each word is separated by a pipe (|).
+ * Example: ".... . .-.. .-.. --- | .-- --- .-. .-.. -.." -> "HELLO WORLD"
+ *
+ * Applications: Used in radio communications and algorithmic challenges.
+ *
+ * @author Hardvan
+ */
+public final class MorseCodeConverter {
+    private MorseCodeConverter() {
+    }
+
+    private static final Map<Character, String> MORSE_MAP = new HashMap<>();
+    private static final Map<String, Character> REVERSE_MAP = new HashMap<>();
+
+    static {
+        MORSE_MAP.put('A', ".-");
+        MORSE_MAP.put('B', "-...");
+        MORSE_MAP.put('C', "-.-.");
+        MORSE_MAP.put('D', "-..");
+        MORSE_MAP.put('E', ".");
+        MORSE_MAP.put('F', "..-.");
+        MORSE_MAP.put('G', "--.");
+        MORSE_MAP.put('H', "....");
+        MORSE_MAP.put('I', "..");
+        MORSE_MAP.put('J', ".---");
+        MORSE_MAP.put('K', "-.-");
+        MORSE_MAP.put('L', ".-..");
+        MORSE_MAP.put('M', "--");
+        MORSE_MAP.put('N', "-.");
+        MORSE_MAP.put('O', "---");
+        MORSE_MAP.put('P', ".--.");
+        MORSE_MAP.put('Q', "--.-");
+        MORSE_MAP.put('R', ".-.");
+        MORSE_MAP.put('S', "...");
+        MORSE_MAP.put('T', "-");
+        MORSE_MAP.put('U', "..-");
+        MORSE_MAP.put('V', "...-");
+        MORSE_MAP.put('W', ".--");
+        MORSE_MAP.put('X', "-..-");
+        MORSE_MAP.put('Y', "-.--");
+        MORSE_MAP.put('Z', "--..");
+
+        // Build reverse map for decoding
+        MORSE_MAP.forEach((k, v) -> REVERSE_MAP.put(v, k));
+    }
+
+    /**
+     * Converts text to Morse code.
+     * Each letter is separated by a space and each word is separated by a pipe (|).
+     *
+     * @param text The text to convert to Morse code.
+     * @return The Morse code representation of the text.
+     */
+    public static String textToMorse(String text) {
+        StringBuilder morse = new StringBuilder();
+        String[] words = text.toUpperCase().split(" ");
+        for (int i = 0; i < words.length; i++) {
+            for (char c : words[i].toCharArray()) {
+                morse.append(MORSE_MAP.getOrDefault(c, "")).append(" ");
+            }
+            if (i < words.length - 1) {
+                morse.append("| ");
+            }
+        }
+        return morse.toString().trim();
+    }
+
+    /**
+     * Converts Morse code to text.
+     * Each letter is separated by a space and each word is separated by a pipe (|).
+     *
+     * @param morse The Morse code to convert to text.
+     * @return The text representation of the Morse code.
+     */
+    public static String morseToText(String morse) {
+        StringBuilder text = new StringBuilder();
+        String[] words = morse.split(" \\| ");
+        for (int i = 0; i < words.length; i++) {
+            for (String code : words[i].split(" ")) {
+                text.append(REVERSE_MAP.getOrDefault(code, '?'));
+            }
+            if (i < words.length - 1) {
+                text.append(" ");
+            }
+        }
+        return text.toString();
+    }
+}