fix:add more codes to the string folder

Author: DewminK

src/main/java/com/thealgorithms/strings/ComplexNumberMultiplication.java

@@ -0,0 +1,78 @@
+package com.thealgorithms.strings;
+
+/**
+ * Algorithm to multiply two complex numbers represented as strings.
+ *
+ * A complex number can be represented as a string on the form "real+imaginaryi" where:
+ * - real is the real part and is an integer in the range [-100, 100]
+ * - imaginary is the imaginary part and is an integer in the range [-100, 100]
+ * - i² == -1
+ *
+ * Given two complex numbers num1 and num2 as strings, this returns a string
+ * of the complex number that represents their multiplication.
+ *
+ * Mathematical formula:
+ * (a + bi) * (c + di) = (ac - bd) + (ad + bc)i
+ *
+ * Example:
+ * Input: num1 = "1+1i", num2 = "1+1i"
+ * Output: "0+2i"
+ * Explanation: (1 + i) * (1 + i) = 1 + i + i + i² = 1 + 2i - 1 = 0 + 2i
+ *
+ * @see <a href="https://leetcode.com/problems/complex-number-multiplication/">LeetCode Problem</a>
+ */
+public final class ComplexNumberMultiplication {
+    private ComplexNumberMultiplication() {
+    }
+
+    /**
+     * Multiplies two complex numbers represented as strings.
+     *
+     * @param num1 The first complex number in the format "a+bi"
+     * @param num2 The second complex number in the format "c+di"
+     * @return The product of the two complex numbers in the format "real+imaginaryi"
+     */
+    public static String complexNumberMultiply(String num1, String num2) {
+        if (num1 == null || num2 == null || num1.isEmpty() || num2.isEmpty()) {
+            return "0+0i";
+        }
+
+        // Parse the first complex number
+        int[] complex1 = parseComplexNumber(num1);
+        int a = complex1[0]; // Real part of num1
+        int b = complex1[1]; // Imaginary part of num1
+
+        // Parse the second complex number
+        int[] complex2 = parseComplexNumber(num2);
+        int c = complex2[0]; // Real part of num2
+        int d = complex2[1]; // Imaginary part of num2
+
+        // Calculate the multiplication using the formula: (a + bi) * (c + di) = (ac - bd) + (ad + bc)i
+        int realPart = a * c - b * d;
+        int imaginaryPart = a * d + b * c;
+
+        return realPart + "+" + imaginaryPart + "i";
+    }
+
+    /**
+     * Parses a complex number string into its real and imaginary components.
+     *
+     * @param num The complex number string in the format "a+bi" or "a-bi"
+     * @return An array where index 0 is the real part and index 1 is the imaginary part
+     */
+    private static int[] parseComplexNumber(String num) {
+        // Find the position of '+' or '-' after the first character (to handle negative real parts)
+        int plusIndex = num.indexOf('+', 1);
+        int minusIndex = num.indexOf('-', 1);
+
+        // Determine the separator position
+        int separatorIndex = (plusIndex != -1) ? plusIndex : minusIndex;
+
+        // Extract real and imaginary parts
+        int real = Integer.parseInt(num.substring(0, separatorIndex));
+        // Remove the 'i' at the end and parse the imaginary part
+        int imaginary = Integer.parseInt(num.substring(separatorIndex + 1, num.length() - 1));
+
+        return new int[] {real, imaginary};
+    }
+}

src/main/java/com/thealgorithms/strings/RemovingStarsFromString.java

@@ -0,0 +1,51 @@
+package com.thealgorithms.strings;
+
+/**
+ * Algorithm to remove stars from a string along with the closest non-star character to the left.
+ *
+ * You are given a string s, which contains stars *.
+ * In one operation, you can:
+ * - Choose a star in s.
+ * - Remove the closest non-star character to its left, as well as remove the star itself.
+ *
+ * Example:
+ * Input: s = "leet**cod*e"
+ * Output: "lecoe"
+ * Explanation:
+ * - We remove the first star and the 't' to its left, resulting in "lee*cod*e"
+ * - We remove the second star and the 'e' to its left, resulting in "lecod*e"
+ * - We remove the third star and the 'd' to its left, resulting in "lecoe"
+ *
+ * @see <a href="https://leetcode.com/problems/removing-stars-from-a-string/">LeetCode Problem</a>
+ */
+public final class RemovingStarsFromString {
+    private RemovingStarsFromString() {
+    }
+
+    /**
+     * Removes all stars from the string along with their closest non-star character to the left.
+     *
+     * @param s The input string containing stars
+     * @return The resulting string after all stars have been removed
+     */
+    public static String removeStars(String s) {
+        if (s == null || s.isEmpty()) {
+            return s;
+        }
+
+        StringBuilder result = new StringBuilder();
+
+        for (char c : s.toCharArray()) {
+            if (c == '*') {
+                // Remove the last character (closest non-star character to the left)
+                if (result.length() > 0) {
+                    result.deleteCharAt(result.length() - 1);
+                }
+            } else {
+                result.append(c);
+            }
+        }
+
+        return result.toString();
+    }
+}

