Optimizing Circular Proximity with Spatial Indexing in Java

#100DaysOfLeetcode journey 🚀 Day 67/100 — Optimizing Circular Proximity! Today’s Problem: Minimum Circular Distance to Matching Elements 🔹 The Goal: Given an array that "wraps around," find the shortest path from a specific index to any other occurrence of the same value. 🔹 The Insight: A naive search for every query would be $O(Q \times N)$, which is catastrophic for large datasets. The breakthrough here is Spatial Indexing. By pre-grouping the indices of every value and keeping them sorted, we transform a global search into a localized neighbor check. 🔹 The Logic: Value-to-Index Mapping: I used a HashMap to store sorted lists of indices for each unique number. Logarithmic Search: Using binarySearch, I instantly located the query index within its value-group. The "Circular Sandwich": Because the indices are sorted, the closest matching elements are always the immediate neighbors in the list. By checking the left, the right, and the wrap-around (first/last) elements, we guarantee the global minimum in $O(\log N)$ time. ✨ Achievement: Day 67! Successfully applied pre-computation and binary search to optimize a spatial query problem. Understanding that the "closest" element in a circular topology is always an adjacent neighbor in the sorted index space is a powerful shortcut for range-based problems. 🔍 Steps followed: ✔ Map Pre-processing: Clustered indices for constant-time value lookups. ✔ Binary Search Integration: Optimized neighbor identification to logarithmic time. ✔ Modular Distance Logic: Correctly handled the $N - \text{linearDist}$ calculation for circular boundaries. 🔧 Complexity Analysis: Time Complexity: $O(N + Q \log N)$ Space Complexity: $O(N)$ 67 days down! The logic is getting faster, and the problems are getting more interesting. Let's keep the streak alive! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #ArrayAlgorithms #BinarySearch #Optimization #Day67

#100DaysOfLeetcode journey 🚀 Day 66/100 — Thinking in Circles! Today’s Problem: 2515. Shortest Distance to Target String in a Circular Array 🔹 The Goal: Find the shortest path between a starting index and a target string in an array that "wraps around" at the ends. You can move either clockwise or counter-clockwise. 🔹 The Insight: This is a beautiful exercise in Radial Geometry applied to a 1D structure. When you connect the ends of an array, the distance between any two points $i$ and $j$ isn't just $|i - j|$. There's a hidden path that goes through the "boundary" of the array. The shortest path is always the minimum of the direct linear distance and the "complement" distance ($N - \text{Linear Distance}$). 🔹 The Logic: Single Pass Scan: Instead of complex BFS, we just need to identify where the target lives. Dual-Distance Logic: For every match found, we evaluate the two possible routes: The "Standard" route (staying within the array bounds). The "Circular" route (jumping from index 0 to $N-1$ or vice versa). Constant Space: The entire check happens in $O(N)$ time with $O(1)$ memory. ✨ Achievement: Day 66! Moving from complex bitwise validation and string parsing into circular array logic. It’s a great reminder that understanding the topology of your data structure (whether it's a line, a circle, or a grid) is the first step toward optimization. 🔍 Steps followed: ✔ Linear Traversal: Evaluated every potential target location. ✔ Modular Arithmetic: Simplified circular transitions using absolute differences. ✔ Optimal Minimum: Tracked the global minimum across all valid occurrences. 🔧 Complexity Analysis: Time Complexity: $O(n)$ Space Complexity: $O(1)$ 66 days down! The finish line is coming into focus. Let’s keep the momentum! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #ArrayAlgorithms #CircularArrays #Optimization #Day66

