Building Reusable Patterns in Coding

Day 8 — Array problems Searching & basic operations Method practice (modular coding) Big shift: Stopped writing everything in one block. Started breaking problems into functions. Less chaos. More structure. Day 9 tomorrow. #LearnInPublic #Java #BuildInPublic

🚀 Day 30/60 — LeetCode Discipline Problem Solved: 3Sum Closest Difficulty: Medium Today’s problem pushed beyond exact answers and focused on finding the closest possible sum to a given target — a subtle yet powerful variation of the classic 3Sum problem. By sorting the array and using a two-pointer approach, the solution efficiently explores combinations while continuously updating the closest result. This problem highlights how small modifications in logic can significantly change the nature of a problem — from exact matching to optimal approximation. 💡 Focus Areas: • Strengthened two-pointer technique • Practiced working with sorted arrays • Improved handling of optimization conditions • Learned to track and update closest values dynamically • Reinforced problem-solving under constraints ⚡ Performance Highlight: Achieved efficient runtime with optimized traversal. Not every problem asks for perfection — sometimes, the goal is to get as close as possible. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #TwoPointers #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering #Java #Developers #Consistency #TechGrowth #LearnToCode

#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

🚀 Day 66 of #LeetCode Challenge ✅ Problem Solved: Divide a String Into Groups of Size K 💡 What I learned today: • Learned how to break a string into fixed-size groups • Understood how to handle incomplete groups using a fill character • Practiced building strings step-by-step using loops • Improved clarity on index handling and conditions 🧠 Approach: • Traverse the string one character at a time • Build a group until it reaches size k • Store the group and reset • If the last group is smaller, fill remaining positions with the given character 📊 Key Takeaway: Handling edge cases (like incomplete groups) is very important in problem solving 🔥 Consistency is the key — improving step by step every day! #Day66 #LeetCode #CodingJourney #DSA #Java #ProblemSolving #Consistency

🚀 #60DaysOfLeetCode – Day 32 Today’s problem was about removing all adjacent duplicates in a string. 🔹 Approach Used: Stack To efficiently handle consecutive duplicates, I used a stack-based approach: Traverse the string character by character. If the stack is not empty and the top element matches the current character, pop it (this removes the duplicate pair). Otherwise, push the current character onto the stack. Finally, build the result string from the stack and reverse it to maintain the correct order. 🔹 Key Learning: Using a stack helps simulate the process of removing adjacent duplicates in a single pass, achieving O(n) time complexity and avoiding unnecessary reprocessing. This problem highlights how stacks are powerful for handling sequential patterns and cancellations, especially in string manipulation problems. On to Day 33! 💻🔥 #LeetCode #DSA #Java #CodingChallenge #ProblemSolving #LearningInPublic #60DaysOfCode

🚀 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

One interesting thing I’ve noticed while doing #100DaysOfCode and solving problems on LeetCode: At first, every problem looks completely different. But after solving a few, you start realizing many of them are built on the same core patterns: • Binary Search • Two Pointers • Sliding Window • Greedy • Hashing The real challenge isn’t just coding the solution — it’s recognizing the pattern quickly. Once the pattern clicks, the problem suddenly becomes much easier. Curious to know from other developers here 👇 Which LeetCode problem or concept made an algorithmic pattern “click” for you? #100DaysOfCode #LeetCode #DSA #Algorithms #CodingJourney #ProblemSolving #Java #SoftwareEngineering #TechLearning

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 48 of My 90-Day Coding Challenge Today I solved Merge Intervals, and this one was tricky until I truly visualized what was happening. At first, the logic didn’t click. But once I started thinking in terms of interval overlap on a number line, everything became much clearer. Key concepts I learned today: • Sorting based on starting index using a comparator • Understanding how sorting simplifies complex problems • Merging intervals by tracking the current start and end range The biggest realization: Without sorting, this problem is messy. With sorting, it becomes structured and manageable. Also got hands-on with: • Writing a custom comparator • Using Arrays.sort() effectively for 2D arrays Key takeaway: Some problems feel hard not because of logic, but because you’re not visualizing them correctly. Once the visualization is clear, the solution becomes almost obvious. #90DaysOfCode #DSA #Java #LeetCode #Sorting #ProblemSolving

🚀 Day 16/100 Days of Code Challenge Solved the classic “Sort Colors” problem (LeetCode 75) today! 🎯 🔹 Problem Summary: Given an array containing 0s, 1s, and 2s (representing colors), sort them in-place without using built-in sort. 🔹 Approach Used: Maintained three pointers: low, mid, high Efficiently partitioned the array in a single pass 🔹 Key Learning: ✔️ In-place sorting can be done in O(n) time ✔️ Using pointers smartly avoids extra space 💡 Time Complexity: O(n) 💡 Space Complexity: O(1) 🔹 Code Highlight : Used swapping and pointer movement to organize elements in one traversal. Consistency is the key 🔑 — one step closer to mastering DSA! #Day16 #100DaysOfCode #DSA #Java #CodingChallenge #LeetCode #ProblemSolving #TechJourney