Optimizing with Flexibility: Longest Repeating Character Replacement

Day 35 :- The Ultimate Sliding Window Challenge: Minimum Window Substring ✅ Today’s DSA session was all about precision and optimization. I tackled the classic Minimum Window Substring, a problem often considered the "final boss" of the Sliding Window technique. It’s an incredible exercise in managing character frequencies while dynamically adjusting window boundaries. The Technical Highlights: The "Need" Frequency Array: Instead of using a heavy HashMap, I used a simple 128-size integer array to track required characters. This constant-time O(1) lookup is crucial for maintaining performance. Expansion & Contraction: The right pointer expands the window until it contains all characters of string t (the "desirable" state). The left pointer then aggressively contracts the window to find the smallest possible substring that still satisfies the condition. Optimal Counting: By using a count variable to track the number of characters currently satisfied, I avoided re-scanning the frequency array at every step. Efficiency: This algorithm processes each character at most twice, resulting in a sleek O(n) time complexity. Mastering this problem is a major milestone in understanding how two pointers can work in harmony to solve complex string constraints! 🚀 A huge thanks to my mentor, Anchal Sharma and Ikshit .. for the incredible support and for helping me stay consistent on this journey. Having that accountability makes all the difference! #DSA #Java #100DaysOfCode #SlidingWindow #TwoPointers #ProblemSolving #Mentorship #LeetCode #SoftwareEngineering #Strings

Day 26 of 30-day Coding Sprint 992. Subarrays with K Different Integers - The Problem: Count every single contiguous subarray that contains exactly k different integers. - The Challenge: A standard sliding window is "greedy"; it finds the largest or smallest window that fits a condition. But here, multiple windows of different sizes ending at the same index r could all have exactly k integers. Approach 1: Brute Force - Generating all subarrays and checking unique counts using a HashMap. - Complexity: O(n^2). This will TLE (Time Limit Exceeded) on any competitive platform with a large input. Approach 2: The "Exactly K" via "At Most K" Logic (Optimal) - The Strategy: Just like we did with binary sums on Day 21, we use the formula: Exactly(K) = AtMost(K) - AtMost(K-1) - The Helper: helper(nums, k) counts how many subarrays have at most $k$ distinct elements. - Why it works: Finding "at most" is easy with a sliding window: if map.size > k, we shrink from the left. The number of subarrays ending at r that satisfy "at most k" is simply (r - l + 1). - Complexity: O(n) time and O(k) space. #30DaysOfCode #DSASprint #LeetCode #JavaScript #SlidingWindow #HardProblem #Algorithms #Consistency

✳️Day 17 of #100DaysOfCode✳️ Solving the Longest Common Subsequence Problem! 🚀 I recently took on the "Longest Common Subsequence" (LCS) challenge on LeetCode—a classic problem that perfectly illustrates the power of Dynamic Programming. Here’s the step-by-step approach I took: ✅ 1. Problem Decomposition: I broke the problem down into smaller sub-problems. If the last characters of two strings match, they contribute to the subsequence; if not, we explore the possibilities by skipping a character from either string. ✅ 2. Recursive Foundation: I started by defining the base case—if either string is empty, the LCS length is 0. ✅ 3. Optimization with Memoization: Pure recursion leads to redundant calculations (overlapping sub-problems). I implemented a 2D array (dp[n][m]) to store results of previously computed states, significantly boosting performance. ✅ 4. Refinement: Fine-tuning the logic to ensure the time and space complexity were balanced for an efficient "Accepted" result . Always learning, always coding. On to the next challenge! 💻 #LeetCode #Java #DynamicProgramming #CodingLife #SoftwareEngineering #ProblemSolving

