Mastering String and Combinatorial Logic with Java

🌟 Same Problem. 4 Different Mindsets. Today I solved the “Valid Anagram” problem — but instead of stopping at one solution, I pushed further. 1️⃣ Sorting → O(n log n) Simple and intuitive. Convert strings to arrays, sort, and compare. ⚠️ Downside: Sorting is unnecessary overhead. 2️⃣ Two HashMaps → O(n) Count frequency of each character in both strings and compare maps. ⚠️ Downside: Extra space + redundant storage. 3️⃣ One HashMap → O(n) Increment using first string, decrement using second. ✔️ Eliminates redundancy, more efficient and clean. 4️⃣ Frequency Array → O(n), O(1) space Use fixed array (size 26) for lowercase letters. ✔️ Fastest and most optimal due to constant space. Realization: The problem didn’t change — my thinking did. Every optimization removed something unnecessary: • First → sorting • Then → extra hashmap • Finally → even space overhead ⚡ Final insight: Good coders solve problems. Great coders refine solutions. #DSA #CodingJourney #Java #ProblemSolving #GrowthMindset

🚀 Solved: Product of Array Except Self (LeetCode 238) Today I solved a very interesting problem that strengthens array + prefix-suffix concepts. 🔹 Problem: Given an array, return a new array where each element is the product of all elements except itself — without using division and in O(n) time. 🔹 Approach: Instead of brute force, I used an optimized approach: ✅ Prefix Product (Left side) ✅ Suffix Product (Right side) This avoids division and keeps space & time efficient. 🔹 Key Idea: First pass: store product of all elements to the left Second pass: multiply with product of all elements to the right 🔹 Code Insight: Efficient use of a single array + running suffix variable 🔹 Complexity:🚀 Solved: Product of Array Except Self (LeetCode 238) Today, I tackled an interesting problem that enhances understanding of array concepts, particularly prefix and suffix approaches. 🔹 **Problem:** Given an array, the task is to return a new array where each element is the product of all other elements, excluding itself—without using division and ensuring an O(n) time complexity. 🔹 **Approach:** Instead of using a brute-force method, I opted for an optimized solution: ✅ Compute a Prefix Product (for the left side) ✅ Compute a Suffix Product (for the right side) This method avoids division while maintaining efficiency in both time and space. 🔹 **Key Idea:** - **First pass:** Store the product of all elements to the left of each element. - **Second pass:** Multiply these results by the product of all elements to the right of each element. 🔹 **Code Insight:** Utilizing a single array along with a running suffix variable enhances efficiency. 🔹 **Complexity:** - Time: O(n) - Space: O(1) (excluding the output array) 💡 This problem deepened my understanding of how prefix and suffix patterns can significantly optimize brute-force solutions. #DSA #LeetCode #Java #CodingJourney #100DaysOfCode #ProblemSolving #TechLearning🚀 Solved: Product of Array Except Self

