3Sum Closest Problem Solution with Two-Pointer Technique

“What I learned after solving 300+ LeetCode problems 👇” At the beginning, I made a mistake. I kept solving random problems every day thinking: “More problems = more skill” But I was wrong. I realized that solving problems randomly is mostly a waste of time if you don’t understand the pattern behind them. Everything changed when I started focusing on patterns instead of problems. Here are some important patterns I learned: • Sliding Window • Two Pointers • Prefix Sum • Binary Search • Recursion & Backtracking • Linked List Patterns • Stack & Monotonic Stack • Hashing / Frequency Count Once you understand these patterns: You don’t need to solve 1000 problems. You start recognizing solutions instantly. Now when I see a problem, I don’t panic. I ask: 👉 “Which pattern does this belong to?” That one question changed everything for me. Still learning, but now with direction 🚀 #DSA #LeetCode #Java #BackendDevelopment #CodingJourney

#Day357 of #1001DaysOfCode LeetCode Daily Challenge Problem: Decode the Slanted Ciphertext (LeetCode 2075) 💡 Approach: The encoded string represents a matrix filled row-wise. I traversed the matrix diagonally (top-left to bottom-right) by converting 2D indices into a 1D string index. Finally, removed trailing spaces to get the correct decoded message. (*you can use inbuilt .stripTrailing() function as well) ⏱ Time Complexity: O(n) 🧠 Space Complexity: O(n) Staying consistent with daily problem solving 🚀 #DSA #Java #LeetCode #ProblemSolving #Coding

#Day370 of #1001DaysOfCode 📘 LeetCode Daily Challenge Problem: Mirror Distance 💡 Approach: Reversed the number using recursion by extracting digits and rebuilding the number. Then calculated the absolute difference between the original number and its reversed form. ⏱ Time Complexity: O(d) 🧠 Space Complexity: O(d) Exploring recursion patterns and improving problem-solving skills 🚀 #DSA #Java #LeetCode #Recursion #ProblemSolving #Coding

Solved Today’s LeetCode Daily Challenge! Problem: Check if Strings Can Be Made Equal With Operations II At first glance, it looks like a swapping problem… but the real trick is understanding the constraint You can only swap characters if the distance between indices is even. Key Insight: Characters at even indices can only swap among even positions Characters at odd indices can only swap among odd positions So instead of simulating swaps (which is messy ), I used a smarter approach: Count frequency of characters at even indices Count frequency at odd indices Compare both strings If both match → Possible Else → Not possible Time Complexity: O(n) Space Complexity: O(1) Takeaway: Sometimes problems look complex, but a small observation can simplify everything. Consistency + pattern recognition = #LeetCode #DSA #Java #Coding #ProblemSolving #TechJourney #100DaysOfCode

🚀 Day 26/100 Days of #CodeChallenge Today’s problem: Isomorphic Strings (Leetcode 205) This problem helped me understand how to map characters between two strings while maintaining consistency and order. 💡 Key Concept: Two strings are isomorphic if characters in one string can be replaced to get the other string — with: ✔️ One-to-one mapping ✔️ No two characters mapping to the same character ✔️ Order preserved 🧠 What I Learned: How to use mapping (arrays/hashmaps) efficiently Importance of bidirectional checking Handling edge cases like unequal lengths ⚡ Approach: Compare lengths first Track character mappings using arrays Ensure consistency in both directions ⏱️ Complexity Analysis: Time Complexity: O(n) → We traverse the strings once Space Complexity: O(1) → Fixed-size arrays (256 characters) ✅ Successfully solved and understood the logic! Every day is a step closer to mastering problem-solving 💪 #Day26 #100DaysOfCode #Java #DSA #LeetCode #CodingJourney #ProblemSolving #TechLearning

🚀 Day 11/100 — #100DaysOfLeetCode Consistency continues — one problem closer to better problem-solving skills 💻🔥 ✅ Problem Solved: 🔹 LeetCode 1423 — Maximum Points You Can Obtain from Cards 💡 Concepts Used: Sliding Window Technique Complementary Subarray Thinking 🧠 Key Learning: Instead of directly choosing k cards from both ends, I learned to think differently — find the minimum sum subarray of size n - k and subtract it from the total sum. This transformation converts a complex decision problem into a clean sliding window optimization. ⚡ Takeaway: Sometimes optimization comes from changing perspective, not increasing complexity. Continuing the journey 🚀 #100DaysOfLeetCode #LeetCode #DSA #SlidingWindow #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic

There was a time when even starting a problem felt confusing. Reading the question multiple times, not knowing where to begin, and getting stuck often. With consistent practice, things started to change — patterns became familiar, approaches became clearer, and solving started to feel more structured. That consistency has now led to solving 150 problems on LeetCode. Focused on building a strong foundation through arrays, strings, hashing, sliding window, and binary search — spending more time understanding the logic rather than just aiming for accepted submissions. This journey improved: * Problem breakdown and thinking approach * Pattern recognition across questions * Code clarity and structure Currently working on improving speed and taking on more challenging problems. 🔗 LeetCode Profile: https://lnkd.in/gkf7m6wp #LeetCode #DSA #Java #ProblemSolving #Coding #SoftwareEngineering

🚀 Solved Linked List Cycle Detection using Fast & Slow Pointers Used Algorithm are: - Slow pointer moves 1 step - Fast pointer moves 2 steps - If they meet → cycle exists To find cycle start: - Move slow to head - Move both one step → meeting point = cycle start ⚡ Time: O(n) | Space: O(1) #DSA #LinkedList #Java #LeetCode #Coding

#Day360 of #1001DaysOfCode 📘 LeetCode Daily Challenge Problem: Search in a Binary Search Tree (LeetCode 700) 💡 Approach: Used the properties of a Binary Search Tree to efficiently search for a value. At each step: If the value is smaller, move to the left subtree If larger, move to the right subtree This reduces the search space at every step. ⏱ Time Complexity: O(h) 🧠 Space Complexity: O(h) Continuing daily consistency in problem solving 🚀 #DSA #Java #LeetCode #BinaryTree #ProblemSolving #Coding

🚀 Day 559 of #750DaysOfCode 🚀 🔍 LeetCode 3741: Minimum Distance Between Three Equal Elements II Today’s problem was an extension of yesterday’s question — but with larger constraints (n up to 1e5), making efficiency crucial ⚡ 💡 Problem Recap: Find three indices (i, j, k) such that: nums[i] == nums[j] == nums[k] Distance = |i - j| + |j - k| + |k - i| is minimized ✨ Approach I Used (Clean & Intuitive): ✔ Stored indices of each number using a HashMap ✔ For each number: If it appears ≥ 3 times Check consecutive triplets of indices ✔ Compute distance using: 👉 |i - j| + |j - k| + |k - i| 💻 Key Code Insight: Instead of checking all combinations, I only checked sliding windows of size 3 within index lists — reducing unnecessary work. 🧠 Learning: Even in medium problems, a simple structured approach (grouping + sliding window) can pass efficiently when applied correctly. ⚡ Complexity: Time: O(n) to build map + O(n) traversal Space: O(n) 💬 Takeaway: Don’t overcomplicate — sometimes the same idea from an easy problem scales well with just a small optimization in thinking. #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Tech #Programming #Developers #100DaysOfCode