🚀 Day 526 of #750DaysOfCode 🚀 Today I solved LeetCode 3129 – Find All Possible Stable Binary Arrays I. 🔹 Problem Summary We are given three integers: zero, one, and limit. We need to count the number of binary arrays that: • Contain exactly zero number of 0s • Contain exactly one number of 1s • Do not allow more than limit consecutive identical elements In other words, every subarray longer than limit must contain both 0 and 1, preventing long runs of the same digit. 🔹 Approach I solved this using Dynamic Programming. Idea: Track how many zeros and ones are used. Maintain the last placed digit (0 or 1). Ensure the count of consecutive digits never exceeds the limit. Use DP states to count valid configurations and apply modulo (10^9 + 7) for large results. 🔹 Key Concepts Practiced Dynamic Programming State transitions Handling constraints with limit on consecutive elements Modular arithmetic 💡 Problems like this strengthen DP intuition and constraint handling, which are very common in coding interviews. Consistency continues… 🔥 #leetcode #dsa #dynamicprogramming #codingchallenge #softwareengineering #programming #developers #learninginpublic #techjourney #750daysofcode

🚀 Day 24 – LeetCode 1358 | Mastering Sliding Window for Substring Counting Solved LeetCode 1358: Number of Substrings Containing All Three Characters today. At first glance, this problem looks like a brute-force substring question. But checking every substring leads to O(n²) or O(n³) time, which is unacceptable for interviews. The correct approach is using the Sliding Window (Two Pointers) technique. Instead of generating all substrings: Expand the window Track counts of a, b, and c Once all three are present, count all valid substrings at once Shrink the window and repeat This reduces the complexity to O(n). Today’s focus: • Efficient substring counting • Two-pointer logic • Thinking in patterns instead of brute force Improving problem-solving skills one day at a time. #LeetCode #DSA #SlidingWindow #TwoPointers #Java #ProblemSolving #CodingInterview #SoftwareDeveloper #100DaysOfCode #TechGrowth

#PostLog130 🚀  𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝗼𝗹𝘃𝗲𝗱: 𝗠𝗮𝘅𝗶𝗺𝘂𝗺 𝗣𝗿𝗼𝗱𝘂𝗰𝘁 𝗦𝘂𝗯𝗮𝗿𝗿𝗮𝘆 (𝗟𝗲𝗲𝘁𝗖𝗼𝗱𝗲 𝟭𝟱𝟮) Solved Maximum Product Subarray, a classic problem that teaches an important lesson beyond coding: 🔹 Negative numbers can completely change the game. 🔹 Thinking only in one direction isn’t always enough. 🔹 Sometimes the best solution comes from viewing the problem from both ends. 💡 Key takeaway: Instead of relying only on a forward pass, using a left-to-right and right-to-left traversal helps handle negatives and zeros efficiently — resulting in an optimized O(n) solution. #LeetCode #DSA #Algorithms #Java #ProblemSolving #CodingJourney #SoftwareEngineering #LearningInPublic

Day 9 | Round 5 — 30 Days Coding Challenge 🚀 Today I solved the problem “Find K-th Bit in N-th Binary String.” 🔎 Problem (In Simple Words) We are given two numbers n and k. A binary string is built using this rule: S1 = "0" Si = S(i-1) + "1" + reverse(invert(S(i-1))) We need to find the k-th bit in the string Sn. 💡 Understanding the Pattern Each new string is built using three parts: Previous string The character "1" The reversed and inverted version of the previous string Invert means: Change 0 → 1 Change 1 → 0 So every level depends completely on the previous level. 🛠️ Approach I Used Start with base case: S1 = "0" For each level from 2 to n: Invert the previous string Reverse it Concatenate: previous + "1" + reversed inverted string Finally, return the (k-1) index from Sn This directly follows the pattern defined in the problem. ⚙️ Complexity Time Complexity: Exponential string growth (since length doubles each level) Space Complexity: Stores all generated strings This problem helped me understand: Recursive string construction patterns String manipulation (reverse + invert) How problems build on previously generated results Round 5 — Day 9 Completed ✅ Recognizing patterns in construction-based problems makes implementation much clearer. #30DaysOfCode #Round5 #Day9 #StringManipulation #RecursionPattern #DSA #ProblemSolving #LeetCode #CodingChallenge #CPlusPlus #DeveloperJourney #Consistency #CodeDaily #TechGrowth

