Merge remote-tracking branch 'origin/rom_to_int_improve' into rom_to_int_improve

Author: Hardvan

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

@@ -22,6 +22,10 @@ public static int cutRod(int[] price, int n) {
         if (price == null || price.length == 0) {
             throw new IllegalArgumentException("Price array cannot be null or empty.");
         }
+        if (n < 0) {
+            throw new IllegalArgumentException("Rod length cannot be negative.");
+        }
+
         // Create an array to store the maximum obtainable values for each rod length.
         int[] val = new int[n + 1];
         val[0] = 0;

src/main/java/com/thealgorithms/dynamicprogramming/RodCutting.java

@@ -0,0 +1,84 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * Finds the strongly connected components in a directed graph.
+ *
+ * @param adjList The adjacency list representation of the graph.
+ * @param n The number of nodes in the graph.
+ * @return The number of strongly connected components.
+ */
+public class StronglyConnectedComponentOptimized {
+
+    public void btrack(HashMap<Integer, List<Integer>> adjList, int[] visited, Stack<Integer> dfsCallsNodes, int currentNode) {
+        visited[currentNode] = 1;
+        List<Integer> neighbors = adjList.get(currentNode);
+        // Check for null before iterating
+        if (neighbors != null) {
+            for (int neighbor : neighbors) {
+                if (visited[neighbor] == -1) {
+                    btrack(adjList, visited, dfsCallsNodes, neighbor);
+                }
+            }
+        }
+        dfsCallsNodes.add(currentNode);
+    }
+
+    public void btrack2(HashMap<Integer, List<Integer>> adjRevList, int[] visited, int currentNode, List<Integer> newScc) {
+        visited[currentNode] = 1;
+        newScc.add(currentNode);
+        List<Integer> neighbors = adjRevList.get(currentNode);
+        // Check for null before iterating
+        if (neighbors != null) {
+            for (int neighbor : neighbors) {
+                if (visited[neighbor] == -1) {
+                    btrack2(adjRevList, visited, neighbor, newScc);
+                }
+            }
+        }
+    }
+
+    public int getOutput(HashMap<Integer, List<Integer>> adjList, int n) {
+        int[] visited = new int[n];
+        Arrays.fill(visited, -1);
+        Stack<Integer> dfsCallsNodes = new Stack<>();
+
+        for (int i = 0; i < n; i++) {
+            if (visited[i] == -1) {
+                btrack(adjList, visited, dfsCallsNodes, i);
+            }
+        }
+
+        HashMap<Integer, List<Integer>> adjRevList = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            adjRevList.put(i, new ArrayList<>());
+        }
+
+        for (int i = 0; i < n; i++) {
+            List<Integer> neighbors = adjList.get(i);
+            // Check for null before iterating
+            if (neighbors != null) {
+                for (int neighbor : neighbors) {
+                    adjRevList.get(neighbor).add(i);
+                }
+            }
+        }
+
+        Arrays.fill(visited, -1);
+        int stronglyConnectedComponents = 0;
+
+        while (!dfsCallsNodes.isEmpty()) {
+            int node = dfsCallsNodes.pop();
+            if (visited[node] == -1) {
+                List<Integer> newScc = new ArrayList<>();
+                btrack2(adjRevList, visited, node, newScc);
+                stronglyConnectedComponents++;
+            }
+        }
+
+        return stronglyConnectedComponents;
+    }
+}

src/main/java/com/thealgorithms/graph/StronglyConnectedComponentOptimized.java

@@ -1,9 +1,23 @@
 package com.thealgorithms.maths;
 
 /**
- * This is Euclid's algorithm, used to find the greatest common
- * denominator Override function name gcd
+ *  This class provides methods to compute the Greatest Common Divisor (GCD) of two or more integers.
  *
+ * The Greatest Common Divisor (GCD) of two or more integers is the largest positive integer that divides each of the integers without leaving a remainder.
+ *
+ * The GCD can be computed using the Euclidean algorithm, which is based on the principle that the GCD of two numbers also divides their difference.
+ *
+ * For more information, refer to the
+ * <a href="https://en.wikipedia.org/wiki/Greatest_common_divisor">Greatest Common Divisor</a> Wikipedia page.
+ *
+ * <b>Example usage:</b>
+ * <pre>
+ * int result1 = GCD.gcd(48, 18);
+ * System.out.println("GCD of 48 and 18: " + result1); // Output: 6
+ *
+ * int result2 = GCD.gcd(48, 18, 30);
+ * System.out.println("GCD of 48, 18, and 30: " + result2); // Output: 6
+ * </pre>
  * @author Oskar Enmalm 3/10/17
  */
 public final class GCD {
@@ -40,20 +54,12 @@ public static int gcd(int num1, int num2) {
      * @param numbers the input array
      * @return gcd of all of the numbers in the input array
      */
-    public static int gcd(int[] numbers) {
+    public static int gcd(int... numbers) {
         int result = 0;
         for (final var number : numbers) {
             result = gcd(result, number);
         }
 
         return result;
     }
-
-    public static void main(String[] args) {
-        int[] myIntArray = {4, 16, 32};
-
-        // call gcd function (input array)
-        System.out.println(gcd(myIntArray)); // => 4
-        System.out.printf("gcd(40,24)=%d gcd(24,40)=%d%n", gcd(40, 24), gcd(24, 40)); // => 8
-    }
 }