Balanced Numbers with Digit DP in Java

💡#LeetCode Daily Challenge – Smart Optimization! Today I worked on a problem where we need to find the minimum distance between three equal elements in an array. At first, it looks like a brute-force problem, but the real trick is simplifying the formula.After observing carefully, the distance formula actually reduces to just twice the difference between the first and last indices. So the middle element doesn’t even matter! That insight helped me avoid unnecessary computations.I grouped indices of each number and checked only consecutive triples to get the minimum distance efficiently. This problem reminded me how powerful pattern recognition can be in coding. #LeetCode #ProblemSolving #DataStructures #Algorithms #CodingInterview #Java #Programming #CodingJourney #TechLearning #Developers #SoftwareEngineering

💡 𝗣𝗿𝗲𝗳𝗶𝘅 𝗦𝘂𝗺𝘀 + 𝗔 𝗦𝘂𝗯𝘁𝗹𝗲 𝗧𝘄𝗶𝘀𝘁 𝗼𝗻 “𝗗𝗶𝘀𝘁𝗶𝗻𝗰𝘁” — 𝗧𝗼𝗱𝗮𝘆’𝘀 𝗗𝗦𝗔 𝗜𝗻𝘀𝗶𝗴𝗵𝘁 Today’s problem looked familiar: count subarrays whose sum is divisible by 𝗸. But one word changed everything - 𝗱𝗶𝘀𝘁𝗶𝗻𝗰𝘁 (by value, not by index). 🧠 𝗧𝗵𝗲 𝗕𝗮𝘀𝗲 𝗜𝗱𝗲𝗮: 𝗣𝗿𝗲𝗳𝗶𝘅 𝗦𝘂𝗺 + 𝗠𝗼𝗱𝘂𝗹𝗼 A classic idea from Introduction to Algorithms: 1. If two prefix sums give the same remainder modulo k, 2. the subarray between them has a sum divisible by k. Using a hashmap of (sum % k) -> frequency, we can count such subarrays in O(n). Simple and elegant - but incomplete. ⚠️ 𝗧𝗵𝗲 𝗖𝗮𝘁𝗰𝗵: 𝗗𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗲 𝗩𝗮𝗹𝘂𝗲 𝗦𝗲𝗾𝘂𝗲𝗻𝗰𝗲𝘀 For an array like [1, 1, 1], subarrays such as [1] occur at multiple positions. They are different by index, but the same by value. Prefix sums will count all of them. We must count them only once. 💡 𝗧𝗵𝗲 𝗜𝗻𝘀𝗶𝗴𝗵𝘁 𝗧𝗵𝗮𝘁 𝗦𝗼𝗹𝘃𝗲𝘀 𝗜𝘁 Since the array is sorted, two subarrays that: 1. end at the same value, and 2. have the same (sum % k) must represent the same sequence. So we track such patterns using a key formed by: (sum % k) and the current value, and subtract these duplicates from the earlier total. ✨ 𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆 This problem wasn’t about finding valid subarrays - it was about removing overcounted ones cleverly. A great reminder that: Sometimes the trick lies in interpreting “𝗱𝗶𝘀𝘁𝗶𝗻𝗰𝘁” correctly. #DSA #Algorithms #PrefixSum #Hashing #Java #ProblemSolving #CompetitiveProgramming #CodingInterview #DataStructures #CodingLife #Programmer #Developers #TechInterview #LeetCode #CodeNewbie #100DaysOfCode #LearningInPublic #CodingJourney #InterviewPreparation

🚀 Day 10 of #100DaysOfDSA – Solved LeetCode 344: Reverse String Today’s problem was simple yet powerful — Reverse a String (in-place) 💡 🔹 Problem: Given a character array, reverse it without using extra space. 🔹 Approach: Used the Two Pointer Technique: 👉 Start one pointer from the beginning 👉 Another from the end 👉 Swap characters and move inward 🔹 Key Learning: In-place operations improve space efficiency Two-pointer approach is a must-know pattern for interviews 🔹 Time Complexity: O(n) 🔹 Space Complexity: O(1) 💻 Code Insight: Swapping elements until both pointers meet does the job efficiently! ✨ Small problems like this build strong fundamentals for bigger challenges. #DSA #Java #Coding #LeetCode #Programming #SoftwareEngineering #InterviewPrep #100DaysOfCode

“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

🚀 Day 23 of #50DaysOfCode Solved Daily Temperatures (LeetCode 739) 🌡️ Today’s focus was on mastering the Monotonic Stack concept — one of the most powerful patterns in DSA. Learned how to efficiently find the next greater element by storing indices and resolving them smartly instead of brute force. 💡 Key Learnings: • Stack helps reduce time complexity from O(n²) → O(n) • Always think in terms of “pending answers” • Monotonic stacks are 🔥 for interview questions ✅ Status: Accepted ✔️ ⏱️ Optimized approach implemented Every day getting better at problem-solving and consistency 💪 #DSA #LeetCode #Java #CodingJourney #Consistency #100DaysOfCode #Programming

What if a function could call itself to solve a problem? That’s exactly what Recursion is. In this short video, I explained: - What is recursion - Base case (stops execution) - Recursive case (reduces problem size) - Factorial example - Importance of call stack Recursion is widely used in solving complex problems like trees, graphs, and divide-and-conquer algorithms. Explore structured DSA in Java roadmap + practice: www.quipoin.com #DSA #Java #Programming #Coding #SoftwareEngineering #Recursion #InterviewPreparation

#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

🚀 Day 558 of #750DaysOfCode 🚀 🔍 LeetCode 3740: Minimum Distance Between Three Equal Elements I Today’s problem looked simple at first, but had a neat mathematical twist hidden inside 👀 💡 Problem Insight: We need to find three indices (i, j, k) such that: nums[i] == nums[j] == nums[k] Minimize distance = |i - j| + |j - k| + |k - i| ✨ The key realization: 👉 This formula simplifies to 2 × (k - i) when i < j < k So instead of checking all combinations, we: ✔ Group indices of each number ✔ Look at every consecutive triplet ✔ Minimize (k - i) ⚡ Approach: Store indices using HashMap For each number with ≥ 3 occurrences: Check sliding window of size 3 Compute distance efficiently 🧠 Learning: Sometimes brute-force isn’t the problem — recognizing a mathematical simplification is the real game changer. 📈 Complexity: Time: O(n²) worst case Space: O(n) 💬 Takeaway: Always try to simplify formulas — it can turn a hard-looking problem into an easy one. #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Tech #Programming #100DaysOfCode #Developers

🚀 Code 6 – #50LeetCodeChallenge 🧩 Problem: Search Insert Position Given a sorted array of distinct integers and a target value, return its index if found. If not, return the position where it should be inserted to maintain sorted order. 💡 Approach: Use Binary Search to efficiently locate the target or its correct insertion position in O(log n) time. 📚 Key Takeaway: Binary search is the go-to technique for problems involving sorted arrays, especially when optimal time complexity is required. #LeetCode #Java #Coding #ProblemSolving #BinarySearch #Arrays #Programming

🚀 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