Merge branch 'master' into int_to_rom_improve

Author: siriak

DIRECTORY.md

@@ -20,7 +20,7 @@
             <dependency>
                 <groupId>org.junit</groupId>
                 <artifactId>junit-bom</artifactId>
-                <version>5.11.2</version>
+                <version>5.11.3</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -31,7 +31,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
-            <version>5.11.2</version>
+            <version>5.11.3</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -51,7 +51,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
-            <version>5.11.2</version>
+            <version>5.11.3</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -132,7 +132,7 @@
             <plugin>
                 <groupId>com.github.spotbugs</groupId>
                 <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.8.6.4</version>
+                <version>4.8.6.5</version>
                 <configuration>
                     <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                     <includeTests>true</includeTests>

pom.xml

@@ -0,0 +1,71 @@
+package com.thealgorithms.ciphers;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * The Baconian Cipher is a substitution cipher where each letter is represented
+ * by a group of five binary digits (A's and B's). It can also be used to hide
+ * messages within other texts, making it a simple form of steganography.
+ * https://en.wikipedia.org/wiki/Bacon%27s_cipher
+ *
+ * @author Bennybebo
+ */
+public class BaconianCipher {
+
+    private static final Map<Character, String> BACONIAN_MAP = new HashMap<>();
+    private static final Map<String, Character> REVERSE_BACONIAN_MAP = new HashMap<>();
+
+    static {
+        // Initialize the Baconian cipher mappings
+        String[] baconianAlphabet = {"AAAAA", "AAAAB", "AAABA", "AAABB", "AABAA", "AABAB", "AABBA", "AABBB", "ABAAA", "ABAAB", "ABABA", "ABABB", "ABBAA", "ABBAB", "ABBBA", "ABBBB", "BAAAA", "BAAAB", "BAABA", "BAABB", "BABAA", "BABAB", "BABBA", "BABBB", "BBAAA", "BBAAB"};
+        char letter = 'A';
+        for (String code : baconianAlphabet) {
+            BACONIAN_MAP.put(letter, code);
+            REVERSE_BACONIAN_MAP.put(code, letter);
+            letter++;
+        }
+
+        // Handle I/J as the same letter
+        BACONIAN_MAP.put('I', BACONIAN_MAP.get('J'));
+        REVERSE_BACONIAN_MAP.put(BACONIAN_MAP.get('I'), 'I');
+    }
+
+    /**
+     * Encrypts the given plaintext using the Baconian cipher.
+     *
+     * @param plaintext The plaintext message to encrypt.
+     * @return The ciphertext as a binary (A/B) sequence.
+     */
+    public String encrypt(String plaintext) {
+        StringBuilder ciphertext = new StringBuilder();
+        plaintext = plaintext.toUpperCase().replaceAll("[^A-Z]", ""); // Remove non-letter characters
+
+        for (char letter : plaintext.toCharArray()) {
+            ciphertext.append(BACONIAN_MAP.get(letter));
+        }
+
+        return ciphertext.toString();
+    }
+
+    /**
+     * Decrypts the given ciphertext encoded in binary (A/B) format using the Baconian cipher.
+     *
+     * @param ciphertext The ciphertext to decrypt.
+     * @return The decrypted plaintext message.
+     */
+    public String decrypt(String ciphertext) {
+        StringBuilder plaintext = new StringBuilder();
+
+        for (int i = 0; i < ciphertext.length(); i += 5) {
+            String code = ciphertext.substring(i, i + 5);
+            if (REVERSE_BACONIAN_MAP.containsKey(code)) {
+                plaintext.append(REVERSE_BACONIAN_MAP.get(code));
+            } else {
+                throw new IllegalArgumentException("Invalid Baconian code: " + code);
+            }
+        }
+
+        return plaintext.toString();
+    }
+}

src/main/java/com/thealgorithms/ciphers/BaconianCipher.java

@@ -0,0 +1,36 @@
+package com.thealgorithms.ciphers;
+
+import java.math.BigInteger;
+
+public final class DiffieHellman {
+
+    private final BigInteger base;
+    private final BigInteger secret;
+    private final BigInteger prime;
+
+    // Constructor to initialize base, secret, and prime
+    public DiffieHellman(BigInteger base, BigInteger secret, BigInteger prime) {
+        // Check for non-null and positive values
+        if (base == null || secret == null || prime == null || base.signum() <= 0 || secret.signum() <= 0 || prime.signum() <= 0) {
+            throw new IllegalArgumentException("Base, secret, and prime must be non-null and positive values.");
+        }
+        this.base = base;
+        this.secret = secret;
+        this.prime = prime;
+    }
+
+    // Method to calculate public value (g^x mod p)
+    public BigInteger calculatePublicValue() {
+        // Returns g^x mod p
+        return base.modPow(secret, prime);
+    }
+
+    // Method to calculate the shared secret key (otherPublic^secret mod p)
+    public BigInteger calculateSharedSecret(BigInteger otherPublicValue) {
+        if (otherPublicValue == null || otherPublicValue.signum() <= 0) {
+            throw new IllegalArgumentException("Other public value must be non-null and positive.");
+        }
+        // Returns b^x mod p or a^y mod p
+        return otherPublicValue.modPow(secret, prime);
+    }
+}

