Merge branch 'master' into fix/mobius-function-integer-overflow

Author: DenizAltunkapan

pom.xml

@@ -112,7 +112,7 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>13.9.0</version>
+                    <version>13.10.0</version>
                     </dependency>
                 </dependencies>
             </plugin>

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

@@ -1,7 +1,5 @@
 package com.thealgorithms.ciphers;
 
-import java.util.Arrays;
-
 /**
  * The rail fence cipher (also called a zigzag cipher) is a classical type of transposition cipher.
  * It derives its name from the manner in which encryption is performed, in analogy to a fence built with horizontal rails.
@@ -14,28 +12,27 @@ public class RailFenceCipher {
     // Encrypts the input string using the rail fence cipher method with the given number of rails.
     public String encrypt(String str, int rails) {
 
+        checkInput(str, rails);
+
         // Base case of single rail or rails are more than the number of characters in the string
         if (rails == 1 || rails >= str.length()) {
             return str;
         }
 
-        // Boolean flag to determine if the movement is downward or upward in the rail matrix.
+        // Boolean flag to determine if the movement is downward or upward in the rail pattern.
         boolean down = true;
-        // Create a 2D array to represent the rails (rows) and the length of the string (columns).
-        char[][] strRail = new char[rails][str.length()];
-
-        // Initialize all positions in the rail matrix with a placeholder character ('\n').
+        // Collect the characters of every rail separately. Using one buffer per rail (instead of a
+        // rails x length matrix with a placeholder character) keeps every character of the input,
+        // including characters that would otherwise be indistinguishable from the placeholder.
+        StringBuilder[] railBuffers = new StringBuilder[rails];
         for (int i = 0; i < rails; i++) {
-            Arrays.fill(strRail[i], '\n');
+            railBuffers[i] = new StringBuilder();
         }
 
-        int row = 0; // Start at the first row
-        int col = 0; // Start at the first column
+        int row = 0; // Start at the first rail
 
-        int i = 0;
-
-        // Fill the rail matrix with characters from the string based on the rail pattern.
-        while (col < str.length()) {
+        // Distribute the characters of the string over the rails following the zigzag pattern.
+        for (int i = 0; i < str.length(); i++) {
             // Change direction to down when at the first row.
             if (row == 0) {
                 down = true;
@@ -45,33 +42,28 @@ else if (row == rails - 1) {
                 down = false;
             }
 
-            // Place the character in the current position of the rail matrix.
-            strRail[row][col] = str.charAt(i);
-            col++; // Move to the next column.
+            // Append the character to the rail it belongs to.
+            railBuffers[row].append(str.charAt(i));
             // Move to the next row based on the direction.
             if (down) {
                 row++;
             } else {
                 row--;
             }
-
-            i++;
         }
 
-        // Construct the encrypted string by reading characters row by row.
-        StringBuilder encryptedString = new StringBuilder();
-        for (char[] chRow : strRail) {
-            for (char ch : chRow) {
-                if (ch != '\n') {
-                    encryptedString.append(ch);
-                }
-            }
+        // Construct the encrypted string by reading the rails top to bottom.
+        StringBuilder encryptedString = new StringBuilder(str.length());
+        for (StringBuilder railBuffer : railBuffers) {
+            encryptedString.append(railBuffer);
         }
         return encryptedString.toString();
     }
     // Decrypts the input string using the rail fence cipher method with the given number of rails.
     public String decrypt(String str, int rails) {
 
+        checkInput(str, rails);
+
         // Base case of single rail or rails are more than the number of characters in the string
         if (rails == 1 || rails >= str.length()) {
             return str;
@@ -144,4 +136,14 @@ else if (row == rails - 1) {
 
         return decryptedString.toString();
     }
+
+    // Rejects inputs the zigzag pattern is not defined for.
+    private static void checkInput(String str, int rails) {
+        if (str == null) {
+            throw new IllegalArgumentException("Input string must not be null");
+        }
+        if (rails <= 0) {
+            throw new IllegalArgumentException("Number of rails must be positive, but was " + rails);
+        }
+    }
 }

src/main/java/com/thealgorithms/datastructures/trees/SegmentTree.java

@@ -8,13 +8,18 @@ public class SegmentTree {
 
     /* Constructor which takes the size of the array and the array as a parameter*/
     public SegmentTree(int n, int[] arr) {
+        if (arr == null) {
+            throw new IllegalArgumentException("Input array must not be null");
+        }
+        if (n <= 0 || n > arr.length) {
+            throw new IllegalArgumentException("Size must be in the range [1, " + arr.length + "], but was " + n);
+        }
         this.n = n;
         int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
         int segSize = 2 * (int) Math.pow(2, x) - 1;
 
         this.segTree = new int[segSize];
         this.arr = arr;
-        this.n = n;
         constructTree(arr, 0, n - 1, 0);
     }
 
