3Sum Problem Solution: Optimizing Complexity with Two Pointer Technique

Daily DSA Update – Day 25 Solved: Length of Last Word (LeetCode) Today’s problem looked simple at first glance, but it reinforced an important lesson — clean logic beats shortcut methods. Problem: Given a string containing words and spaces, return the length of the last word. Approach: Instead of using split() (which creates extra space), I traversed the string from the end: • Skipped trailing spaces • Counted characters until the next space appeared Why this matters: Avoiding unnecessary string operations improves space efficiency and shows better control over logic implementation. Key Learning: Sometimes the most optimal solution is not about complex algorithms but about handling edge cases carefully — especially trailing spaces and empty inputs. What this strengthened: • String traversal techniques • Edge case handling • Writing space-optimized code • Thinking from an interviewer’s perspective Consistency is slowly building clarity in problem solving. On to the next challenge. #DSA #DataStructures #Algorithms #Java #LeetCode #ProblemSolving #CodingJourney #DailyLearning

🚀 Day53 🚀 DSA Spotlight: Longest Repeating Subsequence (LRS) Ever faced a problem where you need to find a pattern that repeats within the same string — but without reusing the same character index? 🤯 That’s exactly what the Longest Repeating Subsequence problem is all about! 💡 Problem Insight: Given a string, identify the longest subsequence that appears at least twice, such that the same character position is not reused. 👉 Example: Input: "axxzxy"-->Output: 2 Explanation: The subsequence "xx" appears twice with different index combinations. 🧠 Key Idea: This problem is a smart twist on the classic Longest Common Subsequence (LCS). ✔️ Compare the string with itself ✔️ Ensure indices are different while matching ✔️ Build the solution using Dynamic Programming ⚡ Why this problem matters? Strengthens understanding of DP patterns Teaches subtle constraints handling (i ≠ j condition) Frequently asked in product-based company interviews 🎯 Takeaway: Sometimes, the trick isn’t learning a new algorithm — it’s about modifying a known one smartly. 🚀 Consistently solving these problems strengthens problem-solving skills required for coding interviews and real-world system design. #DSA #Java #CodingInterview #DynamicProgramming #SoftwareEngineer #PlacementPreparation #ProblemSolving #TechCareers

🚀 Day 6 of My DSA Journey – Mastering Patterns, Not Just Problems! Today I solved Two Sum II – Input Array is Sorted 🔢 💡 Key Insight: Two Pointer Pattern Instead of using a HashMap (O(n) space), I used the Two Pointer approach because the array is already sorted. 👉 Approach: Start with two pointers: left = 0 right = n - 1 Calculate sum: If sum == target → ✅ Found answer If sum < target → Move left++ If sum > target → Move right-- ⚡ Why this works? Because the array is sorted, we can intelligently move pointers to reduce time complexity. 📈 Complexity: Time: O(n) Space: O(1) 🧠 Pattern Learned: The Two Pointer Pattern is extremely powerful for: ✔ Sorted arrays ✔ Pair problems ✔ Optimization from brute force 💻 Tech Stack: Java | DSA | Problem Solving 🔥 Takeaway: Don’t just solve problems — identify patterns. That’s what turns practice into interview success. #DSA #Java #CodingJourney #LeetCode #SoftwareEngineer #ProblemSolving #TechCareers #100DaysOfCode

Day 3 — Pattern-Based DSA Practice Continuing to learn and build in public while solving problems pattern by pattern. Today’s focus: Array-Based Problem Solving Problems solved: • Best Time to Buy and Sell Stock • Count Occurrences • Majority Element • Maximum Product Subarray • Merge Intervals • Missing Number • Move Zeroes • Rotation • Sort Colors • Two Sum Key learning: Many array problems are not about complex logic, but about choosing the right approach for the situation. Some required: • greedy thinking • in-place manipulation • understanding patterns like two pointers Realizing that improving in DSA is less about solving more problems and more about understanding why a particular approach works. Trying to focus on pattern recognition and clean implementation. #DSA #Arrays #ProblemSolving #LearningInPublic #Java #CodingJourney

💡 One Small Problem, Big Lesson I recently solved a classic DSA problem: finding the *first non-repeating character* in a string, and it taught me more than I expected. At first glance, it looks simple. But solving it efficiently pushed me to think deeper about: 🔹 Time complexity (avoiding O(n²) solutions) 🔹 Using the right data structures (HashMap for frequency counting) 🔹 Writing clean, readable logic I implemented a solution in Java using a two-pass approach: 1. Count character frequencies 2. Identify the first character with a count of 1 This brought the solution down to *O(n)* time complexity, a big win compared to brute force. Moments like this remind me that mastering Data Structures & Algorithms isn’t about memorizing solutions, but about learning how to think. I’m continuously improving my problem-solving skills and applying them to real-world backend engineering challenges. If you're also on the DSA journey, what problem challenged your thinking recently? #Java #DSA #ProblemSolving #BackendDevelopment #SoftwareEngineering

