Strengthening Logical Thinking with Java String Analysis

⚡ Day 4 — Merge Intervals (Greedy + Sorting) Consistency is slowly turning confusion into clarity. Today’s problem was Merge Intervals — a classic example where the real difficulty isn’t coding, but recognizing the pattern. 🧩 Problem solved: Merge Intervals 🔢 LeetCode: 56 At first glance, the problem looks messy because overlapping ranges create too many comparison possibilities. The turning point was realizing that trying to merge randomly is inefficient — sorting the intervals by start time simplifies everything. Once sorted, the logic becomes straightforward: • Compare the current interval with the last merged interval • If they overlap → extend the boundary • If they don’t → push a new interval No unnecessary comparisons. Just one clean pass. 🔍 Key learnings: • Sorting often converts complex interval problems into linear scans • Greedy decisions work when local choices don’t break global correctness • Tracking only the “last merged interval” avoids redundant checks • Pattern recognition matters more than code length Slowly building the instinct to see patterns before writing loops. Solutions are available here: https://lnkd.in/gW8atfqw More tomorrow. #DSA #Java #LeetCode #GreedyAlgorithm #CodingJourney #StudentDeveloper #LearningInPublic

While solving DSA problems, choosing the right approach changes everything. 🔹 Brute Force ✔ Simple to implement ✔ Easy to understand ❌ Higher time complexity (mostly O(n²)) 👉 Good for small inputs or initial thinking 🔹 Two Pointer Approach ✔ Optimized solution ✔ Often reduces O(n²) → O(n) ✔ Uses smart index movement 👉 Best for sorted arrays / pair problems / sliding window patterns First think brute force → then optimize using patterns like Two Pointers. Smart thinking > Hard coding #DSA #Java #ProblemSolving #SoftwareDevelopment #CodingInterview

Daily Coding Update – Day 23 Today’s challenge: Find the Index of the First Occurrence in a String What I Learned How substring searching works internally Difference between brute force and optimized comparison Why avoiding unnecessary string creation improves performance Approaches Explored Brute force using substring comparison Character-by-character matching (more optimized) Learned about an advanced algorithm: KMP for interview-level optimization Key Takeaway Good developers don’t just solve problems — they analyze time complexity and optimize solutions. Every day I understand DSA a little deeper, and that confidence keeps growing. #Java #DSA #CodingJourney #ProblemSolving #DeveloperGrowth

🚀 Day 13 – LeetCode 60 Days Challenge   Problem Solved: 4 Sum Today I solved the classic 4Sum problem using Sorting + Two Pointer technique. 🔹 Problem: Given an array of integers, return all unique quadruplets such that: nums[i] + nums[j] + nums[left] + nums[right] == target 🔹 Approach I Used: 1️⃣ First, sort the array. 2️⃣ Fix the first element using loop (i). 3️⃣ Fix the second element using loop (j). 4️⃣ Use two pointers (left & right) for remaining two elements. 5️⃣ Carefully skip duplicates to avoid repeated quadruplets. 6️⃣ Used long for sum to avoid integer overflow. This reduces the brute force O(n^4) solution to: ⏱ Time Complexity: O(n^3) 📦 Space Complexity: O(1) (excluding result list) 🔹 Key Learning: - Two pointer technique becomes powerful after sorting. - Duplicate handling is VERY important in combination problems. - Always consider overflow when dealing with large integers. - Pattern recognition: 4Sum is an extension of 3Sum. 💡 Interview Insight: Most interviewers expect you to: ✔ First explain brute force ✔ Then optimize step by step ✔ Handle duplicates properly ✔ Think about overflow edge cases Consistency > Motivation 🔥 Day 13 Done ✅   On to Day 14 🚀 #LeetCode #Java #DSA #ProblemSolving #CodingJourney #InterviewPreparation

🔥 Day 87 of #100DaysOfCode Today’s challenge: LeetCode: Implement Stack using Queues 📚🔁 📌 Problem Summary Implement a stack (LIFO) using only queue operations: push(x) pop() top() empty() You can only use standard queue operations (offer, poll, peek, isEmpty). 🧠 Approach: Two Queues Since stack is LIFO and queue is FIFO, we simulate stack behavior by rearranging elements during push. ⚙️ Strategy Used: Move all elements from q1 → q2 Add new element to q1 Move everything back from q2 → q1 Now: The newest element is always at the front of q1 pop() becomes simple → just q1.poll() 🔁 Key Idea Make push() costly Make pop() O(1) ⏱ Time Complexity push() → O(n) pop() → O(1) top() → O(1) empty() → O(1) 💾 Space Complexity: O(n) ⚡ Performance Runtime: 0 ms 100% faster than other submissions 🚀 💡 What I Learned Data structures can simulate each other. The trick is choosing where to handle the complexity. Understanding internal behavior matters more than memorizing code. Stack → Queue → Simulation mastery growing stronger 💪 On to Day 88 🔥 #100DaysOfCode #LeetCode #Stack #Queue #Java #DSA #InterviewPrep

🚀 Day 20 of #100DaysOfCode Solved 54. Spiral Matrix on LeetCode 🌀 🧠 Key insight: Spiral traversal is all about maintaining boundaries. By shrinking the top, bottom, left, and right limits after each pass, we can cover every element exactly once. ⚙️ Approach: 🔹Maintain four pointers: top, down, left, right 🔹Traverse: 🔹Left → Right (top row) 🔹Top → Bottom (right column) 🔹Right → Left (bottom row) 🔹Bottom → Top (left column) 🔹Update boundaries after each traversal ⏱️ Time Complexity: O(m × n) 📦 Space Complexity: O(1) (excluding output list) #100DaysOfCode #LeetCode #DSA #Matrix #Java #ProblemSolving #LearningInPublic #CodingJourney

🚀 Day 7 of #100DaysOfCode Solved Search a 2D Matrix on LeetCode using an optimized matrix traversal approach 🔎 🧠 Key insight: Since rows and columns are sorted, starting from the top-right corner helps eliminate either a row or a column in each step. ⚙️ Approach: 🔹Start at top-right element 🔹If value < target → move down 🔹If value > target → move left 🔹Repeat until target is found or bounds are crossed ⏱️ Time Complexity: O(m + n) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #Matrix #Java #ProblemSolving #LearningInPublic #CodingJourney

Understanding Tree Height Using Level Order Traversal (BFS) Today I revised an important Binary Tree concept — calculating the height of a tree using Queue (Level Order Traversal). Initially, I used the null marker approach to track levels: Add root to queue Add null to mark end of level Increment height when null is encountered Add another null if queue is not empty While this works, it adds extra conditional checks and complexity. 💡 Then I switched to a cleaner approach using the queue’s size(): ✔ Count number of nodes at current level ✔ Process all nodes of that level ✔ Increment height after each level This approach is: More readable More efficient Interview-friendly Preferred in product-based company interviews 🔑 Key Learning: Sometimes a solution works, but refining it makes it cleaner and more optimal. Writing better logic > just writing working code. #DSA #BinaryTree #LevelOrderTraversal #Java #CodingJourney

Problem-solving is not limited to numbers and arrays — strings demand a different way of thinking. This week, I focused on string-based problems, where attention to detail, recursion, and pattern recognition play a major role. These problems helped me improve how I break down logic and handle edge cases. 🔗 GitHub Repository (Code & Logic): https://lnkd.in/gQHKDf7Z All solutions are implemented using Java, with logic as the main priority. 📌 String problems solved this week: Step by step, strengthening fundamentals and staying consistent 🚀 #ProblemSolving #Java #Strings #DSA #Recursion #LearningJourney #Consistency #SoftwareDevelopment