Add BSGS algorithm to DIRECTORY.md

Author: rajucreate

DIRECTORY.md

@@ -445,6 +445,7 @@
           - 📄 [ConvolutionFFT](src/main/java/com/thealgorithms/maths/ConvolutionFFT.java)
           - 📄 [CrossCorrelation](src/main/java/com/thealgorithms/maths/CrossCorrelation.java)
           - 📄 [DeterminantOfMatrix](src/main/java/com/thealgorithms/maths/DeterminantOfMatrix.java)
+          - [DiscreteLogarithmBSGS](src/main/java/com/thealgorithms/maths/DiscreteLogarithmBSGS.java)
           - 📄 [DigitalRoot](src/main/java/com/thealgorithms/maths/DigitalRoot.java)
           - 📄 [DistanceFormula](src/main/java/com/thealgorithms/maths/DistanceFormula.java)
           - 📄 [DudeneyNumber](src/main/java/com/thealgorithms/maths/DudeneyNumber.java)

src/main/java/com/thealgorithms/maths/DiscreteLogarithmBSGS.java

@@ -0,0 +1,68 @@
+package com.thealgorithms.maths;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Baby-Step Giant-Step algorithm for the Discrete Logarithm Problem.
+ *
+ * <p>
+ * Solves for x in: a^x ≡ b (mod m),
+ * where a, b, m are given, and m is prime (or a has order in modulo m).
+ *
+ * <p>
+ * Time complexity: O(√m)
+ * Space complexity: O(√m)
+ */
+public class DiscreteLogarithmBSGS {
+
+    /**
+     * Computes x such that (a^x) % m == b.
+     * Returns -1 if no solution exists.
+     */
+    public static long discreteLog(long a, long b, long m) {
+        a %= m;
+        b %= m;
+
+        if (b == 1) {
+            return 0;
+        }
+
+        long n = (long) Math.ceil(Math.sqrt(m));
+
+        Map<Long, Long> babySteps = new HashMap<>();
+
+        long value = 1;
+        for (long i = 0; i < n; i++) {
+            babySteps.put(value, i);
+            value = (value * a) % m;
+        }
+
+        long factor = modPow(a, m - n - 1, m);
+
+        long gamma = b;
+        for (long j = 0; j <= n; j++) {
+            if (babySteps.containsKey(gamma)) {
+                return j * n + babySteps.get(gamma);
+            }
+            gamma = (gamma * factor) % m;
+        }
+
+        return -1; // no solution
+    }
+
+    /** Fast modular exponentiation */
+    public static long modPow(long base, long exp, long mod) {
+        long result = 1;
+        base %= mod;
+
+        while (exp > 0) {
+            if ((exp & 1) == 1) {
+                result = (result * base) % mod;
+            }
+            base = (base * base) % mod;
+            exp >>= 1;
+        }
+        return result;
+    }
+}

src/test/java/com/thealgorithms/maths/DiscreteLogarithmBSGSTest.java

@@ -0,0 +1,25 @@
+package com.thealgorithms.maths;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class DiscreteLogarithmBSGSTest {
+
+    @Test
+    public void testSmallValues() {
+        assertEquals(3, DiscreteLogarithmBSGS.discreteLog(2, 8, 13));
+        assertEquals(4, DiscreteLogarithmBSGS.discreteLog(3, 81, 1000000007));
+    }
+
+    @Test
+    public void testNoSolution() {
+        assertEquals(-1, DiscreteLogarithmBSGS.discreteLog(10, 5, 17));
+    }
+
+    @Test
+    public void testLargeMod() {
+        long x = DiscreteLogarithmBSGS.discreteLog(5, 243, 1000003);
+        assertEquals(5, x);
+    }
+}