src/main/java/com/thealgorithms/ciphers/DiffieHellman.java

@@ -0,0 +1,48 @@
+package com.thealgorithms.ciphers;
+
+public final class MonoAlphabetic {
+
+    private MonoAlphabetic() {
+        throw new UnsupportedOperationException("Utility class");
+    }
+
+    // Encryption method
+    public static String encrypt(String data, String key) {
+        if (!data.matches("[A-Z]+")) {
+            throw new IllegalArgumentException("Input data contains invalid characters. Only uppercase A-Z are allowed.");
+        }
+        StringBuilder sb = new StringBuilder();
+
+        // Encrypt each character
+        for (char c : data.toCharArray()) {
+            int idx = charToPos(c); // Get the index of the character
+            sb.append(key.charAt(idx)); // Map to the corresponding character in the key
+        }
+        return sb.toString();
+    }
+
+    // Decryption method
+    public static String decrypt(String data, String key) {
+        StringBuilder sb = new StringBuilder();
+
+        // Decrypt each character
+        for (char c : data.toCharArray()) {
+            int idx = key.indexOf(c); // Find the index of the character in the key
+            if (idx == -1) {
+                throw new IllegalArgumentException("Input data contains invalid characters.");
+            }
+            sb.append(posToChar(idx)); // Convert the index back to the original character
+        }
+        return sb.toString();
+    }
+
+    // Helper method: Convert a character to its position in the alphabet
+    private static int charToPos(char c) {
+        return c - 'A'; // Subtract 'A' to get position (0 for A, 1 for B, etc.)
+    }
+
+    // Helper method: Convert a position in the alphabet to a character
+    private static char posToChar(int pos) {
+        return (char) (pos + 'A'); // Add 'A' to convert position back to character
+    }
+}

src/main/java/com/thealgorithms/ciphers/MonoAlphabetic.java

@@ -2,7 +2,28 @@
 
 import java.util.Map;
 
