fix: add null input validation to AlternativeStringArrange.arrange()

The arrange() method previously threw a NullPointerException when either
input string was null. This change explicitly validates the inputs and
throws IllegalArgumentException with a clear message, matching the
fail-fast pattern used by other utility classes in this package (e.g.
HammingDistance).

- Add null guard at the start of arrange()
- Update Javadoc with @throws and contract notes
- Add parameterized test covering all three null-input combinations

Author: Shubh2-0

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

@@ -21,12 +21,19 @@ private AlternativeStringArrange() {
 
     /**
      * Arranges two strings by alternating their characters.
+     * If one string is longer than the other, the remaining characters of the longer string
+     * are appended at the end of the result.
      *
-     * @param firstString  the first input string
-     * @param secondString the second input string
+     * @param firstString  the first input string, must not be {@code null}
+     * @param secondString the second input string, must not be {@code null}
      * @return a new string with characters from both strings arranged alternately
+     * @throws IllegalArgumentException if {@code firstString} or {@code secondString} is {@code null}
      */
     public static String arrange(String firstString, String secondString) {
+        if (firstString == null || secondString == null) {
+            throw new IllegalArgumentException("Input strings must not be null");
+        }
+
         StringBuilder result = new StringBuilder();
         int length1 = firstString.length();
         int length2 = secondString.length();

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

@@ -1,9 +1,12 @@
 package com.thealgorithms.strings;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 class AlternativeStringArrangeTest {
@@ -20,4 +23,15 @@ private static Stream<Object[]> provideTestData() {
     void arrangeTest(String input1, String input2, String expected) {
         assertEquals(expected, AlternativeStringArrange.arrange(input1, input2));
     }
+
+    @ParameterizedTest(name = "null input ({0}, {1}) should throw IllegalArgumentException")
+    @MethodSource("provideNullInputs")
+    void arrangeThrowsOnNullInput(String input1, String input2) {
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> AlternativeStringArrange.arrange(input1, input2));
+        assertEquals("Input strings must not be null", ex.getMessage());
+    }
+
+    private static Stream<Arguments> provideNullInputs() {
+        return Stream.of(Arguments.of(null, "abc"), Arguments.of("abc", null), Arguments.of(null, null));
+    }
 }