Optimize DSA with Two Pointer Approach

🚀 DSA – Day 16 Continuing the journey with consistent daily problem solving and strengthening core concepts 🚀 📘 Today’s Topic: Strings (Java) 🧠 Problem Solved: 8. String to Integer (atoi) 🔢 🎯 Practiced string parsing and edge case handling like whitespace trimming, sign detection, overflow handling, and numeric conversion. This problem helped improve attention to detail and handling real-world input scenarios. Building stronger fundamentals by focusing on tricky edge-case driven problems 💪 Consistency is turning into confidence 🚀 #DSA #Java #Strings #LeetCode #Placements #Consistency 🚀

Today I practiced an important DSA concept: Finding First & Last Occurrence of an Element in an Array What I learned: 1) How to find all occurrences using Linear Search 2) How to find first & last index 3) When to use Linear Search (unsorted array) 4) When to use Binary Search (sorted array) 5) Time Complexity → O(n) for unsorted array #DSA #Java #CodingPractice #PlacementPreparation #ProblemSolving #FutureSoftwareEngineer

Day 4 of DSA Practice 🚀 Today I solved two classic problems focused on the two-pointer technique. 1️⃣ 3Sum (LeetCode 15) Tried two approaches: -Sorting + HashMap -Sorting + Two Pointers (optimal) Time Complexity: O(n²) Space Complexity: O(n) (HashMap) / O(1) (Two pointers, excluding result) Really understood how sorting simplifies the logic and helps control pointer movement efficiently. 2️⃣ Container With Most Water (LeetCode 11) Used the greedy two-pointer approach. Time Complexity: O(n) Space Complexity: O(1) Key learning: When width keeps shrinking, the only way to maximize area is to move the pointer with the smaller height. Consistency is starting to pay off 💪 #Day4 #DSA #LeetCode #Java #ProblemSolving #TwoPointers#PlacementPreparation

Day 23 - DSA Practice Solved “Reverse Pairs” today using the Merge Sort approach to optimize the brute force solution. When problems involve counting pairs with conditions across the array, Divide & Conquer (Merge Sort technique) can reduce time complexity from O(n²) → O(n log n). Every problem is a small step toward mastering problem solving and system thinking. #LeetCode #DSA #ProblemSolving #Java #CodingJourney #MergeSort #LearningInPublic

🚀 Daily DSA Practice – Day 52 | Dynamic Programming – Pick or Skip (Java) Continuing my Dynamic Programming journey, today I focused on a classic decision-making DP problem that introduces the powerful Pick or Skip pattern. 📌 Problem Solved (LeetCode): 198. House Robber (Medium) 🎯 Concept: 1D DP – Pick / Not Pick Strategy 🧠 Key Learning: At each house, we decide whether to rob the current house or skip it to avoid robbing adjacent houses. DP Relation: dp[i] = max(dp[i-1], nums[i] + dp[i-2]) 🔍 What I Practiced: ✔ Understanding Pick vs Skip decision logic ✔ Converting recursion → memoization → tabulation ✔ Space optimization using two variables ✔ Identifying overlapping subproblems This problem strengthened my ability to think in terms of choices and consequences, which is a core mindset for Dynamic Programming and many real interview problems. #DSA #LeetCode #DynamicProgramming #Java #ProblemSolving #InterviewPreparation #Consistency #SoftwareEngineer

🚀 DSA Insight — Reversing an Array the Optimal Way A very common problem, but also a great test of fundamentals. Many beginners create a new array or use extra memory to reverse elements… But the most efficient solution doesn’t require any extra space 👇 🏆 Optimal Approach — Two Pointer Technique Use two pointers: left → start of array right → end of array Swap elements and move inward. swap(arr[left], arr[right]) left++ right-- We stop when pointers meet in the middle. 📊 Complexity MetricValueTime ComplexityO(n)Space ComplexityO(1)Swapsn/2💡 Why It’s Optimal To reverse an array, every element must move at least once → O(n) is unavoidable. This approach also avoids extra memory, making it optimal in both time and space. 🧠 Simple logic + strong fundamentals = efficient coding #DSA #Algorithms #CodingInterview #Java #ProblemSolving #SoftwareEngineering

Leetcode Problem || Number of Steps to Reduce a Number in Binary Representation to One(1404)🚀 Today I solved a binary manipulation problem where we must: If number is even → divide by 2 If odd → add 1 Count steps until number becomes 1 💡 Learned: How to simulate binary addition using carry Avoid integer overflow Optimize string-based numeric problems #Java #DSA #BitManipulation #LeetCode #ProblemSolving

#Day58 of my second #100DaysOfCode Today’s problem was about carefully handling overlapping intervals. DSA • Solved Merge Intervals (LeetCode 56) • Implemented a brute force approach by checking and merging overlapping intervals → O(2n) + O(n log n) time • Implemented the optimal approach by sorting intervals and merging them in a single traversal → O(n log n) + O(n) time • Key idea: once intervals are sorted by start time, overlapping ranges can be merged efficiently in one pass These interval problems really test attention to detail with edge cases. #DSA #Algorithms #LeetCode #Java #100DaysOfCode #WomenWhoCode #BuildInPublic #LearningInPublic

🚀 𝐃𝐚𝐲 57 / 100 𝐃𝐚𝐲𝐬 𝐨𝐟 𝐂𝐨𝐝𝐞 🚀 Today’s problem: 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 153 – 𝐅𝐢𝐧𝐝 𝐌𝐢𝐧𝐢𝐦𝐮𝐦 𝐢𝐧 𝐑𝐨𝐭𝐚𝐭𝐞𝐝 𝐒𝐨𝐫𝐭𝐞𝐝 𝐀𝐫𝐫𝐚𝐲  A classic binary search problem that strengthens 𝐥𝐨𝐠𝐢𝐜, 𝐩𝐫𝐞𝐜𝐢𝐬𝐢𝐨𝐧, 𝐚𝐧𝐝 𝐨𝐩𝐭𝐢𝐦𝐢𝐳𝐚𝐭𝐢𝐨𝐧 𝐭𝐡𝐢𝐧𝐤𝐢𝐧𝐠. 🔹 What I practiced today: Applying 𝐛𝐢𝐧𝐚𝐫𝐲 𝐬𝐞𝐚𝐫𝐜𝐡 on rotated arrays Understanding 𝐬𝐨𝐫𝐭𝐞𝐝 + 𝐫𝐨𝐭𝐚𝐭𝐞𝐝 patterns Writing 𝐎(𝐥𝐨𝐠 𝐧) 𝐨𝐩𝐭𝐢𝐦𝐢𝐳𝐞𝐝 logic #100DaysOfCode #Day57 #LeetCode #Java #DSA #BinarySearch #Arrays #ProblemSolving #CodingJourney #DeveloperLife #Consistency

🚀 Day 82 | DSA Journey Today’s focus was on Pascal’s Triangle — a classic problem that looks simple but quietly tests how well you understand patterns and structured thinking. 🔹 Instead of rushing to code, I slowed down and observed how:    • Each row is built from the previous one    • Boundary elements remain constant    • The real logic lies in how the middle values evolve This approach made the solution feel natural rather than forced. Onward to Day 83 with the same momentum 🔥 #Day82 #DSA #ProblemSolving #Java #LeetCode #CodingJourney #Consistency #FutureSoftwareEngineer