Longest Repeating Subsequence Problem in Dynamic Programming

🚀 Day56 🚀 DSA Problem Solved: Maximum Balanced Binary Substrings 💡 Problem Statement Given a binary string, split it into the maximum number of consecutive substrings such that each substring contains an equal number of 0s and 1s. If it's not possible, return -1. 🔍 Example Input: "0100110101" ✅ Explanation: Balanced substrings → 01 | 0011 | 01 | 01 🧠 Approach (Greedy + Counting) Instead of generating all substrings (which is inefficient ❌), we use a smart greedy strategy: ✔ Traverse the string once ✔ Count number of 0s and 1s ✔ Whenever both counts become equal → we found a balanced substring ✔ Increase count and continue ⚠️ Final check: If total 0s ≠ total 1s → return -1 ⚡ Key Insight Every time count(0) == count(1), we can safely split the string there to maximize the number of substrings. ⏱️ Complexity Time: O(N) Space: O(1) ✨ Pro Tip This pattern is very similar to problems involving: Balanced parentheses Equal partitioning Prefix counting techniques 🔥 Consistency > Complexity Solving problems like this daily sharpens your problem-solving mindset for real-world systems and interviews. #DSA #Java #CodingInterview #ProblemSolving #100DaysOfCode #LearnToCode #TechCareers #Developers #CodingJourney

🚀 From Confusion to Clarity: Day 69 of My DSA Journey Today’s focus was on strengthening core problem-solving patterns and improving implementation clarity. 🔹 Solved and revised key problems across: HashMap, Sliding Window, Prefix Sum, and Kadane’s Algorithm Strengthened understanding of pattern recognition and when to apply them 🔹 Deep Dive: Reverse Linked List (LeetCode 206) Instead of memorizing, I focused on understanding pointer manipulation: ✔️ Learned the importance of storing the next node before breaking links ✔️ Understood how incorrect pointer updates can break the entire structure ✔️ Improved ability to debug and refine my approach step-by-step 💡 Key Insight: Writing code is not enough — understanding why it works is what builds real problem-solving skills. 📈 Progress Mindset: First attempt → Mistakes Debugging → Learning Final solution → Clarity Consistently focusing on patterns + clean implementation + explanation skills to prepare for real interview scenarios. #DSA #LeetCode #Java #ProblemSolving #CodingJourney #SoftwareEngineering #InterviewPreparation

Day 1 of becoming DSA consistent (no excuses) Problem name : Minimum Distance Between Three Equal Elements II Difficulty : Medium Topic : Hash Table Most people would brute-force this problem… but there’s a smarter way using grouping. 🧠 Approach : 👉 Instead of comparing all triplets (which is slow), we optimize using a HashMap. Step 1: Store indices Traverse the array For each number, store all its indices in a map number → list of positions Step 2: Filter useful candidates Only consider numbers that appear at least 3 times Others cannot form a valid triplet Step 3: Check consecutive triplets For each list of indices: Pick 3 consecutive indices → (i, i+1, i+2) Since indices are sorted, this ensures minimum distance. Step 4: Compute distance, Distance is calculated between the 3 positions. Simplifies to: 2 × (last index − first index); Step 5: Track minimum. Keep updating the smallest distance found. If no valid triplet → return -1; Key Learning : When dealing with repeated elements: Use HashMap for grouping, Work on indices instead of values, Look for patterns (like consecutive grouping) to reduce complexity. IF YOU GUYS USED DIFFERENT LOGIC , Drop your logic below 👇... #leetcode #dsa #coding #softwareengineering #programming #interviewprep #java #grow #innovation #LetsConnect

🚀 Day 23 of My DSA Journey – Clean & Efficient Deduplication Today I solved a classic and very important problem: 👉 Remove Duplicates from Sorted Array 🔍 Problem Understanding Given a sorted array, we need to remove duplicates in-place such that each element appears only once and return the new length. ⚠️ Constraints: No extra space allowed Maintain relative order 🧠 Brute Force Approach Use a Set or ArrayList to store unique elements Copy back to array ❌ Not optimal due to O(n) extra space ⚡ Optimized Approach (Two Pointer Technique) 💡 Key Idea: Since the array is sorted, duplicates are adjacent. We can maintain a pointer j to track the position of unique elements. 🪜 Steps Initialize j = 0 Traverse array using i If nums[j] != nums[i] Increment j Assign nums[j] = nums[i] Return j + 1 🧪 Example Walkthrough Input: [0,0,1,1,1,2,2,3,3,4] Process: Keep only unique elements Final array: [0,1,2,3,4] Output: 5 ⏱️ Complexity Analysis Time Complexity: O(n) Space Complexity: O(1) ✅ 💡 Key Learning Sorted arrays simplify many problems Two-pointer approach is 🔑 for in-place operations Writing clean and minimal code matters in interviews 🙏 Gratitude Consistency is paying off. Small daily wins are building strong fundamentals 💪 📈 Consistency Note Discipline > Motivation. Showing up daily 🚀 #DSA #LeetCode #Java #CodingJourney #100DaysOfCode #ProblemSolving #TechJourney #InterviewPreparation

🚀 Day 68/100 – DSA Challenge Consistency builds confidence 💯 Today’s problem focused on mirror distance of a number. 🔍 Problem: Given an integer, reverse its digits and find the absolute difference between the original number and its reversed form. 🧠 Approach: The idea is simple but powerful — extract digits one by one, build the reversed number, and compute the difference. 💡 Key Learning: Problems like this strengthen core concepts of number manipulation and logical thinking, which are essential for cracking interviews. Every small step is adding up. On to Day 69 🚀 #100DaysOfCode #DSA #Java #CodingJourney #Consistency #ProblemSolving #KeepLearning

