Merge branch 'master' into vardhan30016-patch-2

Author: vardhan30016

.github/pull_request_template.md

@@ -13,4 +13,5 @@ In order to reduce the number of notifications sent to the maintainers, please:
 - [ ] All filenames are in PascalCase.
 - [ ] All functions and variable names follow Java naming conventions.
 - [ ] All new algorithms have a URL in their comments that points to Wikipedia or other similar explanations.
-- [ ] All new code is formatted with `clang-format -i --style=file path/to/your/file.java`
+- [ ] All new algorithms include a corresponding test class that validates their functionality.
+- [ ] All new code is formatted with `clang-format -i --style=file path/to/your/file.java`

.github/workflows/infer.yml

@@ -33,7 +33,7 @@ jobs:
 
       - name: Cache infer build
         id: cache-infer
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: infer
           key: ${{ runner.os }}-infer-${{ env.year_week }}

.gitpod.dockerfile

@@ -1,4 +1,4 @@
-FROM gitpod/workspace-java-21:2025-10-06-13-14-25
+FROM gitpod/workspace-java-21:2025-11-14-10-05-32
 
 ENV LLVM_SCRIPT="tmp_llvm.sh"
 

DIRECTORY.md

@@ -42,7 +42,7 @@
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>5.20.0</version>
+            <version>5.21.0</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -112,7 +112,7 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>12.1.2</version>
+                    <version>13.0.0</version>
                     </dependency>
                 </dependencies>
             </plugin>
@@ -127,7 +127,7 @@
                         <plugin>
                             <groupId>com.mebigfatguy.fb-contrib</groupId>
                             <artifactId>fb-contrib</artifactId>
-                            <version>7.7.0</version>
+                            <version>7.7.2</version>
                         </plugin>
                         <plugin>
                             <groupId>com.h3xstream.findsecbugs</groupId>

pom.xml

@@ -4,11 +4,36 @@
 import java.util.List;
 
 /**
- * Program description - To find all possible paths from source to destination
- * <a href="https://en.wikipedia.org/wiki/Shortest_path_problem">Wikipedia</a>
+ * Finds all possible simple paths from a given source vertex to a destination vertex
+ * in a directed graph using backtracking.
  *
- * @author <a href="https://github.com/siddhant2002">Siddhant Swarup Mallick</a>
+ * <p>This algorithm performs a Depth First Search (DFS) traversal while keeping track
+ * of visited vertices to avoid cycles. Whenever the destination vertex is reached,
+ * the current path is stored as one valid path.</p>
+ *
+ * <p><b>Key Characteristics:</b></p>
+ * <ul>
+ *   <li>Works on directed graphs</li>
+ *   <li>Does not allow revisiting vertices in the same path</li>
+ *   <li>Stores all possible paths from source to destination</li>
+ * </ul>
+ *
+ * <p><b>Time Complexity:</b></p>
+ * <ul>
+ *   <li>Worst Case: O(V!) — when the graph is fully connected</li>
+ * </ul>
+ *
+ * <p><b>Space Complexity:</b></p>
+ * <ul>
+ *   <li>O(V) for recursion stack and visited array</li>
+ *   <li>Additional space for storing all valid paths</li>
+ * </ul>
+ *
+ * <p>This implementation is intended for educational purposes.</p>
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Depth-first_search">Depth First Search</a>
  */
