Solving Chocolate Distribution Problem with Sorting and Sliding Window

🚀 Problem Solved: Pow(x, n) – Fast Exponentiation Today I worked on LeetCode 50 (Medium) — implementing pow(x, n) efficiently. Instead of using the naive O(n) multiplication approach, I applied Binary Exponentiation (Fast Power Algorithm) to reduce the time complexity to O(log n). 🔎 Key Learnings: Handling negative powers correctly Preventing integer overflow (using long for edge cases) Understanding how dividing the exponent by 2 optimizes performance Applying mathematical logic in coding interviews Example: 2¹⁰ → 1024 2⁻² → 0.25 This problem was a great reminder that optimization isn’t optional — it’s essential. Slowly building strong fundamentals, one problem at a time. 💻✨ #LeetCode #ProblemSolving #Java #DataStructures #Algorithms #CodingJourney #InterviewPrep #BinaryExponentiation

We've been looking this week at using a Two-Pointer pattern to merge sorted lists (not linked lists) in place. This works fine, as the first YouTube video showed, but there is a "hidden" performance issue. It looks like an O(M + N) solution, but every insertion in an in-place merge forces every subsequent element to shift to the right. That's actually O(M * (M + N)). Try rewriting this as a "reverse merge." By filling the destination list from back to front, you eliminate memory shifting. 💡 Why this wins the interview: * It shows you understand how lists and dynamic arrays handle insertions. * You reduce time complexity to true O(M + N) efficiency. #SoftwareEngineering #Java #CodingInterview #Algorithms #LeetCode #TechInterview #Optimization #TwoPointerPattern

𝗗𝗮𝘆 𝟱𝟳/𝟭𝟬𝟬 — 𝗪𝗵𝗲𝗻 𝗦𝘁𝗮𝗰𝗸𝘀 𝗚𝗲𝘁 𝗚𝗿𝗲𝗲𝗱𝘆 Yesterday: Valid Parentheses. Basic stack. Today: Remove Duplicate Letters. Stack + greedy + frequency tracking. Level up. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ #𝟯𝟭𝟲: Remove Duplicate Letters (Medium) 𝗧𝗵𝗲 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲: Remove duplicate letters so the result is: Smallest in lexicographical order (dictionary order) Contains each letter exactly once Example: "bcabc" → "abc" The trick? Knowing when to remove a character from the stack to make room for a better one. 𝗠𝘆 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: Monotonic stack + greedy decisions. 👉 Track frequency: how many times each character appears ahead 👉 Track visited: have we already used this character? 👉 For each character, pop stack if: Stack top is larger (worse for lexicographical order) Stack top appears again later (we can use it then) 👉 Push current character and mark visited Time: O(n), Space: O(1) — only 26 letters max. 𝗪𝗵𝗮𝘁 𝗖𝗹𝗶𝗰𝗸𝗲𝗱: This combines three patterns: Monotonic stack (maintaining order) Greedy algorithm (making locally optimal choices) Frequency tracking (knowing what's ahead) Solving it wasn't about knowing one technique. It was about combining them. 𝗖𝗼𝗱𝗲: https://lnkd.in/gzw6ACFr 57 down. 43 to go. 𝗗𝗮𝘆 𝟱𝟳/𝟭𝟬𝟬 ✅ #100DaysOfCode #LeetCode #Stack #MonotonicStack #GreedyAlgorithm #DataStructures #Algorithms #CodingInterview #Programming #Java #MediumLevel #PatternCombination

Most developers first see two pointers as just an interview trick. It is not. It is one of the simplest ways to make brute-force logic become efficient thinking. In this PDF, I broke down the Two Pointer Approach from the ground up: how it works why it works where to use it how to debug it what happens at a low level and why this technique shows up again and again in real problem solving What makes two pointers powerful is not just speed. It teaches you how to control a search space intelligently instead of checking everything blindly. That is a skill far bigger than one algorithm. Once you understand the pattern, you start seeing it in: sorted array problems pair matching duplicate removal palindrome checks sliding comparisons partition-style logic and many real-world data scanning tasks The biggest mistake many developers make is memorizing the code without understanding why each pointer moves. That is exactly where confusion starts. So I wanted this post to explain the intuition first, then the mechanics, then the practical usage. Which problem made you truly understand two pointers for the first time? #Java #DataStructures #Algorithms #TwoPointers #ProblemSolving #SoftwareEngineering #CodingInterview #Programming #DeveloperLearning #deutch

#Short and #Crisp 🧠 Idle brain creates overthinking. Busy brain creates growth. Sorting a 2-digit array? Easy. Done it many times. ✔️ But what if I ask you to sort it based on the last digit only? 🤔 Now we’re talking logic. 🧠 This is where the beauty of Java kicks in. 💡 Comparator Interface — Because smart developers don’t just sort… They define how to sort. import java.util.*; public class SortByLastDigit { public static void main(String[] args) { Integer[] arr = {23, 45, 12, 34, 56, 78, 91}; Comparator<Integer> comparator = new Comparator<Integer>() { @Override public int compare(Integer a, Integer b) { return (a % 10) - (b % 10); // compare last digits } }; Arrays.sort(arr, comparator); System.out.println(Arrays.toString(arr)); } } Sorting is done based on last digit difference. If result is: Negative → a comes before b Positive → b comes before a Zero → both considered equal 👉 “Comparator is used when we want custom sorting logic.” #Java #Puzzles #BusyBrain #LearnDaily #Productive #JavaAutomation