🚀 Day 78 of DSA Problem Solving 💡 Problem Solved: Count Submatrices with Top-Left Element and Sum ≤ k 🔍 Problem Idea: Given a matrix, count all submatrices that: ✔ Start from the top-left corner (0,0) ✔ Have a sum ≤ k 🧠 Key Learning: Instead of checking every submatrix (which is costly 😵), we optimize using 2D Prefix Sum to compute sums efficiently. ⚙️ Concepts Practiced: 2D Prefix Sum Matrix Traversal Optimization of brute force ⏱️ Time Complexity: 👉 O(m × n) — Efficient due to prefix sum usage 🔥 Real Journey Behind Solution: At first glance, it feels like a brute-force problem 🤯 But the moment you realize every valid submatrix must start from (0,0), the problem simplifies beautifully using prefix sums. That “aha!” moment is what makes DSA addictive 💙 📌 Takeaway: 👉 Always look for constraints that reduce the problem space 👉 Prefix sums are a game-changer in matrix problems Day 78 done. 🚀 #DSA #CodingJourney #Java #LeetCode #ProblemSolving #PrefixSum #TechGrowth

🚀 𝗗𝗮𝘆 𝟮𝟴 – 𝗝𝗮𝘃𝗮 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝗼𝗹𝘃𝗶𝗻𝗴 & 𝗗𝗦𝗔 𝗝𝗼𝘂𝗿𝗻𝗲𝘆 Consistency builds capability. Today marks Day 28 of my continuous practice in Java Problem Solving and Data Structures & Algorithms. Each day is helping me strengthen my fundamentals and improve my logical thinking. 🔹 Concepts Practiced Today - Binary Search – understanding how it significantly reduces time complexity compared to Linear Search - Floor of a Number - Ceil of a Number - Finding the Span of elements - Leader in an Array 🧪 Practice Test Focus Worked on array and sub-array based logical problems such as: - Printing all elements whose index position sum is divisible by m1 and m2 - Writing a program to identify subarrays where the difference between the maximum and minimum element equals k These exercises are helping me develop a deeper understanding of algorithm efficiency, edge cases, and array traversal logic. 💡 Every problem solved is another step toward becoming a stronger developer. #Java #DSA #ProblemSolving #LearningInPublic #ProgrammingJourney #ComputerScience #DeveloperGrowth

Day 44 of My DSA Journey 🚀 | Problem: Reverse a String 🧠 Problem Summary: Given a string, reverse the characters of the string. 💡 Key Concepts: • Two-pointer technique • Character array conversion • In-place swapping • String reconstruction 🧠 Approach: I used the two-pointer technique to reverse the string. Step-by-step: • Convert the string into a character array using toCharArray(). • Initialize two pointers: → left at the beginning of the array → right at the end of the array. • Swap characters at left and right. • Move left forward and right backward. • Continue until both pointers meet. Finally, convert the modified character array back into a string. 📈 Time Complexity: O(n) — each character is visited once 📉 Space Complexity: O(n) — character array created from the string 🧪 Test Case: Input: "I love Java" Output: "avaJ evol I" 🔧 Practical Usage / Why This Matters: • Text formatting in applications • Reversing data in string manipulation tasks • Processing palindromic transformations • Preprocessing strings in compilers or parsers 🌱 What I Learned Today: I reinforced how two-pointer swapping is a simple and efficient way to manipulate string data. 💬 How would you solve this problem differently? Share your approach! 🙌 If you're preparing for placements, let’s connect and grow together! #dsa #string #javaprogramming #coding #problemSolving #datastructures #algorithms #softwareengineering #placements #developerjourney

While revising Binary Search, I noticed a subtle but important issue with how we calculate the mid value 👀....... Using (low + high) / 2 can cause integer overflow for large inputs, leading to incorrect results. A safer approach is low + (high - low) / 2, which avoids this problem. It’s a small change, but it makes the implementation more robust 💡 Sometimes, it's not about learning new algorithms… It's about understanding the depth of what we already know. 😊 #Java #DSA #BinarySearch #Coding #SoftwareEngineering #Learning

🔥 Day 43 – DSA Journey ━━━━━━━━━━━━━━━━━━━ 📌 LeetCode 1732 – Find the Highest Altitude ━━━━━━━━━━━━━━━━━━━ 🚴♂️ A simple yet insightful problem based on Prefix Sum. 💡 Core Idea: Track the running altitude and keep updating the maximum value reached during the journey. 🧠 Approach: ✔ Start from altitude = 0 ✔ Add each gain to current sum ✔ Update max altitude at every step 📈 Complexity: ⏱ Time → O(n) 📦 Space → O(1) ✨ Key Learning: Sometimes the simplest logic (running sum) solves the problem efficiently without extra space. 💻 Language Used: Java Consistency is building problem-solving mindset step by step. ━━━━━━━━━━━━━━━━━━━ #LeetCode #DSA #Java #Coding #ProblemSolving #PlacementPreparation #LearningJourney