feat: refactored docs structure

docs/(01-linear-structures)/prefix-sum/(problems)/238_product-of-array-except-self.mdx

@@ -0,0 +1,68 @@
+---
+title: '238. Product of Array Except Self'
+description: Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i]
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Prefix Sum", slug: "prefix-sum" }
+video: "bNvIQI2wAjk"
+issue: "https://github.com/prdlk/leetcode/issues/37"
+sidebar:
+  label: 'Product of Array Except Self'
+  badge: 'Medium'
+---
+
+::::warning
+You must write an algorithm that runs in O(n) time and without using the division operation.
+Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)
+::::
+
+### Example 1:
+- Input: `nums = [1,2,3,4]`
+- Output: `[24,12,8,6]`
+
+### Example 2:
+- Input: `nums = [-1,1,0,-3,3]`
+- Output: `[0,0,9,0,0]`
+
+### Constraints:
+
+- `2 <= nums.length <= 10^5`
+- `-30 <= nums[i] <= 30`
+- The input is generated such that `answer[i]` is guaranteed to fit in a 32-bit integer.
+
+## Approach
+
+```mermaid
+flowchart TD
+  S(["productExceptSelf(nums)"]) --> I["answer = ones(n), rightArr = ones(n)"]
+  I --> P1["Pass 1 — left to right: answer[i] = nums[i-1] * answer[i-1]"]
+  P1 --> P2["Pass 2 — right to left: rightArr[i] = nums[i+1] * rightArr[i+1]"]
+  P2 --> P3["Pass 3: answer[i] *= rightArr[i]"]
+  P3 --> E(["return answer — no division needed"])
+```
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function(nums) {
+  const n = nums.length;
+  const answer = new Array(n).fill(1);
+  const rightArr = new Array(n).fill(1);
+
+  for (let i = 1; i < n; i++) {
+    answer[i] = nums[i - 1] * answer[i - 1];
+  }
+  for (let i = n - 2; i >= 0; i--) {
+    rightArr[i] = nums[i + 1] * rightArr[i + 1];
+  }
+  for (let i = 0; i < n; i++) {
+    answer[i] *= rightArr[i];
+  }
+  return answer;
+};
+```

docs/(01-linear-structures)/prefix-sum/(problems)/303_range-sum-query-immutable.mdx

@@ -0,0 +1,72 @@
+---
+title: '303. Range Sum Query - Immutable'
+description: Given an integer array nums, handle multiple queries of the following type
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Design", slug: "design" }
+  - { name: "Prefix Sum", slug: "prefix-sum" }
+video: "2pndAmo_sMA"
+issue: "https://github.com/prdlk/leetcode/issues/36"
+sidebar:
+  label: 'Range Sum Query - Immutable'
+  badge: 'Easy'
+---
+
+### Example 1:
+- Input: `["NumArray", "sumRange", "sumRange", "sumRange"]` `[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]`
+- Output: `[null, 1, -1, -3]`
+- Explanation: `NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);` `numArray.sumRange(0, 2); // return (-2) + 0 + 3 = 1` `numArray.sumRange(2, 5); // return 3 + (-5) + 2 + (-1) = -1` `numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3`
+
+### Constraints:
+
+- `1 <= nums.length <= 10^4`
+- `-10^5 <= nums[i] <= 10^5`
+- `0 <= left <= right < nums.length`
+- At most `10^4` calls will be made to `sumRange`.
+
+## Approach
+
+```mermaid
+flowchart TD
+  subgraph build["constructor(nums) — O(n) once"]
+    A["prefix = [0]"] --> B{"more n in nums?"}
+    B -- yes --> C["prefix.push(last + n)"]
+    C --> B
+  end
+  build --> Q
+  subgraph Q["sumRange(left, right) — O(1) per call"]
+    D(["return prefix[right + 1] - prefix[left]"])
+  end
+```
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ */
+class NumArray {
+    constructor(nums) {
+      this.prefix = [0];
+      for (let n of nums){
+        this.prefix.push(this.prefix[this.prefix.length - 1] + n);
+      }
+    }
+    /**
+     * @param {number} left
+     * @param {number} right
+     * @return {number}
+     */
+    sumRange(left, right) {
+        return this.prefix[right + 1] - this.prefix[left];
+    }
+}
+
+
+/** 
+ * Your NumArray object will be instantiated and called as such:
+ * var obj = new NumArray(nums)
+ * var param_1 = obj.sumRange(left,right)
+ */
+```

docs/(01-linear-structures)/prefix-sum/(problems)/525_contiguous-array.mdx

@@ -0,0 +1,53 @@
+---
+title: '525. Contiguous Array'
+description: Given a binary array nums, return the maximum length of a contiguous subarray with an equal number of 0 and 1
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Prefix Sum", slug: "prefix-sum" }
+issue: "https://github.com/prdlk/leetcode/issues/39"
+sidebar:
+  label: 'Contiguous Array'
+  badge: 'Medium'
+---
+
+### Example 1:
+- Input: `nums = [0,1]`
+- Output: `2`
+- Explanation: [0, 1] is the longest contiguous subarray with an equal number of `0` and `1`.
+
+### Example 2:
+- Input: `nums = [0,1,0]`
+- Output: `2`
+- Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of `0` and `1`.
+
+### Example 3:
+- Input: `nums = [0,1,1,1,1,1,0,0,0]`
+- Output: `6`
+- Explanation: `[1,1,1,0,0,0]` is the longest contiguous subarray with equal number of `0` and `1`.
+
+### Constraints:
+
+- `1 <= nums.length <= 10^5`
+- `nums[i]` is either 0 or 1.
+
+## Solution
+
+```py
+class Solution:
+    def findMaxLength(self, nums: List[int]) -> int:
+        map = {0: -1}
+        count = 0
+        longest = 0
+
+        for i, num in enumerate(nums):
+            count += 1 if num == 1 else -1
+
+            if count in map:
+                longest = max(longest, i - map[count])
+            else:
+                map[count] = i
+
+        return longest
+```

docs/(01-linear-structures)/prefix-sum/(problems)/560_subarray-sum-equals-k.mdx

@@ -0,0 +1,71 @@
+---
+title: '560. Subarray Sum Equals K'
+description: Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Prefix Sum", slug: "prefix-sum" }
+video: "fFVZt-6sgyo"
+issue: "https://github.com/prdlk/leetcode/issues/38"
+sidebar:
+  label: 'Subarray Sum Equals K'
+  badge: 'Medium'
+---
+
+### Example 1:
+- Input: `nums = [1,1,1], k = 2`
+- Output: `2`
+
+### Example 2:
+- Input: `nums = [1,2,3], k = 3`
+- Output: `2`
+
+### Constraints:
+
+- `1 <= nums.length <= 2 * 10^4`
+- `-1000 <= nums[i] <= 1000`
+- `-10^7 <= k <= 10^7`
+
+## Approach
+
+```mermaid
+flowchart TD
+  S(["subarraySum(nums, k)"]) --> I["map = {0: 1} — the empty prefix; sum = 0, count = 0"]
+  I --> L{"more n in nums?"}
+  L -- no --> E(["return count"])
+  L -- yes --> A["sum += n"]
+  A --> Q{"map has sum - k?"}
+  Q -- yes --> C["count += map.get(sum - k) — every earlier prefix that closes a window"]
+  Q -- no --> W["map.set(sum, count of sum + 1)"]
+  C --> W
+  W --> L
+```
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var subarraySum = function(nums, k) {
+  const map = new Map();
+  map.set(0, 1);
+
+  let sum = 0;
+  let count = 0;
+
+  for (let n of nums){
+    sum += n;
+
+    if(map.has(sum - k)){
+      count += map.get(sum - k);
+    }
+
+    map.set(sum, (map.get(sum) || 0) + 1);
+  }
+  return count
+};
+```