🚀 Day 76 — Slow & Fast Pointer (Find the Duplicate Number) Continuing the cycle detection pattern — today I applied slow‑fast pointers to an array problem where the values act as pointers to indices. 📌 Problem Solved: - LeetCode 287 – Find the Duplicate Number 🧠 Key Learnings: 1️⃣ The Problem Twist  Given an array of length `n+1` containing integers from `1` to `n` (inclusive), with one duplicate. We must find the duplicate without modifying the array and using only O(1) extra space. 2️⃣ Why Slow‑Fast Pointer Works Here  - Treat the array as a linked list where `i` points to `nums[i]`.   - Because there’s a duplicate, two different indices point to the same value → a cycle exists in this implicit linked list.   - The duplicate number is exactly the entry point of the cycle (same logic as LeetCode 142).  3️⃣ The Algorithm in Steps - Phase 1 (detect cycle): `slow = nums[slow]`, `fast = nums[nums[fast]]`. Wait for them to meet.   - Phase 2 (find cycle start): Reset `slow = 0`, then move both one step at a time until they meet again. The meeting point is the duplicate. 4️⃣ Why Not Use Sorting or Hashing?   - Sorting modifies the array (not allowed).   - Hashing uses O(n) space (not allowed).   - Slow‑fast pointer runs in O(n) time and O(1) space — perfect for the constraints. 💡 Takeaway:  This problem beautifully demonstrates how the slow‑fast pattern transcends linked lists. Any structure where you can define a “next” function (here: `next(i) = nums[i]`) can be analyzed for cycles. Recognizing this abstraction is a superpower. No guilt about past breaks — just another pattern mastered, one day at a time. #DSA #SlowFastPointer #CycleDetection #FindDuplicateNumber #LeetCode #CodingJourney #Revision #Java #ProblemSolving #Consistency #GrowthMindset #TechCommunity #LearningInPublic

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝: 𝐃𝐞𝐭𝐞𝐫𝐦𝐢𝐧𝐞 𝐖𝐡𝐞𝐭𝐡𝐞𝐫 𝐌𝐚𝐭𝐫𝐢𝐱 𝐂𝐚𝐧 𝐁𝐞 𝐎𝐛𝐭𝐚𝐢𝐧𝐞𝐝 𝐁𝐲 𝐑𝐨𝐭𝐚𝐭𝐢𝐨𝐧 (𝟏𝟖𝟖𝟔) Today I solved an interesting matrix problem that involves matrix rotation and comparison. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦: Given two n × n binary matrices mat and target, determine whether mat can become target by rotating it in 90° increments (0°, 90°, 180°, 270°). 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Check if the current matrix equals the target. If not, rotate the matrix 90° clockwise. Repeat the process up to 4 rotations. If any rotation matches the target → return true. 𝐇𝐨𝐰 𝐫𝐨𝐭𝐚𝐭𝐢𝐨𝐧 𝐰𝐨𝐫𝐤𝐬: Step 1: Transpose the matrix (swap mat[i][j] with mat[j][i]) Step 2: Reverse every row This efficiently performs a 90° clockwise rotation in-place. Time Complexity: O(4 × n²) → effectively O(n²) Space Complexity: O(1) (in-place rotation) 𝐊𝐞𝐲 𝐭𝐚𝐤𝐞𝐚𝐰𝐚𝐲: Matrix rotation problems can often be solved efficiently using the transpose + reverse technique, which is a powerful pattern for many 2D array problems. #LeetCode #DataStructures #Algorithms #Java #CodingPractice #ProblemSolving #SoftwareEngineering

Day 9/ #100DaysOfCode Solved LeetCode 1848: Minimum Distance to the Target Element. Approach: The problem can be solved using a straightforward linear traversal. Iterate through the array and check for indices where the value equals the target. For each such index, compute the absolute difference between the current index and the given start index. Maintain a variable to track the minimum distance encountered during the traversal. Solution Insight: Initialize a variable with a large value (e.g., Integer.MAX_VALUE). Traverse the array once. Whenever the target element is found, update the minimum distance using Math.abs(i - start). Return the minimum value after the loop. Complexity: Time Complexity: O(n) Space Complexity: O(1) Result: 72/72 test cases passed with optimal runtime performance. This problem reinforces the importance of simple iteration and careful tracking of minimum values in array-based problems. #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #Algorithms

𝐃𝐚𝐲 𝟓𝟓 – 𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 | 𝐀𝐫𝐫𝐚𝐲𝐬 🚀 Today’s problem extended the previous one by introducing duplicates in a rotated sorted array. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝 • Find Minimum in Rotated Sorted Array II 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 • Used modified binary search • Compared nums[mid] with nums[right] Logic: • If nums[mid] > nums[right] → minimum is in right half • If nums[mid] < nums[right] → minimum is in left half (including mid) • If equal → cannot decide, so shrink search space (right--) 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 • Duplicates can break standard binary search logic • When unsure, safely reduce the search space • Edge cases often define the complexity of the problem • Small changes in conditions can affect performance 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 • Average Time: O(log n) • Worst Case: O(n) (due to duplicates) • Space: O(1) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲 When the data becomes ambiguous, focus on reducing the problem safely instead of forcing a decision. 55 days consistent 🚀 On to Day 56. #DSA #Arrays #BinarySearch #LeetCode #Java #ProblemSolving #DailyCoding #LearningInPublic #SoftwareDeveloper

