chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-04-08-3653-XOR-After-Range-Multiplication-Queries-I/explanation.md

@@ -0,0 +1,31 @@
+# XOR After Range Multiplication Queries I (Medium)
+
+**Problem ID:** 3653  
+**Date:** 2026-04-08  
+**Link:** https://leetcode.com/problems/xor-after-range-multiplication-queries-i/
+
+## Approach
+
+To solve the problem "XOR After Range Multiplication Queries I," we can follow a systematic approach that efficiently processes the queries and computes the final XOR of the modified array.
+
+### Main Idea:
+The goal is to apply a series of multiplication operations specified in the queries to the elements of the array `nums`, and then compute the XOR of the entire array after all operations have been applied. Given the constraints, a naive approach that directly modifies the array for each query could lead to inefficiencies, particularly when the number of queries and the size of the array are both large.
+
+### Approach:
+1. **Iterate Through Queries**: For each query, which consists of four parameters `[l_i, r_i, k_i, v_i]`, we will:
+   - Start from index `l_i` and apply the multiplication operation to elements at indices `l_i`, `l_i + k_i`, `l_i + 2*k_i`, ..., up to `r_i`.
+   - This means we will update `nums[idx]` to `(nums[idx] * v_i) % (10^9 + 7)` for each valid index in the specified range.
+
+2. **Efficient Indexing**: Instead of updating each element in a nested loop, we can directly compute the indices to be updated using the formula:
+   - `idx = l_i + j * k_i` where `j` is a non-negative integer such that `idx` remains within the bounds of `r_i`.
+
+3. **Final XOR Calculation**: After processing all the queries, we will compute the XOR of all elements in the modified `nums` array. This can be done in a single pass through the array.
+
+### Data Structures:
+- We primarily use an integer array `nums` to store the values and a list (or array) to hold the queries.
+
+### Complexity:
+- **Time Complexity**: The overall time complexity is O(q * (r_i - l_i) / k_i), where `q` is the number of queries. In the worst case, this can approach O(n * q) if every query affects most of the elements in the array. However, since the maximum constraints are relatively small (both `n` and `q` up to 1000), this is manageable.
+- **Space Complexity**: O(1) additional space is used aside from the input arrays, as we are modifying `nums` in place and using a few variables for computations.
+
+By following this approach, we efficiently apply the range multiplication operations and compute the final XOR without unnecessary overhead, ensuring that we stay within acceptable time limits for the given constraints.

Medium/2026-04-08-3653-XOR-After-Range-Multiplication-Queries-I/solution.java

@@ -0,0 +1,18 @@
+class Solution {
+    public int xorAfterQueries(int[] nums, int[][] queries) {
+        int MOD = 1000000007;
+        for (int[] query : queries) {
+            int l = query[0], r = query[1], k = query[2], v = query[3];
+            for (int idx = l; idx <= r; idx += k) {
+                nums[idx] = (int)((long)nums[idx] * v % MOD);
+            }
+        }
+        
+        int result = 0;
+        for (int num : nums) {
+            result ^= num;
+        }
+        
+        return result;
+    }
+}

Medium/2026-04-08-3653-XOR-After-Range-Multiplication-Queries-I/solution.js

@@ -0,0 +1,12 @@
+var xorQueries = function(nums, queries) {
+    const MOD = 1e9 + 7;
+    const n = nums.length;
+
+    for (const [l, r, k, v] of queries) {
+        for (let idx = l; idx <= r; idx += k) {
+            nums[idx] = (nums[idx] * v) % MOD;
+        }
+    }
+
+    return nums.reduce((acc, num) => acc ^ num, 0);
+};

Medium/2026-04-08-3653-XOR-After-Range-Multiplication-Queries-I/solution.py

@@ -0,0 +1,15 @@
+class Solution:
+    def xorQueries(self, nums: List[int], queries: List[List[int]]) -> int:
+        MOD = 10**9 + 7
+        
+        for l, r, k, v in queries:
+            idx = l
+            while idx <= r:
+                nums[idx] = (nums[idx] * v) % MOD
+                idx += k
+        
+        result = 0
+        for num in nums:
+            result ^= num
+        
+        return result

README.md

@@ -417,3 +417,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-04-05 — [Robot Return to Origin](https://leetcode.com/problems/robot-return-to-origin/) (Easy) → `Easy/2026-04-05-657-Robot-Return-to-Origin`
 - 2026-04-06 — [Walking Robot Simulation](https://leetcode.com/problems/walking-robot-simulation/) (Medium) → `Medium/2026-04-06-874-Walking-Robot-Simulation`
 - 2026-04-07 — [Walking Robot Simulation II](https://leetcode.com/problems/walking-robot-simulation-ii/) (Medium) → `Medium/2026-04-07-2069-Walking-Robot-Simulation-II`
+- 2026-04-08 — [XOR After Range Multiplication Queries I](https://leetcode.com/problems/xor-after-range-multiplication-queries-i/) (Medium) → `Medium/2026-04-08-3653-XOR-After-Range-Multiplication-Queries-I`