@@ -47,7 +52,8 @@ private void updateTree(int start, int end, int index, int diff, int segIndex) {
 
     /* A function to update the value at a particular index*/
     public void update(int index, int value) {
-        if (index < 0 || index > n) {
+        // Valid positions are 0..n-1; index == n is out of bounds and must not reach arr[index].
+        if (index < 0 || index >= n) {
             return;
         }
 
@@ -73,7 +79,8 @@ private int getSumTree(int start, int end, int qStart, int qEnd, int segIndex) {
 
     /* A function to query the sum of the subarray [start...end]*/
     public int getSum(int start, int end) {
-        if (start < 0 || end > n || start > end) {
+        // The last queryable position is n-1, so end == n is an out of range query.
+        if (start < 0 || end >= n || start > end) {
             return 0;
         }
         return getSumTree(0, n - 1, start, end, 0);

src/test/java/com/thealgorithms/ciphers/RailFenceCipherTest.java

@@ -0,0 +1,70 @@
+package com.thealgorithms.ciphers;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class RailFenceCipherTest {
+
+    private final RailFenceCipher railFenceCipher = new RailFenceCipher();
+
+    @Test
+    void testEncrypt() {
+        assertEquals("WECRLTEERDSOEEFEAOCAIVDEN", railFenceCipher.encrypt("WEAREDISCOVEREDFLEEATONCE", 3));
+    }
+
+    @Test
+    void testDecrypt() {
+        assertEquals("WEAREDISCOVEREDFLEEATONCE", railFenceCipher.decrypt("WECRLTEERDSOEEFEAOCAIVDEN", 3));
+    }
+
+    @ParameterizedTest
+    @CsvSource({"HELLOWORLD, 2", "HELLOWORLD, 3", "HELLOWORLD, 4", "ATTACKATDAWN, 5", "abcdefghij, 6"})
+    void testRoundTrip(String message, int rails) {
+        assertEquals(message, railFenceCipher.decrypt(railFenceCipher.encrypt(message, rails), rails));
+    }
+
+    /**
+     * Every character of the input must survive encryption, including the ones that used to collide
+     * with the placeholder that marked unused cells of the rail matrix.
+     */
+    @ParameterizedTest
+    @ValueSource(strings = {"ab\ncdef", "line1\nline2\nline3", "\n\n\n\n\n", "a\nb", "tabs\tand\nnewlines\r\n"})
+    void testControlCharactersArePreserved(String message) {
+        for (int rails = 2; rails <= 5; rails++) {
+            String encrypted = railFenceCipher.encrypt(message, rails);
+            assertEquals(message.length(), encrypted.length(), "characters were dropped with " + rails + " rails");
+            assertEquals(message, railFenceCipher.decrypt(encrypted, rails), "round trip failed with " + rails + " rails");
+        }
+    }
+
+    @Test
+    void testEncryptWithNewlineMatchesReferencePattern() {
+        // Rails of "ab\ncdef" with 3 rails: {a, d} / {b, c, e} / {\n, f}
+        assertEquals("adbce\nf", railFenceCipher.encrypt("ab\ncdef", 3));
+    }
+
+    @ParameterizedTest
+    @CsvSource({"HELLO, 1", "HELLO, 5", "HELLO, 9", "'', 1", "'', 4"})
+    void testDegenerateRailCountsReturnInput(String message, int rails) {
+        assertEquals(message, railFenceCipher.encrypt(message, rails));
+        assertEquals(message, railFenceCipher.decrypt(message, rails));
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -1, -7})
+    void testNonPositiveRailCountThrows(int rails) {
+        assertThrows(IllegalArgumentException.class, () -> railFenceCipher.encrypt("HELLO", rails));
+        assertThrows(IllegalArgumentException.class, () -> railFenceCipher.decrypt("HELLO", rails));
+    }
+
+    @Test
+    void testNullInputThrows() {
+        assertThrows(IllegalArgumentException.class, () -> railFenceCipher.encrypt(null, 3));
+        assertThrows(IllegalArgumentException.class, () -> railFenceCipher.decrypt(null, 3));
+    }
+}

src/test/java/com/thealgorithms/datastructures/trees/SegmentTreeTest.java

@@ -0,0 +1,96 @@
+package com.thealgorithms.datastructures.trees;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class SegmentTreeTest {
+
+    private static SegmentTree treeOf(int... values) {
+        return new SegmentTree(values.length, values);
+    }
+
+    @ParameterizedTest
+    @CsvSource({"0, 4, 15", "0, 0, 1", "4, 4, 5", "1, 3, 9", "2, 4, 12"})
+    void testRangeSums(int start, int end, int expected) {
+        assertEquals(expected, treeOf(1, 2, 3, 4, 5).getSum(start, end));
+    }
+
+    @Test
+    void testSingleElementTree() {
+        SegmentTree tree = treeOf(42);
+        assertEquals(42, tree.getSum(0, 0));
+        tree.update(0, 7);
+        assertEquals(7, tree.getSum(0, 0));
+    }
+
+    @Test
+    void testUpdateIsReflectedInSubsequentQueries() {
+        SegmentTree tree = treeOf(1, 2, 3, 4, 5);
+        tree.update(2, 10);
+        assertEquals(22, tree.getSum(0, 4));
+        assertEquals(16, tree.getSum(1, 3));
+        tree.update(0, -1);
+        assertEquals(20, tree.getSum(0, 4));
+    }
+
+    @Test
+    void testNegativeValues() {
+        SegmentTree tree = treeOf(-5, 3, -2, 8);
+        assertEquals(4, tree.getSum(0, 3));
+        assertEquals(-4, tree.getSum(0, 2));
+    }
+
+    /**
+     * index == n is past the last element, so it must be rejected by the guard instead of reaching
+     * the backing array and throwing {@link ArrayIndexOutOfBoundsException}.
+     */
+    @ParameterizedTest
+    @ValueSource(ints = {5, 6, 100, -1})
+    void testUpdateOutOfRangeIndexIsIgnored(int index) {
+        SegmentTree tree = treeOf(1, 2, 3, 4, 5);
+        assertDoesNotThrow(() -> tree.update(index, 99));
+        assertEquals(15, tree.getSum(0, 4), "out of range update must not modify the tree");
+    }
+
+    @ParameterizedTest
+    @CsvSource({"0, 5", "0, 6", "3, 2", "-1, 3", "5, 5"})
+    void testOutOfRangeQueriesReturnZero(int start, int end) {
+        assertEquals(0, treeOf(1, 2, 3, 4, 5).getSum(start, end));
+    }
+
+    @Test
+    void testConstructorRejectsInvalidSize() {
+        assertThrows(IllegalArgumentException.class, () -> new SegmentTree(0, new int[] {1, 2, 3}));
+        assertThrows(IllegalArgumentException.class, () -> new SegmentTree(-1, new int[] {1, 2, 3}));
+        assertThrows(IllegalArgumentException.class, () -> new SegmentTree(4, new int[] {1, 2, 3}));
+    }
+
+    @Test
+    void testConstructorRejectsNullArray() {
+        assertThrows(IllegalArgumentException.class, () -> new SegmentTree(3, null));
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17})
+    void testMatchesBruteForceForVariousSizes(int size) {
+        int[] values = new int[size];
+        for (int i = 0; i < size; i++) {
+            values[i] = i * 3 - 4;
+        }
+        SegmentTree tree = new SegmentTree(size, values.clone());
+
+        for (int start = 0; start < size; start++) {
+            int expected = 0;
+            for (int end = start; end < size; end++) {
+                expected += values[end];
+                assertEquals(expected, tree.getSum(start, end), "sum of [" + start + ", " + end + "] with size " + size);
+            }
+        }
+    }
+}