#100DaysOfLeetcode journey 🚀 🚀 Day 72/100 — Hamming Distance & Early-Exit Optimization! Today’s Problem: 2452. Words Within Two Edits of Dictionary 🔹 The Goal: Given a set of query words and a dictionary, identify which queries can be transformed into any dictionary word using a maximum of two character replacements. 🔹 The Insight: This is a classic "String Similarity" problem. Since all words are guaranteed to have the same length, the number of edits required is simply the Hamming Distance—the count of positions where characters differ. 🔹 The Logic: Exhaustive Comparison: For each query, we check it against the dictionary entries until we find a match within the 2-edit threshold. The Early Break (Pruning): This is the key optimization. While comparing two words character by character, if the difference count (diff) exceeds 2, we immediately stop and move to the next dictionary word. Short-Circuiting: Once a query word is validated against any dictionary word, we add it to our results and immediately move to the next query, avoiding unnecessary comparisons. ✨ Achievement: Day 72! Moving into the final 30 days of the challenge. Today’s solution highlights how simple logic—like breaking a loop early when a threshold is breached—can significantly improve the performance of $O(N \cdot M)$ algorithms without the complexity of more advanced data structures like Tries. 🔍 Steps followed: ✔ Hamming Distance Logic: Calculated positional differences for equal-length strings. ✔ Threshold Gating: Implemented a diff > 2 check to prune redundant character comparisons. ✔ Order Preservation: Ensured the results followed the original query sequence. 🔧 The Stats: Time Complexity: $O(Q \cdot D \cdot L)$ (where $Q$ is queries, $D$ is dictionary size, and $L$ is word length) Space Complexity: $O(1)$ auxiliary space. 72 days down! The logic is getting sharper, and the finish line is coming into focus. Let’s keep pushing! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #StringAlgorithms #Optimization #Algorithms #Day72

#100DaysOfLeetcode journey 🚀 🚀 Day 68/100 — Numerical Symmetry & Mirror Distances! Today’s Problem: Mirror Distance of an Integer 🔹 The Goal: Define the "Mirror Distance" of a number $n$ as the absolute difference between the number and its digit-reversal. For example, if $n = 123$, the mirror is $321$, and the distance is $|123 - 321| = 198$. 🔹 The Insight: This is a fundamental exercise in Digit Manipulation. Reversing a number isn't just a string operation; it’s an arithmetic process. By using the modulo operator (% 10) to extract the last digit and integer division (/ 10) to shift the decimal place, we can reconstruct the mirror image in a single pass. 🔹 The Logic: Arithmetic Reversal: I used a while-loop to peel off digits and build the reversed integer. This naturally handles the "omit leading zeros" rule (e.g., reversing $120$ results in $21$ because $0 \times 10 + 2 \times 1 + 1$ arithmetic logic). Absolute Variance: The final result is simply the absolute magnitude of the gap between the two values. Negative Handling: I ensured the logic remains robust for negative integers by reversing the absolute value and reapplying the sign. ✨ Achievement: Day 68! We are well into the second half of the challenge. Today’s solution highlights how core arithmetic can replace heavy string parsing for better performance and lower memory overhead. 🔍 Steps followed: ✔ Digit Extraction: Peeling digits using remainder operations. ✔ Numerical Reconstruction: Building the reversed value through decimal shifting. ✔ Error Guarding: Managed potential sign issues to ensure a valid absolute distance. 🔧 The Stats: Time Complexity: $O(\log_{10} n)$ Space Complexity: $O(1)$ 68 days down! The journey into algorithmic mastery continues. Let's keep the momentum! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #MathAlgorithms #Logic #Optimization #Day68

#100DaysOfLeetcode journey 🚀 Day 64/100 — Linear Search & Absolute Minimization! Today’s Problem: 1848. Minimum Distance to the Target Element 🔹 The Goal: Given an array, a target value, and a starting index, find the index $i$ where $nums[i] == target$ such that the absolute distance $|i - start|$ is minimized. 🔹 The Insight: While many distance-based problems involve complex sorting or two-pointer strategies, this one is beautifully straightforward. Because we need to find the absolute minimum distance, a single linear scan is all it takes to evaluate every potential candidate and keep track of the closest one. 🔹 The Logic: Exhaustive Search: We iterate through the entire array to ensure we don't miss any occurrences of the target. Distance Tracking: For every match, we calculate the absolute difference between the current index and our start point. Running Minimum: We maintain a minDistance variable that gets updated whenever a "closer" target is discovered. ✨ Achievement: Day 64! Only 36 days remaining until the century mark. Today was a great reminder that not every "Hard" problem requires a complex data structure—sometimes, the most robust solution is a clean, well-implemented linear scan. 🔍 Steps followed: ✔ Single-Pass Scan: Maintained a strictly $O(N)$ runtime. ✔ Distance Logic: Used Math.abs to handle indices on both the left and right sides of the start point. ✔ Constant Space: Kept the memory footprint at $O(1)$. 🔧 Complexity Analysis: Time Complexity: $O(N)$ Space Complexity: $O(1)$ 97 days down! The finish line is officially in sight. Let's finish these final three days with the same consistency that got us here! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #LinearSearch #Optimization #Algorithms #Day64