+/**
+ * A utility class to convert integers to their English word representation.
+ *
+ * <p>The class supports conversion of numbers from 0 to 2,147,483,647
+ * (the maximum value of a 32-bit signed integer). It divides the number
+ * into groups of three digits (thousands, millions, billions, etc.) and
+ * translates each group into words.</p>
+ *
+ * <h2>Example Usage</h2>
+ * <pre>
+ *   IntegerToEnglish.integerToEnglishWords(12345);
+ *   // Output: "Twelve Thousand Three Hundred Forty Five"
+ * </pre>
+ *
+ * <p>This class uses two maps:</p>
+ * <ul>
+ *   <li>BASE_NUMBERS_MAP: Holds English words for numbers 0-20, multiples of 10 up to 90, and 100.</li>
+ *   <li>THOUSAND_POWER_MAP: Maps powers of 1000 (e.g., Thousand, Million, Billion).</li>
+ * </ul>
+ */
 public final class IntegerToEnglish {
+
     private static final Map<Integer, String> BASE_NUMBERS_MAP = Map.ofEntries(Map.entry(0, ""), Map.entry(1, "One"), Map.entry(2, "Two"), Map.entry(3, "Three"), Map.entry(4, "Four"), Map.entry(5, "Five"), Map.entry(6, "Six"), Map.entry(7, "Seven"), Map.entry(8, "Eight"), Map.entry(9, "Nine"),
         Map.entry(10, "Ten"), Map.entry(11, "Eleven"), Map.entry(12, "Twelve"), Map.entry(13, "Thirteen"), Map.entry(14, "Fourteen"), Map.entry(15, "Fifteen"), Map.entry(16, "Sixteen"), Map.entry(17, "Seventeen"), Map.entry(18, "Eighteen"), Map.entry(19, "Nineteen"), Map.entry(20, "Twenty"),
         Map.entry(30, "Thirty"), Map.entry(40, "Forty"), Map.entry(50, "Fifty"), Map.entry(60, "Sixty"), Map.entry(70, "Seventy"), Map.entry(80, "Eighty"), Map.entry(90, "Ninety"), Map.entry(100, "Hundred"));
@@ -13,43 +34,53 @@ private IntegerToEnglish() {
     }
 
     /**
-        converts numbers < 1000 to english words
+     * Converts numbers less than 1000 into English words.
+     *
+     * @param number the integer value (0-999) to convert
+     * @return the English word representation of the input number
      */
     private static String convertToWords(int number) {
         int remainder = number % 100;
-
-        String result;
+        StringBuilder result = new StringBuilder();
 
         if (remainder <= 20) {
-            result = BASE_NUMBERS_MAP.get(remainder);
+            result.append(BASE_NUMBERS_MAP.get(remainder));
         } else if (BASE_NUMBERS_MAP.containsKey(remainder)) {
-            result = BASE_NUMBERS_MAP.get(remainder);
+            result.append(BASE_NUMBERS_MAP.get(remainder));
         } else {
             int tensDigit = remainder / 10;
             int onesDigit = remainder % 10;
-
-            result = String.format("%s %s", BASE_NUMBERS_MAP.get(tensDigit * 10), BASE_NUMBERS_MAP.get(onesDigit));
+            String tens = BASE_NUMBERS_MAP.getOrDefault(tensDigit * 10, "");
+            String ones = BASE_NUMBERS_MAP.getOrDefault(onesDigit, "");
+            result.append(tens);
+            if (ones != null && !ones.isEmpty()) {
+                result.append(" ").append(ones);
+            }
         }
 
         int hundredsDigit = number / 100;
-
         if (hundredsDigit > 0) {
-            result = String.format("%s %s%s", BASE_NUMBERS_MAP.get(hundredsDigit), BASE_NUMBERS_MAP.get(100), result.isEmpty() ? "" : " " + result);
+            if (result.length() > 0) {
+                result.insert(0, " ");
+            }
+            result.insert(0, String.format("%s Hundred", BASE_NUMBERS_MAP.get(hundredsDigit)));
         }
 
-        return result;
+        return result.toString().trim();
     }
 
     /**
-      Only convert groups of three digit if they are non-zero
+     * Converts a non-negative integer to its English word representation.
+     *
+     * @param number the integer to convert (0-2,147,483,647)
+     * @return the English word representation of the input number
      */
     public static String integerToEnglishWords(int number) {
         if (number == 0) {
             return "Zero";
         }
 
         StringBuilder result = new StringBuilder();
-
         int index = 0;
 
         while (number > 0) {
@@ -58,23 +89,20 @@ public static String integerToEnglishWords(int number) {
 
             if (remainder > 0) {
                 String subResult = convertToWords(remainder);
-
                 if (!subResult.isEmpty()) {
-                    if (!result.isEmpty()) {
-                        result.insert(0, subResult + " " + THOUSAND_POWER_MAP.get(index) + " ");
-                    } else {
-                        if (index > 0) {
-                            result = new StringBuilder(subResult + " " + THOUSAND_POWER_MAP.get(index));
-                        } else {
-                            result = new StringBuilder(subResult);
-                        }
+                    if (index > 0) {
+                        subResult += " " + THOUSAND_POWER_MAP.get(index);
+                    }
+                    if (result.length() > 0) {
+                        result.insert(0, " ");
                     }
+                    result.insert(0, subResult);
                 }
             }
 
             index++;
         }
 
-        return result.toString();
+        return result.toString().trim();
     }
 }

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

@@ -1,14 +1,40 @@
 package com.thealgorithms.conversions;
 
 /**
- * Converts any Octal Number to a Binary Number
+ * A utility class to convert an octal (base-8) number into its binary (base-2) representation.
+ *
+ * <p>This class provides methods to:
+ * <ul>
+ *     <li>Convert an octal number to its binary equivalent</li>
+ *     <li>Convert individual octal digits to binary</li>
+ * </ul>
+ *
+ * <h2>Octal to Binary Conversion:</h2>
+ * <p>An octal number is converted to binary by converting each octal digit to its 3-bit binary equivalent.
+ * The result is a long representing the full binary equivalent of the octal number.</p>
+ *
+ * <h2>Example Usage</h2>
+ * <pre>
+ *   long binary = OctalToBinary.convertOctalToBinary(52); // Output: 101010 (52 in octal is 101010 in binary)
+ * </pre>
  *
  * @author Bama Charan Chhandogi
+ * @see <a href="https://en.wikipedia.org/wiki/Octal">Octal Number System</a>
+ * @see <a href="https://en.wikipedia.org/wiki/Binary_number">Binary Number System</a>
  */
-
 public final class OctalToBinary {
     private OctalToBinary() {
     }
+
+    /**
+     * Converts an octal number to its binary representation.
+     *
+     * <p>Each octal digit is individually converted to its 3-bit binary equivalent, and the binary
+     * digits are concatenated to form the final binary number.</p>
+     *
+     * @param octalNumber the octal number to convert (non-negative integer)
+     * @return the binary equivalent as a long
+     */
     public static long convertOctalToBinary(int octalNumber) {
         long binaryNumber = 0;
         int digitPosition = 1;
@@ -20,12 +46,25 @@ public static long convertOctalToBinary(int octalNumber) {
             binaryNumber += binaryDigit * digitPosition;
 
             octalNumber /= 10;
-            digitPosition *= 1000; // Move to the next group of 3 binary digits
+            digitPosition *= 1000;
         }
 
         return binaryNumber;
     }
 
+    /**
+     * Converts a single octal digit (0-7) to its binary equivalent.
+     *
+     * <p>For example:
+     * <ul>
+     *     <li>Octal digit 7 is converted to binary 111</li>
+     *     <li>Octal digit 3 is converted to binary 011</li>
+     * </ul>
+     * </p>
+     *
+     * @param octalDigit a single octal digit (0-7)
+     * @return the binary equivalent as a long
+     */
     public static long convertOctalDigitToBinary(int octalDigit) {
         long binaryDigit = 0;
         int binaryMultiplier = 1;