🚀 Day 23 of Consistency – Solved a Hard Dynamic Programming Problem on LeetCode Today I solved “Find All Possible Stable Binary Arrays II”, a Hard level problem that required careful Dynamic Programming state design and constraint handling. The challenge was to count the number of binary arrays containing exactly zero zeros and one ones such that no more than limit identical elements appear consecutively, while returning the result modulo (10^9 + 7). 💡 Key learnings from this problem: • Designing a 3D Dynamic Programming state based on counts of 0s, 1s, and the last placed element • Handling constraints on consecutive elements efficiently • Using subtraction of overcounted states to avoid invalid sequences • Building transitions carefully to maintain the consecutive limit condition Problems like this really strengthen the ability to translate problem constraints into DP state transitions, which is a crucial skill for solving advanced algorithmic challenges. 🔗 Problem: https://lnkd.in/d5-rY-Cw 💻 My Solution: https://lnkd.in/dUsuSR-C Staying consistent with problem solving and learning something new every day. 📈 #Day23 #LeetCode #DSA #DynamicProgramming #CodingJourney #ProblemSolving #SoftwareEngineering #Consistency #LearningInPublic

🚀 Day 522 of #750DaysOfCode 🚀 Today I solved the LeetCode problem “Minimum Changes To Make Alternating Binary String.” 🔹 Problem: Given a binary string consisting of 0s and 1s, we need to make the string alternating (no two adjacent characters are the same). In one operation, we can flip any character (0 → 1 or 1 → 0). The goal is to find the minimum number of operations required. 🔹 Key Idea: An alternating string can only follow two possible patterns: 1️⃣ 010101... 2️⃣ 101010... So we: Count mismatches assuming the string starts with '0'. The other pattern mismatches will be n - mismatch. The minimum of these two values gives the answer. 🔹 Time Complexity: O(n) – we traverse the string once. 📌 Example Input: "1111" Possible alternating strings → "0101" or "1010" Minimum operations → 2 Problems like this highlight how pattern observation can simplify the solution. #leetcode #programming #coding #java #softwaredevelopment #dsa #problemSolving #750DaysOfCode

🚀 𝗠𝗼𝗱𝗲𝗿𝗻 𝗖++ 𝗙𝗲𝗮𝘁𝘂𝗿𝗲: 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱 𝗕𝗶𝗻𝗱𝗶𝗻𝗴𝘀 (C++17) One of the most elegant features introduced in Modern C++ is Structured Bindings. They allow you to unpack values from tuples, structs, arrays, and maps in a clean and expressive way. 💡 𝗧𝗵𝗶𝘀 𝗺𝗮𝗸𝗲𝘀 𝗖++ 𝗰𝗼𝗱𝗲 𝗺𝗼𝗿𝗲 𝗿𝗲𝗮𝗱𝗮𝗯𝗹𝗲 𝗮𝗻𝗱 𝗲𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝘃𝗲. ❌ 𝗕𝗲𝗳𝗼𝗿𝗲 (Verbose Style) std::pair<std::string, int> person = {"Alice", 30}; std::string name = person.first; int age = person.second; Problems 👇 ❌ Verbose code ❌ Harder to read ❌ Repeated object access ✅ 𝗠𝗼𝗱𝗲𝗿𝗻 𝗖++ 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 std::pair<std::string, int> person = {"Alice", 30}; auto [name, age] = person; Benefits 👇 ✔ Cleaner syntax ✔ More readable code ✔ Reduces boilerplate ✔ Improves developer productivity 📦 𝗪𝗼𝗿𝗸𝘀 𝗚𝗿𝗲𝗮𝘁 𝗪𝗶𝘁𝗵 𝗦𝗧𝗟 𝗖𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝘀 Example with std::map: for (const auto& [key, value] : myMap) { std::cout << key << " -> " << value << "\n"; } ✨ No .first ✨ No .second ✨ Just clean and expressive code. 🏆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆 Modern C++ is evolving toward expressive, readable, and safer code. 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱 𝗕𝗶𝗻𝗱𝗶𝗻𝗴𝘀 are a small feature that make a big difference in daily coding. #CPP #ModernCPP #SoftwareEngineering #CPP17 #Coding #CleanCode — 𝗔𝗕𝗛𝗜𝗦𝗛𝗘𝗞 𝗦𝗜𝗡𝗛𝗔