🚀 DSA Daily Challenge – Day 7 🧠 Problem: Remove Element (LeetCode 27) 💡 Problem Statement: Given an integer array nums and an integer val, remove all occurrences of val in-place and return the number of remaining elements. ⚠️ You must modify the array in-place with O(1) extra space. 🔥 Intuition Brute force idea: Create a new array and copy elements ≠ val ❌ But the problem requires in-place modification. So how do we solve it efficiently? 👉 Use the Two Pointer Technique 🛠 Approach (Two Pointers – In Place) • Use one pointer i to traverse the array • Use another pointer index to track where the next valid element should go • If nums[i] != val → copy it to nums[index] • Increment index At the end, index represents the new length. ⚙️ Complexity ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 👉 Think Two Pointers + Overwriting Pattern This pattern is very common in coding interviews 🔥 #LeetCode #LeetCode27 #RemoveElement #DSA #DataStructures #Algorithms #CodingInterview #InterviewPreparation #Java #TwoPointers #ArrayProblems #InPlaceAlgorithm #TimeComplexity #BigO #CompetitiveProgramming #FAANGPrep #100DaysOfCode

Day 15/100 of DSA , (Arrays) 🚀 Today I Solved" Sort Colors "using the Dutch National Flag Algorithm in Java Instead of using built-in sorting, I implemented the optimal three-pointer approach (low, mid, high) to sort the array in a single pass. 🔹 Time Complexity: O(n) 🔹 Space Complexity: O(1) 🔹 In-place modification (No extra space used) 🔹 Single traversal solution This problem reinforced an important lesson — not every sorting problem requires a traditional sort. Sometimes understanding pointer movement and partition logic leads to a much more efficient solution. Key Takeaways: • Mastering two-pointer and three-pointer techniques is crucial for DSA interviews • Clean logic > brute force • Writing structured, readable code prevents silly compilation mistakes Step by step improvement. Consistency over shortcuts. #Java #DSA #LeetCode #CodingPractice #ProblemSolving #WomenInTech #100DaysOfCode

🔥 Day 322 – Daily DSA Challenge! 🔥 Problem: 🧠 Maximum Product of Word Lengths Given a string array words, return the maximum value of length(word[i]) * length(word[j]) such that the two words do not share common letters. 💡 Key Insights: 🔹 Comparing characters directly would cost O(n² × L) — too slow. 🔹 Instead, use bit manipulation to represent each word. 🔹 Each word gets a 26-bit mask: Bit 0 → 'a' Bit 1 → 'b' ... Bit 25 → 'z' 🔹 If (mask[i] & mask[j]) == 0, the two words share no common letters. 🔹 This reduces character comparison to a single bitwise operation ⚡ ⚡ Optimized Plan: ✅ For each word: Build its bitmask Store its length ✅ Compare every pair: If masks AND to zero → update max product ✅ Return the maximum found ✅ Time Complexity: O(n²) (Bitmask creation is linear per word, pair check is constant time) ✅ Space Complexity: O(n) 💬 Challenge for you: 1️⃣ How would you optimize further for very large n? 2️⃣ Can this approach work if words contain uppercase letters too? 3️⃣ What if the alphabet size was larger than 32 characters? #DSA #Day322 #LeetCode #BitManipulation #Optimization #Strings #Java #ProblemSolving #KeepCoding #100DaysOfCode

My Structured DSA Preparation Roadmap – 26 Coding Patterns Instead of solving random problems, I started focusing on patterns. I Use this structured cheat sheet covering: • Two Pointers • Fast & Slow Pointers • Sliding Window • Prefix Sum • Binary Search • Merge Intervals • Cyclic Sort • Linked List Reversal • Stack & HashMap • Heap Pattern • Graph (BFS) • DP (0/1 Knapsack) • Backtracking • Trie • Union Find …and many more. Each pattern includes curated LeetCode & GFG problems from easy → hard. Goal: Build strong problem-solving skills through pattern recognition instead of memorizing solutions. Consistency > Motivation. If you're preparing for placements or interviews, this structured approach helps a lot. #DSA #CodingInterview #LeetCode #Java #ProblemSolving #SoftwareEngineer

🚀 Day 18/30 – Recognizing Patterns in a Single Pass Today’s problem was about finding the longest mountain in an array — a subarray that strictly increases and then strictly decreases. The real challenge was not just identifying the pattern, but doing it efficiently in one traversal. 💡 Approach Skip flat and decreasing sequences Detect the start of an increasing slope Count the upward climb Count the downward descent Update the maximum length only when both exist This ensures: ⏱ O(n) time complexity 📦 O(1) space complexity 📊 Performance ✅ All test cases passed ⚡ 2 ms runtime (Beats 99.57%) 💾 Efficient memory usage 📚 Key Takeaway This problem improved my ability to: Break complex patterns into simple state transitions Think in terms of phases (uphill → downhill) Solve without extra arrays or nested loops The biggest learning today: 👉 Many array problems are about state management during traversal, not brute force. 🎯 Day 18 complete. Each day is making pattern recognition faster and more intuitive — which is critical for coding interviews. #Day18 #30DaysOfCode #LeetCode #Java #Algorithms #ArrayProblems #ProblemSolving #InterviewPreparation #SoftwareEngineering #CodingJourney #Consistency #TechGrowth