Added solutions for Range Sum Query Immutable and Running Sum of 1d Array

Author: adityashirsatrao007

algos/range_queries/PrefixSum/soln/adityashirsatrao007/RangeSumQueryImmutable.cpp

@@ -0,0 +1,52 @@
+/*
+    Problem: Range Sum Query - Immutable (LeetCode 303)
+    Link: https://leetcode.com/problems/range-sum-query-immutable/
+
+    Approach: Prefix Sum Array
+    We can precompute the prefix sums of the array such that:
+    prefix[i] = nums[0] + nums[1] + ... + nums[i]
+
+    Then, the sum of the range [left, right] can be calculated as:
+    sumRange(left, right) = prefix[right] - prefix[left - 1]
+
+    Time Complexity:
+    - Constructor: O(N) to build the prefix sum array.
+    - sumRange: O(1) per query.
+
+    Space Complexity: O(N) to store the prefix sum array.
+*/
+
+#include <vector>
+#include <iostream>
+
+using namespace std;
+
+class NumArray {
+private:
+    vector<int> prefix;
+
+public:
+    NumArray(vector<int>& nums) {
+        int n = nums.size();
+        prefix.resize(n);
+        if (n == 0) return;
+
+        prefix[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            prefix[i] = prefix[i - 1] + nums[i];
+        }
+    }
+
+    int sumRange(int left, int right) {
+        if (left == 0) {
+            return prefix[right];
+        }
+        return prefix[right] - prefix[left - 1];
+    }
+};
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray* obj = new NumArray(nums);
+ * int param_1 = obj->sumRange(left,right);
+ */

algos/range_queries/PrefixSum/soln/adityashirsatrao007/RunningSum1dArray.cpp

@@ -0,0 +1,36 @@
+/*
+    Problem: Running Sum of 1d Array (LeetCode 1480)
+    Link: https://leetcode.com/problems/running-sum-of-1d-array/
+
+    Approach: Prefix Sum (In-place)
+    We can iterate through the array and update each element to be the sum of itself and the previous element.
+    nums[i] += nums[i-1] for i > 0.
+    
+    This creates the running sum array in-place without using extra space (excluding the output vector).
+
+    Time Complexity: O(N) where N is the number of elements.
+    Space Complexity: O(1) if we ignore the output array space, or O(N) if we create a new vector.
+    (This implementation returns a new vector to be clean, but modifies logic similar to in-place)
+*/
+
+#include <vector>
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+public:
+    vector<int> runningSum(vector<int>& nums) {
+        int n = nums.size();
+        if (n == 0) return {};
+
+        vector<int> result(n);
+        result[0] = nums[0];
+
+        for (int i = 1; i < n; i++) {
+            result[i] = result[i - 1] + nums[i];
+        }
+
+        return result;
+    }
+};