#100DaysOfLeetcode journey 🚀 🚀 Day 73/100 — Budgeting Increments with Sliding Windows! Today’s Problem: 1838. Frequency of the Most Frequent Element 🔹 The Goal: Maximize the frequency of any element in an array by increasing other elements. You have a "budget" of $k$ total increments. 🔹 The Insight: This is a classic Sorting + Sliding Window challenge. By sorting the data, we ensure that elements that require the least work to become identical are grouped together. The problem then shifts from a search for "which value" to a search for "how wide a window" can we afford. 🔹 The Logic: The Cost Equation: For any window ending at right, the cost to make everything equal to nums[right] is simply $(Value \times Size) - \text{Total Sum}$. Greedy Expansion: We keep expanding the right pointer and adding to our window sum. Dynamic Contraction: The moment our "cost to equalize" exceeds our budget $k$, we shrink the window from the left until it’s affordable again. Efficiency: This allows us to find the global maximum frequency in a single linear sweep after sorting. ✨ Achievement: Day 73! We're deep into the final 30% of the challenge. Moving from prefix-sum coordinate math to these dynamic-cost sliding windows is refining my ability to handle optimization problems with multiple constraints. 🔍 Steps followed: ✔ Sort & Proximity: Grouped similar values to minimize increment costs. ✔ Long-Precision Math: Used long to prevent overflow when calculating window areas. ✔ Linear Synchronization: Implemented the two-pointer sweep for an efficient $O(N \log N)$ total runtime. 🔧 The Stats: Time Complexity: $O(n \log n)$ Space Complexity: $O(1)$ 73 days down! The logic is getting faster and the solutions are getting cleaner. Let’s keep going! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #SlidingWindow #Sorting #Optimization #Day73

#100DaysOfLeetcode journey 🚀 🚀 Day 77/100 — Mapping Structural Connectivity! Today’s Problem: 1391. Check if There is a Valid Path in a Grid 🔹 The Goal: Navigate through a grid of different street types (curves, straights, and corners) to see if a valid path exists from the entrance to the exit. 🔹 The Insight: This isn't just a standard pathfinding problem like BFS or DFS. The "edges" in this graph are directional and restrictive. Moving from Cell A to Cell B requires Reciprocal Connectivity—Cell A must have a door leading to B, and Cell B must have a door leading to A. 🔹 The Logic: Geometry to Graph: I mapped each of the 6 street types into vectors. For example, Type 3 (Left-Down) is mapped to {(0, -1), (1, 0)}. Double-Sided Verification: Before moving to a neighbor, my DFS verifies that the neighbor "accepts" the connection from the current cell's direction. Recursive Search: Using Depth-First Search with a visited matrix, I explored the maze of streets in $O(M \cdot N)$ time. ✨ Achievement: Day 77! Moving from grid cycle detection into complex directional connectivity. Mastering these "rule-based" traversals is a key step toward solving real-world routing and circuit-design algorithms. 🔍 Steps followed: ✔ Vector Offsets: Organized the street shapes into a 3D lookup table. ✔ Symmetry Check: Implemented the logic to ensure paths are "plugged in" correctly at both ends. ✔ Memoized Traversal: Prevented cycles and redundant checks using state-tracking. 🔧 The Stats: Time Complexity: $O(M \times N)$ Space Complexity: $O(M \times N)$ 77 days down! The logic is getting more robust, and the patterns are becoming second nature. Let’s keep moving! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #GraphTheory #DFS #Pathfinding #Algorithms #Day77