src/test/java/com/thealgorithms/strings/ComplexNumberMultiplicationTest.java

@@ -0,0 +1,67 @@
+package com.thealgorithms.strings;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;
+
+class ComplexNumberMultiplicationTest {
+
+    @Test
+    void testBasicMultiplication() {
+        assertEquals("0+2i", ComplexNumberMultiplication.complexNumberMultiply("1+1i", "1+1i"));
+    }
+
+    @Test
+    void testMultiplicationWithZero() {
+        assertEquals("0+0i", ComplexNumberMultiplication.complexNumberMultiply("0+0i", "1+1i"));
+    }
+
+    @Test
+    void testRealNumbersOnly() {
+        assertEquals("6+0i", ComplexNumberMultiplication.complexNumberMultiply("2+0i", "3+0i"));
+    }
+
+    @Test
+    void testImaginaryNumbersOnly() {
+        assertEquals("-6+0i", ComplexNumberMultiplication.complexNumberMultiply("0+2i", "0+3i"));
+    }
+
+    @Test
+    void testNegativeRealPart() {
+        assertEquals("-3+4i", ComplexNumberMultiplication.complexNumberMultiply("1+1i", "-1+3i"));
+    }
+
+    @Test
+    void testNegativeImaginaryPart() {
+        assertEquals("0+-2i", ComplexNumberMultiplication.complexNumberMultiply("1-1i", "1-1i"));
+    }
+
+    @Test
+    void testLargerNumbers() {
+        assertEquals("0+20i", ComplexNumberMultiplication.complexNumberMultiply("2+3i", "4+2i"));
+    }
+
+    @Test
+    void testNegativeResult() {
+        assertEquals("-7+22i", ComplexNumberMultiplication.complexNumberMultiply("3+4i", "1+6i"));
+    }
+
+    @Test
+    void testIdentityMultiplication() {
+        assertEquals("5+3i", ComplexNumberMultiplication.complexNumberMultiply("5+3i", "1+0i"));
+    }
+
+    @Test
+    void testNullInput() {
+        assertEquals("0+0i", ComplexNumberMultiplication.complexNumberMultiply(null, "1+1i"));
+    }
+
+    @Test
+    void testEmptyString() {
+        assertEquals("0+0i", ComplexNumberMultiplication.complexNumberMultiply("", "1+1i"));
+    }
+
+    @Test
+    void testBothNegativeParts() {
+        assertEquals("0+-2i", ComplexNumberMultiplication.complexNumberMultiply("-1+-1i", "1+0i"));
+    }
+}

src/test/java/com/thealgorithms/strings/RemovingStarsFromStringTest.java

@@ -0,0 +1,57 @@
+package com.thealgorithms.strings;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;
+
+class RemovingStarsFromStringTest {
+
+    @Test
+    void testEmptyString() {
+        assertEquals("", RemovingStarsFromString.removeStars(""));
+    }
+
+    @Test
+    void testNullString() {
+        assertEquals(null, RemovingStarsFromString.removeStars(null));
+    }
+
+    @Test
+    void testStringWithNoStars() {
+        assertEquals("leetcode", RemovingStarsFromString.removeStars("leetcode"));
+    }
+
+    @Test
+    void testBasicExample() {
+        assertEquals("lecoe", RemovingStarsFromString.removeStars("leet**cod*e"));
+    }
+
+    @Test
+    void testAllStars() {
+        assertEquals("", RemovingStarsFromString.removeStars("abc***"));
+    }
+
+    @Test
+    void testSingleCharacterWithStar() {
+        assertEquals("", RemovingStarsFromString.removeStars("a*"));
+    }
+
+    @Test
+    void testMultipleConsecutiveStars() {
+        assertEquals("ac", RemovingStarsFromString.removeStars("abc**d*"));
+    }
+
+    @Test
+    void testStarAtEnd() {
+        assertEquals("leet", RemovingStarsFromString.removeStars("leetc*"));
+    }
+
+    @Test
+    void testComplexPattern() {
+        assertEquals("", RemovingStarsFromString.removeStars("a*b*c*"));
+    }
+
+    @Test
+    void testNoRemoval() {
+        assertEquals("hello", RemovingStarsFromString.removeStars("hello"));
+    }
+}