chore: clean up content phase organization

2026-11-02 13:12:44 +00:00 · 2026-09-24 15:57:38 -04:00
1 parent 403a2d7f23
commit bf0ac34a43
@@ -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]
+sidebar:
+  label: 'Product of Array Except Self'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Array</Badge>
+
+::::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;
+};
+```
+
+## Explanation
+
+<YouTube id="bNvIQI2wAjk" title="Product of Array Except Self - Leetcode 238 - Python" />
@@ -0,0 +1,71 @@
+---
+title: '303. Range Sum Query - Immutable'
+description: Given an integer array nums, handle multiple queries of the following type
+sidebar:
+  label: 'Range Sum Query - Immutable'
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Array</Badge>
+
+### 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)
+ */
+```
+
+## Explanation
+
+<YouTube id="2pndAmo_sMA" title="Range Sum Query Immutable - Leetcode 303 - Python" />
@@ -0,0 +1,70 @@
+---
+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
+sidebar:
+  label: 'Subarray Sum Equals K'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Array</Badge>
+
+### 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
+};
+```
+
+## Explanation
+
+<YouTube id="fFVZt-6sgyo" title="Subarray Sum Equals K - Prefix Sums - Leetcode 560 - Python" />
@@ -0,0 +1,5 @@
+---
+title: Prefix Sum
+description: 'A running total is stored at each index, so the sum of any range is one subtraction.'
+hidden: true
+---
@@ -0,0 +1,3 @@
+import { defineMeta } from "blume";
+
+export default defineMeta({ title: "Prefix Sum", order: 2, icon: "sigma", display: "group" });