Day 89/100 – DSA + Project Revision 🚀 Today was all about strengthening fundamentals that actually get asked in interviews. 🔁 Revised: Slow & Fast Pointer (Linked List Pattern) This pattern looks simple but is extremely powerful. Used in: • Finding middle of linked list • Detecting cycle (Floyd’s Algorithm) • Palindrome linked list • Reordering list 👉 Key learning: Instead of solving each problem differently, recognize the pattern and reuse logic. 💻 Project Revision: Socket Programming (Java Client) Revisited my client-side implementation: • Connected to server using Socket • Sent message using PrintWriter • Received response using BufferedReader 👉 Realization: Understanding how data flows between client and server is more important than just writing code. ⚡ Focus of the day: Consistency > Intensity Small improvements daily are building strong fundamentals. #Day89 #DSA #Java #LinkedList #CodingJourney #100DaysOfCode #PlacementPrep

🚀 𝐃𝐚𝐲 𝟐/ 𝟏𝟎𝟎 — 𝐋𝐞𝐧𝐠𝐭𝐡 𝐨𝐟 𝐋𝐚𝐬𝐭 𝐖𝐨𝐫𝐝 (𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝟓𝟖) Most people learn string manipulation by just chaining built-in methods. But today made one thing clear 👇 👉 Efficient parsing is about knowing exactly when to stop. 🧠 Today’s Breakthrough: From the "easy way" ➔ to optimized engineering thinking • Built-in .split() ➔ fast to write, but wastes memory on new arrays • Forward traversal ➔ works, but forces you to read the entire string • Backward traversal ➔ starts at the end, uses O(1) space • Early exit ➔ breaks the loop immediately, thinking like a pro Same result. Entirely different levels of performance. 💡 The core idea (Backward Parsing): 👉 Start at the end ➔ skip any trailing spaces 👉 Count characters ➔ track the length of the word 👉 Hit a space again ➔ break the loop immediately Simple rule. Massive impact. #DSA #Java #SoftwareEngineering #LeetCode #CodingJourney #InterviewPrep #LearnInPublic

🔥 DSA Challenge – Day 123/360 🚀 📌 Topic: Recursion 🧩 Problem: Generate Parentheses Problem Statement: Given n pairs of parentheses, generate all combinations of well-formed (valid) parentheses. 🔍 Example: Input: n = 3 Output: ["((()))","(()())","(())()","()(())","()()()"] 💡 Approach: Backtracking 1️⃣ Step 1 – Start with an empty string and track open (oc) and close (cc) brackets 2️⃣ Step 2 – Add "(" if oc < n (we still have opening brackets left) 3️⃣ Step 3 – Add ")" only if cc < oc (to maintain valid structure) 👉 This ensures we only generate valid combinations (no extra filtering needed) ⏱ Complexity: Time: O(2ⁿ) (Catalan growth) Space: O(n) recursion stack 📚 Key Learning: Backtracking works best when we avoid invalid choices early, instead of fixing them later. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #123DaysOfCode #LeetCode #Backtracking

🚀 Day 25 of My DSA Journey – Mastering In-Place Array Manipulation Today I solved an interesting problem on LeetCode: 👉 Remove Duplicates from Sorted Array II 🔍 Problem Understanding Given a sorted array, the goal is to remove duplicates in-place such that each element appears at most twice, and return the new length. ⚠️ Constraint: No extra space allowed Modify array in-place 🧠 Brute Force Approach Use extra space (like ArrayList) Track frequency and rebuild array ❌ Not optimal due to O(n) space complexity ⚡ Optimized Approach (Two Pointer Technique) 💡 Key Idea: Since array is sorted, duplicates are adjacent. We can compare current element with the element 2 steps back. 🪜 Steps Start pointer i = 2 (since first 2 elements are always valid) Traverse from j = 2 → n-1 Check: If nums[j] != nums[i-2] → valid element Place it at index i and increment i 🧾 Code Snippet (Java) class Solution { public int removeDuplicates(int[] nums) { int i = 2; for(int j = 2; j < nums.length; j++) { if(nums[j] != nums[i-2]) { nums[i] = nums[j]; i++; } } return i; } } 🧪 Example Walkthrough Input: [1,1,1,2,2,3] Process: Allow only 2 occurrences Final array becomes: [1,1,2,2,3] Output: 5 ⏱️ Complexity Analysis Time Complexity: O(n) Space Complexity: O(1) ✅ (In-place) 💡 Key Learning Sorted array → powerful advantage Two-pointer technique = must-know for interviews Comparing with i-2 is the trick 🔥 🙏 Gratitude Grateful for the consistency and learning curve. Every problem sharpens my logic a bit more! 📈 Consistency Note Showing up daily > being perfect occasionally 💯 #DSA #LeetCode #Java #CodingJourney #100DaysOfCode #SoftwareEngineering #ProblemSolving #InterviewPrep #TechLearning

🚀 Day 41 of #DSA ✅ Solved: Daily Temperatures (LeetCode 739) Today’s problem was about finding how many days we need to wait for a warmer temperature. 💡 Key Insight: Instead of checking every future day (which is slow), we use a Monotonic Stack to efficiently track unresolved days. This reduces complexity to O(n). ⚙️ Approach: - Store indices in a stack - If current temperature is higher → resolve previous indices - Calculate days difference and update result ⏱ Complexity: - Time → O(n) - Space → O(n) 📚 Key Learning: This problem is a classic example of Next Greater Element pattern using stacks — very important for coding interviews. Consistency is the key 🔑 #Day41 #LeetCode #Java #DSA #CodingJourney #ProblemSolving #100DaysOfCode #Tech