chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-12-09-3583-Count-Special-Triplets/explanation.md

@@ -0,0 +1,40 @@
+# Count Special Triplets (Medium)
+
+**Problem ID:** 3583  
+**Date:** 2025-12-09  
+**Link:** https://leetcode.com/problems/count-special-triplets/
+
+## Approach
+
+To solve the problem of counting special triplets in the given integer array `nums`, we can adopt a systematic approach that leverages counting and efficient iteration instead of brute force, which would be computationally expensive.
+
+### Main Idea:
+The essence of the problem lies in identifying triplets `(i, j, k)` such that:
+1. `0 <= i < j < k < n`
+2. `nums[i] == nums[j] * 2`
+3. `nums[k] == nums[j] * 2`
+
+Given that `nums[i]` and `nums[k]` must both equal `2 * nums[j]`, we can simplify our approach by focusing on the middle element `nums[j]` and counting how many valid `i` and `k` indices exist for each `j`.
+
+### Approach:
+1. **Count Occurrences**: Use a frequency array to count occurrences of each possible number in `nums`. This helps in quickly determining how many valid `i` and `k` can be formed for each `j`.
+
+2. **Iterate Through `j`**: For each index `j`, calculate the value `target = 2 * nums[j]`. This value represents the numbers we need to find for both `i` and `k`.
+
+3. **Count Valid Indices**:
+   - **For `i`**: Count how many indices `i` exist before `j` where `nums[i] == target`. This can be done by maintaining a cumulative count of occurrences as we iterate through the array.
+   - **For `k`**: Count how many indices `k` exist after `j` where `nums[k] == target`. This can be achieved by using the frequency array and adjusting counts as we process each `j`.
+
+4. **Calculate Triplets**: For each valid `j`, the number of special triplets can be calculated as the product of the counts of valid `i` and `k`. Sum these products for all valid `j` to get the final result.
+
+5. **Modulo Operation**: Since the result can be large, ensure to take results modulo `10^9 + 7` at each step of accumulation.
+
+### Data Structures:
+- A frequency array (or dictionary) to store counts of each number in `nums`.
+- A cumulative count array to keep track of how many times each number has been seen as we iterate through `j`.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of `nums`. We make a single pass to build the frequency array and then another pass to count triplets.
+- **Space Complexity**: O(m), where m is the range of possible values in `nums` (up to 100,000), which is manageable within the problem constraints.
+
+By following this structured approach, we efficiently count the special triplets without the need for nested loops, making the solution scalable for the upper limits of input size.

Medium/2025-12-09-3583-Count-Special-Triplets/solution.java

@@ -0,0 +1,44 @@
+class Solution {
+    public int countTriplets(int[] nums) {
+        int mod = 1000000007;
+        int n = nums.length;
+        long count = 0;
+        
+        // Count occurrences of each number
+        int[] freq = new int[100001];
+        for (int num : nums) {
+            freq[num]++;
+        }
+        
+        // Iterate through each possible value of nums[j]
+        for (int j = 0; j < n; j++) {
+            int numJ = nums[j];
+            int numI = numJ * 2;
+            int numK = numJ * 2;
+            
+            // If nums[j] * 2 is within bounds
+            if (numI < freq.length) {
+                long countI = 0;
+                long countK = 0;
+                
+                // Count valid i's
+                for (int i = 0; i < j; i++) {
+                    if (nums[i] == numI) {
+                        countI++;
+                    }
+                }
+                
+                // Count valid k's
+                for (int k = j + 1; k < n; k++) {
+                    if (nums[k] == numK) {
+                        countK++;
+                    }
+                }
+                
+                count = (count + (countI * countK) % mod) % mod;
+            }
+        }
+        
+        return (int) count;
+    }
+}

Medium/2025-12-09-3583-Count-Special-Triplets/solution.js

@@ -0,0 +1,32 @@
+var countTriplets = function(nums) {
+    const MOD = 1e9 + 7;
+    const count = new Map();
+    let result = 0;
+
+    for (const num of nums) {
+        count.set(num, (count.get(num) || 0) + 1);
+    }
+
+    for (let j = 0; j < nums.length; j++) {
+        const numJ = nums[j];
+        const numI = numJ * 2;
+        const numK = numJ * 2;
+
+        if (count.has(numI) && count.has(numK)) {
+            let countI = 0;
+            let countK = 0;
+
+            for (let i = 0; i < j; i++) {
+                if (nums[i] === numI) countI++;
+            }
+
+            for (let k = j + 1; k < nums.length; k++) {
+                if (nums[k] === numK) countK++;
+            }
+
+            result = (result + countI * countK) % MOD;
+        }
+    }
+
+    return result;
+};

Medium/2025-12-09-3583-Count-Special-Triplets/solution.py

@@ -0,0 +1,14 @@
+class Solution:
+    def countTriplets(self, nums: List[int]) -> int:
+        count = 0
+        mod = 10**9 + 7
+        n = len(nums)
+        
+        # Count occurrences of each number
+        freq = Counter(nums)
+        
+        for j in range(n):
+            if nums[j] * 2 in freq:
+                count += freq[nums[j] * 2] * (j - sum(1 for i in range(j) if nums[i] == nums[j] * 2))
+        
+        return count % mod

README.md

@@ -299,3 +299,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-06 — [Count Partitions With Max-Min Difference at Most K](https://leetcode.com/problems/count-partitions-with-max-min-difference-at-most-k/) (Medium) → `Medium/2025-12-06-3578-Count-Partitions-With-Max-Min-Difference-at-Most-K`
 - 2025-12-07 — [Count Odd Numbers in an Interval Range](https://leetcode.com/problems/count-odd-numbers-in-an-interval-range/) (Easy) → `Easy/2025-12-07-1523-Count-Odd-Numbers-in-an-Interval-Range`
 - 2025-12-08 — [Count Square Sum Triples](https://leetcode.com/problems/count-square-sum-triples/) (Easy) → `Easy/2025-12-08-1925-Count-Square-Sum-Triples`
+- 2025-12-09 — [Count Special Triplets](https://leetcode.com/problems/count-special-triplets/) (Medium) → `Medium/2025-12-09-3583-Count-Special-Triplets`