#100DaysOfLeetcode journey 🚀 Day 55/100 — Reversing Diagonal Transpositions! Today’s Problem: 2075. Decode the Slanted Ciphertext 🔹 The Goal: Decipher a string that was written diagonally into a matrix but read out row-by-row. We need to extract the original message and handle any padding spaces correctly. 🔹 The Insight: This is a classic "Coordinate Mapping" problem. When data is transformed from one traversal order (diagonal) to another (row-major), the key is to find the mathematical relationship between the indices. If a character is at row $i$ and starts at diagonal $j$, its column index is always $i + j$. 🔹 The Logic: Grid Mapping: By calculating cols = length / rows, we can treat the flat string as a 2D matrix without actually allocating any extra 2D space. Diagonal Scanning: I used a nested loop where the outer loop selects the starting "offset" (top-row column) and the inner loop moves down the diagonal. Precision Trimming: Since the cipher pads the matrix with spaces, the final step requires a backward-pass to remove trailing blanks while preserving spaces that were part of the original message. ✨ Achievement: Day 55! Successfully implemented a linear-time $O(N)$ decoding algorithm. Moving from backtracking and combinatorial searches into geometric string manipulation is a great way to maintain a diverse problem-solving toolkit. 🔍 Steps followed: ✔ Dimension Derivation: Computed the matrix footprint based on the input constraints. ✔ Index Calculation: Leveraged i * cols + (j + i) to access characters directly from the 1D string. ✔ In-Place Cleanup: Managed result trimming to ensure accuracy against the problem's whitespace rules. 🔧 Complexity Analysis: Time Complexity: $O(n)$ Space Complexity: $O(n)$ 83 days in! Only 17 more to go. The finish line is closer than ever! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #StringAlgorithms #MatrixManipulation #Algorithms #Day55

Auto-commit DSA problems Even though I was solving LeetCode regularly, my GitHub stayed inactive for months. That became a problem when I applied for an internship and was asked for my GitHub profile. That’s when it hit me why not automate this? So I built a Python tool that: Detects when I submit an accepted solution → fetches the code → saves it with proper metadata → and automatically commits it to GitHub every 10 minutes. No manual effort. Just solve problems, and everything else happens in the background. Everything perfectly aligning with the tech stack I was working on: • Python (requests, subprocess, argparse, logging) • LeetCode GraphQL API + Codeforces REST API • Git + Cron This is what I love about programming if something is repetitive or annoying, you can build a system to eliminate it. Currently working smoothly with LeetCode. Codeforces integration is still a work in progress due to API limitations. If you’re grinding DSA, this might help you keep your GitHub consistent without extra effort. Repo: https://lnkd.in/gRdSuC6S edit: cron works with mac/linux, if you are using windows it will need a task scheduler setup and you are good to go (Just phase-1, I have plans to improve this project however it does the immediate work which is automating leetcode submissions. Will share progress soon) #Python #GitHub #LeetCode #DSA #BuildInPublic #Automation #Developers #TechCommunity #CodingJourney

#100DaysOfLeetcode journey 🚀 🚀 Day 76/100 — Tracking Recursive Loops in 2D Space! Today’s Problem: 1559. Detect Cycles in 2D Grid 🔹 The Goal: Given a grid of characters, find if there exists a cycle of length 4 or more consisting of the same value. A cycle is a path that starts and ends at the same cell without moving back to the immediate previous cell. 🔹 The Insight: This is a classic Graph Theory problem applied to a Matrix. To find a cycle, we need to distinguish between "moving forward" and "moving backward." While a standard DFS can find connected components, we need Parent Tracking to identify when we've circled back to a visited node through a different path. 🔹 The Logic: Component Traversal: I used DFS to explore islands of identical characters. Parental Guidance: By passing the (pr, pc) coordinates of the previous cell into the recursion, I ensured the algorithm ignores the immediate backtrack. Cycle Invariant: If we hit a cell that is already visited but is NOT our parent, we've found a loop! In a grid graph, such a loop is guaranteed to have a length of at least 4. ✨ Achievement: Day 76! Moving from coordinate geometry back into graph-based grid traversals. Mastering the "Visited vs. Parent" logic is essential for avoiding infinite loops in complex search algorithms and is a fundamental skill for pathfinding optimizations. 🔍 Steps followed: ✔ Global Visited State: Prevented redundant searches across the $M \times N$ grid. ✔ Directional Vectors: Managed 4-way movement using concise offset arrays. ✔ Recursive Validation: Successfully separated valid cycles from simple path backtracking. 🔧 Complexity Analysis: Time Complexity: $O(M \times N)$ Space Complexity: $O(M \times N)$ (Visited array + Recursion stack) 76 days down! The logic is scaling, the patterns are repeating, and the finish line is getting closer. Let's keep the momentum! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #DFS #GraphTheory #CycleDetection #Algorithms #Day76