Longest Palindromic Substring LeetCode Challenge

🚀 Day 16/60 — LeetCode Discipline Problem Solved: Palindrome Number (Revision) Difficulty: Easy Today’s practice revisited a classic number-based problem — determining whether a given integer reads the same forward and backward. Even though the problem appears simple, it reinforces an important concept: recognizing symmetry in data and applying straightforward transformations to verify it efficiently. In this revision, the focus was on converting the integer into a comparable structure and checking whether the reversed representation matches the original value. 💡 Focus Areas: • Reinforced palindrome symmetry concepts • Practiced number-to-string transformations • Strengthened basic logical validation techniques • Focused on writing clear and readable code Consistent practice of even the simplest problems helps keep fundamental logic sharp and reliable. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #Algorithms #ProblemSolving #Programming #CodingJourney #SoftwareEngineering #Developers #TechCareers

🚀 Day 14/60 — LeetCode Discipline Problem Solved: Maximum Number of Vowels in a Substring of Given Length (Revision) Difficulty: Medium Today’s practice revisited another elegant application of the sliding window technique. The task was to determine the maximum number of vowels present in any substring of fixed length k. Instead of recalculating the count for every possible substring, the sliding window approach allows the window to move forward while updating the vowel count efficiently. This pattern once again highlights how maintaining a running state can transform a brute-force idea into a clean and optimal solution. 💡 Focus Areas: • Strengthened fixed-size sliding window intuition • Practiced efficient character counting • Improved substring traversal logic • Reinforced constant-time window updates • Focused on writing clean and readable code ⚡ Performance Highlight: Achieved solid runtime efficiency on submission. Each day of deliberate practice adds another layer of clarity to fundamental algorithmic patterns. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #SlidingWindow #Strings #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers

Day 48 on LeetCode Minimum Size Subarray Sum 🎯✅ Today’s problem was a perfect application of the Sliding Window technique for optimizing subarray problems. 🔹 Approach Used in My Solution The goal was to find the smallest subarray length whose sum is greater than or equal to the target. Key idea in the solution: • Use two pointers low and high to maintain a dynamic window • Expand the window by moving high and adding elements to currentSum • Once the sum becomes ≥ target, start shrinking the window from the left (low) • Continuously update the minimum length during this process • If no valid subarray is found, return 0 This approach avoids brute force and ensures we process each element at most twice. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Mastered the Sliding Window technique for variable window size • Learned how to optimize subarray problems from O(n²) to O(n) • Reinforced handling dynamic window expansion and contraction #LeetCode #DSA #Algorithms #DataStructures #SlidingWindow #Arrays #TwoPointers #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 15/60 — LeetCode Discipline Problem Solved: Longest Repeating Character Replacement (Revision) Difficulty: Medium Today’s session revisited a classic sliding window problem that focuses on maximizing a repeating character substring after performing at most k replacements. The challenge here is not just scanning the string, but intelligently maintaining a window where the number of characters that need replacement stays within the allowed limit. By tracking character frequencies and dynamically adjusting the window, the solution efficiently finds the longest valid substring. Problems like this beautifully demonstrate how combining frequency counting with sliding window logic can turn a brute-force approach into a clean linear-time solution. 💡 Focus Areas: • Strengthened variable-size sliding window technique • Practiced frequency array optimization • Improved window shrink/expand decision logic • Reinforced substring pattern recognition • Focused on writing efficient and readable code ⚡ Performance Highlight: Achieved ~89% runtime efficiency on submission. Each day of deliberate practice is sharpening my understanding of algorithmic patterns and strengthening problem-solving intuition. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #SlidingWindow #Strings #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers

Day 51 on LeetCode — Permutation in String 🔤✅ Today’s problem was a strong application of the Sliding Window + Frequency Count technique. 🔹 Approach Used in My Solution The goal was to check if any permutation of s1 exists as a substring in s2. Key idea in the solution: • Use two frequency arrays (size 26) to track character counts • Initialize frequencies for s1 and the first window of s2 • Compare both frequency arrays — if equal, permutation exists • Slide the window across s2:   – Add incoming character   – Remove outgoing character • Check for a match at each step This ensures we efficiently check all substrings of size k without recomputing frequencies. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Mastered sliding window with fixed-size frequency arrays • Learned how to efficiently detect anagram/permutation patterns • Reinforced optimizing from brute force to linear-time solutions #LeetCode #DSA #Algorithms #DataStructures #SlidingWindow #Strings #Hashing #FrequencyArray #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 11/60 — LeetCode Discipline Problem Solved: Maximum Average Subarray I (Revision) Difficulty: Easy Today’s practice was centered around reinforcing the sliding window technique to efficiently compute the maximum average of a fixed-length subarray. Instead of recalculating sums repeatedly, the focus was on maintaining a running window sum and updating it optimally while traversing the array. Revisiting this pattern continues to strengthen my intuition for window-based optimizations. 💡 Focus Areas: • Strengthened fixed-size sliding window technique • Improved running sum optimization • Practiced constant-time window updates • Enhanced understanding of time–space efficiency • Focused on clean and readable implementation ⚡ Performance Highlight: Achieved ~83% runtime efficiency on submission. Consistent practice of fundamental patterns is steadily improving both speed and clarity in problem-solving. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #SlidingWindow #Arrays #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #TechCareers #Programming #Developers #CodingLife

Day 50 on LeetCode — Maximum Average Subarray I 📊✅ Half-century milestone! 🚀 Today’s problem was a classic and clean application of the Sliding Window technique. 🔹 Approach Used in My Solution The goal was to find the maximum average of a subarray of size k. Key idea in the solution: • First, compute the sum of the first window of size k • Then slide the window forward by:   – Adding the next element   – Removing the element leaving the window • Continuously update the maximum sum encountered • Finally, divide the maximum sum by k to get the result This avoids recomputing sums and ensures an efficient solution. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Mastered the fixed-size sliding window pattern • Learned how to optimize subarray sum problems • Reinforced thinking in terms of window reuse instead of recomputation #LeetCode #DSA #Algorithms #DataStructures #SlidingWindow #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Day 42 on LeetCode — Merge Sorted Array (Two Pointer Approach) ✅ Today’s problem focused on efficient in-place array manipulation using the two-pointer technique. 🔹 Approach Used in My Solution The key insight was to compare elements from the back of both arrays instead of the front. Since nums1 already has extra space at the end to accommodate elements from nums2, we can fill the array from the last index backwards. Key points in the logic: • Initialize pointers at the end of the valid elements of nums1 and nums2 • Compare the elements and place the larger one at the back of nums1 • Move the pointers accordingly until all elements are merged • This allows the final sorted array to be stored directly in nums1 This strategy avoids unnecessary shifting of elements and keeps the solution efficient. ⚡ Complexity: • Time Complexity: O(m + n) • Space Complexity: O(1) (in-place merge) 💡 Key Takeaways: • Learned how working from the back can simplify in-place merges • Strengthened understanding of the two-pointer technique • Practiced optimizing array operations without using extra space #LeetCode #DSA #Algorithms #DataStructures #TwoPointers #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Day 55 on LeetCode — Subarray Product Less Than K 📈✅ Today’s problem was a powerful application of the Sliding Window technique with multiplication-based constraints. 🔹 Approach Used in My Solution The goal was to count the number of contiguous subarrays where the product is less than k. Key idea in the solution: • Use two pointers l and r to maintain a dynamic window • Expand the window by multiplying the current element with prod • If prod ≥ k, shrink the window from the left by dividing elements • At each step, add (r - l + 1) to the count — representing all valid subarrays ending at r Also handled an important edge case: • If k ≤ 1, no valid subarray exists This approach ensures every element is processed efficiently without recomputation. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Strengthened understanding of sliding window with multiplicative conditions • Learned how to count subarrays efficiently using window size • Reinforced handling edge cases early for cleaner logic #LeetCode #DSA #Algorithms #DataStructures #SlidingWindow #TwoPointers #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Day 52 on LeetCode — Minimum Recolors to Get K Consecutive Black Blocks 🧩✅ Today’s problem was another clean application of the Sliding Window technique with optimization. 🔹 Approach Used in My Solution The goal was to find the minimum number of recolors (W → B) needed to get k consecutive black blocks. Key idea in the solution: • Treat it as finding a window of size k with minimum 'W' (white blocks) • Count the number of 'W' in the first window of size k • Slide the window across the string:   – Remove the left character (if it was 'W')   – Add the new right character (if it is 'W') • Keep track of the minimum changes required This avoids recomputation and ensures an efficient linear solution. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Strengthened understanding of fixed-size sliding window problems • Learned how to convert problems into min/max count in a window • Reinforced optimizing from brute force to O(n) solutions #LeetCode #DSA #Algorithms #DataStructures #SlidingWindow #Strings #TwoPointers #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney