Hamming Distance & Early-Exit Optimization in LeetCode

#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 — 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 66! 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 #Day66

#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 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

#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

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

🚀 Day 25 of My DSA Journey – Mastering In-Place Array Manipulation Today I solved an interesting problem on LeetCode: 👉 Remove Duplicates from Sorted Array II 🔍 Problem Understanding Given a sorted array, the goal is to remove duplicates in-place such that each element appears at most twice, and return the new length. ⚠️ Constraint: No extra space allowed Modify array in-place 🧠 Brute Force Approach Use extra space (like ArrayList) Track frequency and rebuild array ❌ Not optimal due to O(n) space complexity ⚡ Optimized Approach (Two Pointer Technique) 💡 Key Idea: Since array is sorted, duplicates are adjacent. We can compare current element with the element 2 steps back. 🪜 Steps Start pointer i = 2 (since first 2 elements are always valid) Traverse from j = 2 → n-1 Check: If nums[j] != nums[i-2] → valid element Place it at index i and increment i 🧾 Code Snippet (Java) class Solution { public int removeDuplicates(int[] nums) { int i = 2; for(int j = 2; j < nums.length; j++) { if(nums[j] != nums[i-2]) { nums[i] = nums[j]; i++; } } return i; } } 🧪 Example Walkthrough Input: [1,1,1,2,2,3] Process: Allow only 2 occurrences Final array becomes: [1,1,2,2,3] Output: 5 ⏱️ Complexity Analysis Time Complexity: O(n) Space Complexity: O(1) ✅ (In-place) 💡 Key Learning Sorted array → powerful advantage Two-pointer technique = must-know for interviews Comparing with i-2 is the trick 🔥 🙏 Gratitude Grateful for the consistency and learning curve. Every problem sharpens my logic a bit more! 📈 Consistency Note Showing up daily > being perfect occasionally 💯 #DSA #LeetCode #Java #CodingJourney #100DaysOfCode #SoftwareEngineering #ProblemSolving #InterviewPrep #TechLearning

Day 24 of #100DaysOfCode I stared at this problem for 40 minutes trying every possible target value. Then one insight — borrowed from basic statistics — made it click instantly. 🧩 The Problem: Minimum Operations to Make a Uni-Value Grid (LeetCode 2033 — Medium) Given a 2D grid and a fixed step value x, transform every element to the same value using the minimum number of add/subtract operations. My first instinct? Try every possible target. Loop through everything. Classic overthinking. 😅 💡 The Key Insight — Why the Median? The median minimizes the sum of absolute differences. This is a well-known statistics fact — and it maps perfectly to this problem. Instead of brute-forcing every target, the strategy is simple: → Flatten the 2D grid into a 1D array → Sort it → Pick the middle element (median) as the target → Count total operations using the absolute difference divided by x No guessing. No unnecessary loops. Just math doing the heavy lifting. ⚠️ The Constraint Check Nobody Talks About Before applying any operations — check if all elements share the same remainder when divided by x. If they don't, it's mathematically impossible to make the grid uni-value. Return -1 immediately and save the computation entirely. This "fail fast" mindset is just as important as the algorithm itself. 📈 Complexity Breakdown → Flatten + Sort → O(n log n) → Single pass to count operations → O(n) → Space → O(n) for the flattened array Simple, clean, and efficient. 🧠 What This Problem Reinforced ✅ Greedy thinking with median optimization ✅ Handle impossible cases before computation — fail fast ✅ Transform 2D problems into simpler 1D forms ✅ Let math do the heavy lifting before writing a single loop The best solutions often come from asking: "What does math already know about this?" On to the next challenge 💪 👇 What's a problem where a simple insight saved you from overcomplicating things? Drop it in the comments — would love to learn from your experience! #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #CodingJourney #SoftwareEngineering #Programming