Real-time systems fail when they treat every threat the same. In Java, an ArrayList means scanning everything. A PriorityQueue changes the game: each new target is ordered by urgency, so the closest threat is processed first That means faster inserts, near-instant retrieval, and smarter threat handling in simulations or detection pipelines Choosing the right data structure isn’t just optimization—it’s engineering maturity. Where have you replaced a simple list with a smarter structure? #Java #Algorithms #ComputerScience #Performance #DataStructures #ThreatDetection

🚀 Day 40/60 – DSA Challenge Today’s problem focused on combining Linked Lists with Stack optimization 💡 🔍 Problem Solved: Remove nodes from a linked list where a node has a greater value on its right side. 🧠 Approach I Used: I used a stack-based approach to efficiently filter out unwanted nodes: Traverse the linked list once Maintain a stack of valid values If the current value is greater than the top of the stack, remove smaller elements Keep only those elements that satisfy the condition Rebuild the linked list from the remaining values ⚡ Key Insight: The stack helps maintain a monotonic decreasing order, ensuring that only the correct nodes are preserved. 📈 Complexity: Time: O(n) Space: O(n) 🎯 What I Learned: Applying monotonic stack concepts to linked lists Optimizing from brute force to linear time Thinking in terms of patterns rather than problems Day by day, getting better at problem-solving and consistency 🔥 #Day40 #DSAChallenge #Java #ProblemSolving #Consistency

🚀 Day 11 – #50DaysLeetCodeChallenge Today I solved the 3Sum problem. 📌 Problem Statement Given an integer array nums, return all the unique triplets [nums[i], nums[j], nums[k]] such that: i ≠ j ≠ k nums[i] + nums[j] + nums[k] = 0 ⚠️ The solution must not contain duplicate triplets. Example: Input: [-1,0,1,2,-1,-4] Output: [[-1,-1,2], [-1,0,1]] 💡 Approach I Used – Sorting + Two Pointers 1️⃣ Sort the array 2️⃣ Fix one element i 3️⃣ Use two pointers: left = i + 1 right = end of array 4️⃣ Check the sum: If sum == 0 → add triplet If sum < 0 → move left++ If sum > 0 → move right-- 5️⃣ Skip duplicates to avoid repeated triplets ⚙️ Key Idea Reduce the problem from 3Sum → 2Sum (using two pointers) Sorting helps in efficient traversal and duplicate handling 🧠 What I learned today ✔️ How sorting simplifies complex problems ✔️ Converting problems into smaller subproblems (3Sum → 2Sum) ✔️ Handling duplicates carefully From simple arrays → advanced pointer techniques 🚀 Consistency is making a difference! #LeetCode #Java #DSA #CodingChallenge #ProblemSolving #SoftwareEngineering

🚀 Day 41 of #LeetCode Journey 📌 Problem: 2515. Shortest Distance to Target String in a Circular Array Today’s problem focused on understanding circular array traversal and how to calculate the minimum distance efficiently. 💡 Key Insight: In a circular array, movement is not limited to one direction. We can move both: ➡️ Forward ⬅️ Backward (wrap-around) So instead of considering only one path, we compare both possibilities to find the shortest route. 🧠 Approach: ✔️ Traverse the array and locate all positions where the target appears ✔️ For each position, compute: Direct distance from start index Circular wrap-around distance ✔️ Take the minimum among all valid distances ✨ Learning: Circular problems become simple when we break them into: 👉 Direct distance 👉 Wrap-around distance This approach helps in many array and graph-based problems as well. ⏱️ Complexity: Time: O(n) Space: O(1) #Day41 #LeetCode #Java #DSA #ProblemSolving #CodingJourney #SoftwareEngineering