+
 @SuppressWarnings({"rawtypes", "unchecked"})
 public class AllPathsFromSourceToTarget {
 

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

@@ -0,0 +1,89 @@
+package com.thealgorithms.ciphers;
+
+import java.security.SecureRandom;
+import java.util.Objects;
+
+/**
+ * One-Time Pad (OTP) cipher implementation.
+ *
+ * <p>The One-Time Pad is information-theoretically secure if:
+ * <ul>
+ *   <li>The key is truly random.</li>
+ *   <li>The key length is at least as long as the plaintext.</li>
+ *   <li>The key is used only once and kept secret.</li>
+ * </ul>
+ *
+ * <p>This implementation is for <b>educational purposes only</b> and should not be
+ * used in production systems.
+ */
+public final class OneTimePadCipher {
+
+    private static final SecureRandom RANDOM = new SecureRandom();
+
+    private OneTimePadCipher() {
+        // utility class
+    }
+
+    /**
+     * Generates a random key of the given length in bytes.
+     *
+     * @param length the length of the key in bytes, must be non-negative
+     * @return a new random key
+     * @throws IllegalArgumentException if length is negative
+     */
+    public static byte[] generateKey(int length) {
+        if (length < 0) {
+            throw new IllegalArgumentException("length must be non-negative");
+        }
+        byte[] key = new byte[length];
+        RANDOM.nextBytes(key);
+        return key;
+    }
+
+    /**
+     * Encrypts the given plaintext bytes using the provided key.
+     * <p>The key length must be exactly the same as the plaintext length.
+     *
+     * @param plaintext the plaintext bytes, must not be {@code null}
+     * @param key the one-time pad key bytes, must not be {@code null}
+     * @return the ciphertext bytes
+     * @throws IllegalArgumentException if the key length does not match plaintext length
+     * @throws NullPointerException if plaintext or key is {@code null}
+     */
+    public static byte[] encrypt(byte[] plaintext, byte[] key) {
+        validateInputs(plaintext, key);
+        return xor(plaintext, key);
+    }
+
+    /**
+     * Decrypts the given ciphertext bytes using the provided key.
+     * <p>For a One-Time Pad, decryption is identical to encryption:
+     * {@code plaintext = ciphertext XOR key}.
+     *
+     * @param ciphertext the ciphertext bytes, must not be {@code null}
+     * @param key the one-time pad key bytes, must not be {@code null}
+     * @return the decrypted plaintext bytes
+     * @throws IllegalArgumentException if the key length does not match ciphertext length
+     * @throws NullPointerException if ciphertext or key is {@code null}
+     */
+    public static byte[] decrypt(byte[] ciphertext, byte[] key) {
+        validateInputs(ciphertext, key);
+        return xor(ciphertext, key);
+    }
+
+    private static void validateInputs(byte[] input, byte[] key) {
+        Objects.requireNonNull(input, "input must not be null");
+        Objects.requireNonNull(key, "key must not be null");
+        if (input.length != key.length) {
+            throw new IllegalArgumentException("Key length must match input length");
+        }
+    }
+
+    private static byte[] xor(byte[] data, byte[] key) {
+        byte[] result = new byte[data.length];
+        for (int i = 0; i < data.length; i++) {
+            result[i] = (byte) (data[i] ^ key[i]);
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,115 @@
+package com.thealgorithms.datastructures.hashmap.hashing;
+
+/**
+ * Immutable HashMap implementation using separate chaining.
+ *
+ * <p>This HashMap does not allow modification of existing instances.
+ * Any update operation returns a new ImmutableHashMap.
+ *
+ * @param <K> key type
+ * @param <V> value type
+ */
+public final class ImmutableHashMap<K, V> {
+
+    private static final int DEFAULT_CAPACITY = 16;
+
+    private final Node<K, V>[] table;
+    private final int size;
+
+    /**
+     * Private constructor to enforce immutability.
+     */
+    private ImmutableHashMap(Node<K, V>[] table, int size) {
+        this.table = table;
+        this.size = size;
+    }
+
+    /**
+     * Creates an empty ImmutableHashMap.
+     *
+     * @param <K> key type
+     * @param <V> value type
+     * @return empty ImmutableHashMap
+     */
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static <K, V> ImmutableHashMap<K, V> empty() {
+        Node<K, V>[] table = (Node<K, V>[]) new Node[DEFAULT_CAPACITY];
+        return new ImmutableHashMap<>(table, 0);
+    }
+
+    /**
+     * Returns a new ImmutableHashMap with the given key-value pair added.
+     *
+     * @param key key to add
+     * @param value value to associate
+     * @return new ImmutableHashMap instance
+     */
+    public ImmutableHashMap<K, V> put(K key, V value) {
+        Node<K, V>[] newTable = table.clone();
+        int index = hash(key);
+
+        newTable[index] = new Node<>(key, value, newTable[index]);
+        return new ImmutableHashMap<>(newTable, size + 1);
+    }
+
+    /**
+     * Retrieves the value associated with the given key.
+     *
+     * @param key key to search
+     * @return value if found, otherwise null
+     */
+    public V get(K key) {
+        int index = hash(key);
+        Node<K, V> current = table[index];
+
+        while (current != null) {
+            if ((key == null && current.key == null) || (key != null && key.equals(current.key))) {
+                return current.value;
+            }
+            current = current.next;
+        }
+        return null;
+    }
+
+    /**
+     * Checks whether the given key exists in the map.
+     *
+     * @param key key to check
+     * @return true if key exists, false otherwise
+     */
+    public boolean containsKey(K key) {
+        return get(key) != null;
+    }
+
+    /**
+     * Returns the number of key-value pairs.
+     *
+     * @return size of the map
+     */
+    public int size() {
+        return size;
+    }
+
+    /**
+     * Computes hash index for a given key.
+     */
+    private int hash(K key) {
+        return key == null ? 0 : (key.hashCode() & Integer.MAX_VALUE) % table.length;
+    }
+
+    /**
+     * Node class for separate chaining.
+     */
+    private static final class Node<K, V> {
+
+        private final K key;
+        private final V value;
+        private final Node<K, V> next;
+
+        private Node(K key, V value, Node<K, V> next) {
+            this.key = key;
+            this.value = value;
+            this.next = next;
+        }
+    }
+}

src/main/java/com/thealgorithms/datastructures/hashmap/hashing/ImmutableHashMap.java

@@ -0,0 +1,100 @@
+package com.thealgorithms.datastructures.trees;
+
+/**
+ * Leetcode 606: Construct String from Binary Tree:
+ * https://leetcode.com/problems/construct-string-from-binary-tree/
+ *
+ * Utility class to convert a {@link BinaryTree} into its string representation.
+ * <p>
+ * The conversion follows a preorder traversal pattern (root → left → right)
+ * and uses parentheses to denote the tree structure.
+ * Empty parentheses "()" are used to explicitly represent missing left children
+ * when a right child exists, ensuring the structure is unambiguous.
+ * </p>
+ *
+ * <h2>Rules:</h2>
+ * <ul>
+ * <li>Each node is represented as {@code (value)}.</li>
+ * <li>If a node has only a right child, include {@code ()} before the right
+ * child
+ * to indicate the missing left child.</li>
+ * <li>If a node has no children, it appears as just {@code (value)}.</li>
+ * <li>The outermost parentheses are removed from the final string.</li>
+ * </ul>
+ *
+ * <h3>Example:</h3>
+ *
+ * <pre>
+ *     Input tree:
+ *           1
+ *          / \
+ *         2   3
+ *          \
+ *           4
+ *
+ *     Output string:
+ *     "1(2()(4))(3)"
+ * </pre>
+ *
+ * <p>
+ * This implementation matches the logic from LeetCode problem 606:
+ * <i>Construct String from Binary Tree</i>.
+ * </p>
+ *
+ * @author Muhammad Junaid
+ * @see BinaryTree
+ */
+public class BinaryTreeToString {
+
+    /** String builder used to accumulate the string representation. */
+    private StringBuilder sb;
+
+    /**
+     * Converts a binary tree (given its root node) to its string representation.
+     *
+     * @param root the root node of the binary tree
+     * @return the string representation of the binary tree, or an empty string if
+     *         the tree is null
+     */
+    public String tree2str(BinaryTree.Node root) {
+        if (root == null) {
+            return "";
+        }
+
+        sb = new StringBuilder();
+        dfs(root);
+
+        // Remove the leading and trailing parentheses added by the root call
+        return sb.substring(1, sb.length() - 1);
+    }
+
+    /**
+     * Performs a recursive depth-first traversal to build the string.
+     * Each recursive call appends the node value and its children (if any)
+     * enclosed in parentheses.
+     *
+     * @param node the current node being processed
+     */
+    private void dfs(BinaryTree.Node node) {
+        if (node == null) {
+            return;
+        }
+
+        sb.append("(").append(node.data);
+
+        // Recursively build left and right subtrees
+        if (node.left != null) {
+            dfs(node.left);
+        }
+
+        // Handle the special case: right child exists but left child is null
+        if (node.right != null && node.left == null) {
+            sb.append("()");
+            dfs(node.right);
+        } else if (node.right != null) {
+            dfs(node.right);
+        }
+
+        sb.append(")");
+    }
+}