chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-04-16-3488-Closest-Equal-Element-Queries/explanation.md

@@ -0,0 +1,40 @@
+# Closest Equal Element Queries (Medium)
+
+**Problem ID:** 3488  
+**Date:** 2026-04-16  
+**Link:** https://leetcode.com/problems/closest-equal-element-queries/
+
+## Approach
+
+To solve the problem of finding the minimum distance between a queried index in a circular array and any other index with the same value, we can adopt a systematic approach that leverages efficient data structures and algorithms.
+
+### Main Idea:
+The main idea is to preprocess the input array `nums` to store the indices of each unique value. This allows us to quickly retrieve all positions of a queried value and compute the minimum distance in constant time.
+
+### Steps to Approach:
+
+1. **Index Mapping**:
+   - Create a dictionary (or hashmap) where the keys are the unique values from `nums`, and the values are lists of indices where each unique value occurs. This will help us quickly access all indices for any queried value.
+
+2. **Circular Distance Calculation**:
+   - For each query, retrieve the value at the queried index and check if it exists in the dictionary.
+   - If the value is not present, append `-1` to the results.
+   - If the value exists, compute the distances to all other indices where this value occurs. Since the array is circular, for each index `j`, the distance can be calculated as:
+     - `distance = abs(i - j)` for linear distance, and
+     - `circular_distance = len(nums) - distance` for the wrap-around distance.
+   - The effective distance is the minimum of these two values.
+
+3. **Efficient Calculation**:
+   - Instead of iterating through all indices for each query, use the pre-stored indices to calculate the minimum distance efficiently. This can be done in linear time relative to the number of occurrences of the queried value.
+
+### Data Structures:
+- A dictionary to map values to their indices.
+- An array to store the results for each query.
+
+### Complexity:
+- **Time Complexity**: 
+  - Preprocessing the array `nums` takes O(n), where n is the length of `nums`.
+  - Each query can be processed in O(k), where k is the number of occurrences of the queried value. In the worst case, if all values are the same, this could lead to O(n) for each query, but typically, k will be much smaller.
+- **Space Complexity**: O(n) for storing the indices in the dictionary.
+
+This approach ensures that we efficiently handle multiple queries against the circular array while minimizing redundant calculations, making it suitable for the given constraints.

Medium/2026-04-16-3488-Closest-Equal-Element-Queries/solution.java

@@ -0,0 +1,38 @@
+import java.util.*;
+
+public class Solution {
+    public int[] closestEqualElementQueries(int[] nums, int[] queries) {
+        Map<Integer, List<Integer>> indexMap = new HashMap<>();
+        int n = nums.length;
+        
+        // Populate the index map with positions of each number
+        for (int i = 0; i < n; i++) {
+            indexMap.computeIfAbsent(nums[i], k -> new ArrayList<>()).add(i);
+        }
+        
+        int[] answer = new int[queries.length];
+        
+        for (int i = 0; i < queries.length; i++) {
+            int queryIndex = queries[i];
+            int value = nums[queryIndex];
+            List<Integer> positions = indexMap.get(value);
+            
+            if (positions.size() <= 1) {
+                answer[i] = -1;
+                continue;
+            }
+            
+            int minDistance = Integer.MAX_VALUE;
+            for (int pos : positions) {
+                if (pos != queryIndex) {
+                    int distance = Math.abs(pos - queryIndex);
+                    distance = Math.min(distance, n - distance); // Circular distance
+                    minDistance = Math.min(minDistance, distance);
+                }
+            }
+            answer[i] = minDistance;
+        }
+        
+        return answer;
+    }
+}

Medium/2026-04-16-3488-Closest-Equal-Element-Queries/solution.js

@@ -0,0 +1,33 @@
+var closestEqualElementQueries = function(nums, queries) {
+    const n = nums.length;
+    const indexMap = new Map();
+    const answer = new Array(queries.length).fill(-1);
+    
+    for (let i = 0; i < n; i++) {
+        if (!indexMap.has(nums[i])) {
+            indexMap.set(nums[i], []);
+        }
+        indexMap.get(nums[i]).push(i);
+    }
+    
+    for (let i = 0; i < queries.length; i++) {
+        const queryIndex = queries[i];
+        const value = nums[queryIndex];
+        const indices = indexMap.get(value);
+        
+        if (indices.length <= 1) continue;
+        
+        let minDistance = Infinity;
+        for (const index of indices) {
+            if (index !== queryIndex) {
+                const distance = Math.abs(index - queryIndex);
+                const circularDistance = n - distance;
+                minDistance = Math.min(minDistance, Math.min(distance, circularDistance));
+            }
+        }
+        
+        answer[i] = minDistance === Infinity ? -1 : minDistance;
+    }
+    
+    return answer;
+};

Medium/2026-04-16-3488-Closest-Equal-Element-Queries/solution.py

@@ -0,0 +1,28 @@
+class Solution:
+    def closestEqual(self, nums: List[int], queries: List[int]) -> List[int]:
+        from collections import defaultdict
+        
+        index_map = defaultdict(list)
+        n = len(nums)
+        
+        for i in range(n):
+            index_map[nums[i]].append(i)
+        
+        result = []
+        
+        for query in queries:
+            value = nums[query]
+            indices = index_map[value]
+            if len(indices) <= 1:
+                result.append(-1)
+                continue
+            
+            min_distance = float('inf')
+            for idx in indices:
+                distance = abs(idx - query)
+                circular_distance = n - distance
+                min_distance = min(min_distance, min(distance, circular_distance))
+            
+            result.append(min_distance)
+        
+        return result

README.md

@@ -425,3 +425,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-04-13 — [Minimum Distance to the Target Element](https://leetcode.com/problems/minimum-distance-to-the-target-element/) (Easy) → `Easy/2026-04-13-1848-Minimum-Distance-to-the-Target-Element`
 - 2026-04-14 — [Minimum Total Distance Traveled](https://leetcode.com/problems/minimum-total-distance-traveled/) (Hard) → `Hard/2026-04-14-2463-Minimum-Total-Distance-Traveled`
 - 2026-04-15 — [Shortest Distance to Target String in a Circular Array](https://leetcode.com/problems/shortest-distance-to-target-string-in-a-circular-array/) (Easy) → `Easy/2026-04-15-2515-Shortest-Distance-to-Target-String-in-a-Circular-Array`
+- 2026-04-16 — [Closest Equal Element Queries](https://leetcode.com/problems/closest-equal-element-queries/) (Medium) → `Medium/2026-04-16-3488-Closest-Equal-Element-Queries`