docs/(01-linear-structures)/prefix-sum/(problems)/974_subarray-sums-divisible-by-k.mdx

@@ -0,0 +1,49 @@
+---
+title: '974. Subarray Sums Divisible by K'
+description: Given an integer array nums and an integer k, return the number of non-empty subarrays that have a sum divisible by k
+icon: dot
+topics:
+  - { name: "Array", slug: "array" }
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "Prefix Sum", slug: "prefix-sum" }
+issue: "https://github.com/prdlk/leetcode/issues/40"
+sidebar:
+  label: 'Subarray Sums Divisible by K'
+  badge: 'Medium'
+---
+
+### Example 1:
+- Input: `nums = [4,5,0,-2,-3,1], k = 5`
+- Output: `7`
+- Explanation: There are `7` subarrays with a sum divisible by `k = 5`: [4, `5`, `0`, `-2`, `-3`, 1], `[5]`, [5, 0], [5, `0`, `-2`, -3], `[0]`, [0, `-2`, -3], [-2, -3]
+
+### Example 2:
+- Input: `nums = [5], k = 9`
+- Output: `0`
+
+### Constraints:
+
+- `1 <= nums.length <= 3 * 10^4`
+- `-10^4 <= nums[i] <= 10^4`
+- `2 <= k <= 10^4`
+
+## Solution
+
+```py
+class Solution:
+    def subarraysDivByK(self, nums: list[int], k: int) -> int:
+        remainder_counts = {0: 1}
+        cur_sum = 0
+        count = 0
+
+        for n in nums:
+            cur_sum += n
+            remainder = cur_sum % k
+
+            if remainder in remainder_counts:
+                count += remainder_counts[remainder]
+
+            remainder_counts[remainder] = remainder_counts.get(remainder, 0) + 1
+
+        return count
+```