Add RangeSumQuery algorithm in prefix folder (#7280)

* add Subarray Sum Equals K using prefix sum

* Add RangeSumQuery algorithm in prefix folder

* chore: apply clang-format to RangeSumQueryTest file

* Add import statement for JUnit test class

---------

Co-authored-by: Deniz Altunkapan <deniz.altunkapan@outlook.com>

Author: ruturajjadhav07

src/main/java/com/thealgorithms/prefixsum/RangeSumQuery.java

@@ -0,0 +1,73 @@
+package com.thealgorithms.prefixsum;
+
+/**
+ * Implements an algorithm to efficiently compute the sum of elements
+ * between any two indices in an integer array using the Prefix Sum technique.
+ *
+ * <p>
+ * Given an array nums, this algorithm precomputes the prefix sum array
+ * to allow O(1) sum queries for any range [left, right].
+ * </p>
+ *
+ * <p>
+ * Let prefixSum[i] be the sum of elements from index 0 to i-1.
+ * The sum of elements from left to right is:
+ *
+ * <pre>
+ * prefixSum[right + 1] - prefixSum[left]
+ * </pre>
+ * </p>
+ *
+ * <p>
+ * <strong>Time Complexity:</strong> O(N) for preprocessing, O(1) per query<br>
+ * <strong>Space Complexity:</strong> O(N)
+ * </p>
+ *
+ * @author Ruturaj Jadhav, <a href="https://github.com/ruturajjadhav07">ruturajjadhav07</a>
+ */
+public final class RangeSumQuery {
+
+    private RangeSumQuery() {
+        // Utility class; prevent instantiation
+    }
+
+    /**
+     * Computes the prefix sum array for efficient range queries.
+     *
+     * @param nums The input integer array.
+     * @return Prefix sum array where prefixSum[i+1] = sum of nums[0..i].
+     * @throws IllegalArgumentException if nums is null.
+     */
+    public static int[] buildPrefixSum(int[] nums) {
+        if (nums == null) {
+            throw new IllegalArgumentException("Input array cannot be null");
+        }
+
+        int n = nums.length;
+        int[] prefixSum = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            prefixSum[i + 1] = prefixSum[i] + nums[i];
+        }
+        return prefixSum;
+    }
+
+    /**
+     * Returns the sum of elements from index left to right (inclusive)
+     * using the provided prefix sum array.
+     *
+     * @param prefixSum The prefix sum array computed using buildPrefixSum.
+     * @param left      The start index (inclusive).
+     * @param right     The end index (inclusive).
+     * @return The sum of elements in the range [left, right].
+     * @throws IllegalArgumentException if indices are invalid.
+     */
+    public static int sumRange(int[] prefixSum, int left, int right) {
+        if (prefixSum == null) {
+            throw new IllegalArgumentException("Prefix sum array cannot be null");
+        }
+        if (left < 0 || right >= prefixSum.length - 1 || left > right) {
+            throw new IllegalArgumentException("Invalid range indices");
+        }
+        return prefixSum[right + 1] - prefixSum[left];
+    }
+}

src/test/java/com/thealgorithms/prefixsum/RangeSumQueryTest.java

@@ -0,0 +1,73 @@
+package com.thealgorithms.prefixsum;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests for {@link RangeSumQuery}.
+ */
+class RangeSumQueryTest {
+
+    @Test
+    void testBasicExample() {
+        int[] nums = {1, 2, 3, 4, 5};
+        int[] prefixSum = RangeSumQuery.buildPrefixSum(nums);
+
+        assertEquals(6, RangeSumQuery.sumRange(prefixSum, 0, 2)); // 1+2+3
+        assertEquals(9, RangeSumQuery.sumRange(prefixSum, 1, 3)); // 2+3+4
+        assertEquals(15, RangeSumQuery.sumRange(prefixSum, 0, 4)); // 1+2+3+4+5
+        assertEquals(12, RangeSumQuery.sumRange(prefixSum, 2, 4)); // 3+4+5
+    }
+
+    @Test
+    void testSingleElement() {
+        int[] nums = {7};
+        int[] prefixSum = RangeSumQuery.buildPrefixSum(nums);
+
+        assertEquals(7, RangeSumQuery.sumRange(prefixSum, 0, 0));
+    }
+
+    @Test
+    void testAllZeros() {
+        int[] nums = {0, 0, 0, 0};
+        int[] prefixSum = RangeSumQuery.buildPrefixSum(nums);
+
+        assertEquals(0, RangeSumQuery.sumRange(prefixSum, 0, 3));
+        assertEquals(0, RangeSumQuery.sumRange(prefixSum, 1, 2));
+    }
+
+    @Test
+    void testNegativeNumbers() {
+        int[] nums = {-1, 2, -3, 4};
+        int[] prefixSum = RangeSumQuery.buildPrefixSum(nums);
+
+        assertEquals(-2, RangeSumQuery.sumRange(prefixSum, 0, 2)); // -1+2-3
+        assertEquals(3, RangeSumQuery.sumRange(prefixSum, 1, 3)); // 2-3+4
+    }
+
+    @Test
+    void testEmptyArrayThrowsException() {
+        int[] nums = {};
+        int[] prefixSum = RangeSumQuery.buildPrefixSum(nums);
+
+        assertThrows(IllegalArgumentException.class, () -> RangeSumQuery.sumRange(prefixSum, 0, 0));
+    }
+
+    @Test
+    void testNullArrayThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> RangeSumQuery.buildPrefixSum(null));
+        assertThrows(IllegalArgumentException.class, () -> RangeSumQuery.sumRange(null, 0, 0));
+    }
+
+    @Test
+    void testInvalidIndicesThrowsException() {
+        int[] nums = {1, 2, 3};
+        int[] prefixSum = RangeSumQuery.buildPrefixSum(nums);
+
+        assertThrows(IllegalArgumentException.class, () -> RangeSumQuery.sumRange(prefixSum, -1, 2));
+        assertThrows(IllegalArgumentException.class, () -> RangeSumQuery.sumRange(prefixSum, 1, 5));
+        assertThrows(IllegalArgumentException.class, () -> RangeSumQuery.sumRange(prefixSum, 2, 1));
+    }
+}