LeetCode Practice: Contains Duplicate II with Hashing and Sliding Window

🚀 Day 17/60 — LeetCode Discipline Problem Solved: 4Sum (Revision) Difficulty: Medium Today’s session revisited the classic k-Sum family problem — 4Sum. After solving 2Sum and 3Sum patterns previously, this problem naturally extends the idea by combining sorting with nested iteration and the two-pointer technique to efficiently identify unique quadruplets. The key challenge lies in managing duplicates carefully while keeping the solution efficient and structured. 💡 Focus Areas: • Strengthened k-Sum pattern understanding • Practiced sorting + two-pointer combination • Improved duplicate handling in multi-pointer problems • Reinforced nested iteration optimization • Focused on writing structured and readable code Problems like these highlight how mastering one pattern allows you to scale the same idea to more complex variations. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #TwoPointers #Arrays #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers

🚀 Day 181 of #200DaysOfCoding Today I solved “Minimum Changes To Make Alternating Binary String” on LeetCode. 🔹 Problem: We are given a binary string consisting of 0 and 1. In one operation, we can flip any character (0 → 1 or 1 → 0). The goal is to make the string alternating, meaning no two adjacent characters are the same. Example of alternating strings: 0101, 1010 🔹 Key Insight: An alternating binary string can only have two possible patterns: 1️⃣ 010101... 2️⃣ 101010... So the idea is simple: Count how many changes are needed to convert the string to pattern 1. Count how many changes are needed to convert it to pattern 2. The minimum of the two will be the answer. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) Consistent practice is helping me improve my problem-solving and pattern recognition skills every day. #leetcode #coding #programming #cpp #100daysofcode #200daysofcoding #softwaredevelopment

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 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 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 93 of #100DaysOfCode Challenge Today’s problem was all about identifying “Beautiful Strings” 🔢✨ A numeric string is called beautiful if: ✔️ It can be split into a sequence of increasing numbers ✔️ Each number is exactly +1 from the previous ✔️ No leading zeros allowed 💡 What I Learned Today: How to break strings into valid sequences Handling large numbers using long long Importance of string comparison vs integer operations Edge cases like: Leading zeros ❌ Single digit strings ❌ Invalid increments ❌ 🧠 Approach: Try all possible starting numbers Generate the sequence dynamically (x, x+1, x+2…) Match the built string with the original If matched → ✅ YES x Else → ❌ NO 💻 Example: 👉 Input: 91011 👉 Output: YES 9 ⚡ Key Takeaway: Sometimes brute force with smart validation is the best approach! 📅 Consistency is the real game changer. On to Day 94 💪 #Coding #Programming #CProgramming #DataStructures #ProblemSolving #100DaysOfCode #DeveloperJourney #LearningEveryday

#Day58 Solved: Longest Substring Without Repeating Characters(Leetcode 3) Worked on one of the most asked string problems that really tests problem-solving and optimization skills. Problem: Find the length of the longest substring without repeating characters. Approach: Used the sliding window technique to efficiently track a valid substring. Instead of checking all possible substrings (which is slow), I dynamically adjusted the window: Expanded when characters were unique Shrunk when a duplicate appeared Key Learning: The biggest takeaway was understanding how to maintain a valid window rather than restarting every time a duplicate is found. Complexity: Optimized the solution from O(n²) to O(n) using the right approach. This problem strengthened my understanding of: Sliding Window Two Pointer Technique Optimizing brute force solutions #leetcode #dsa #programming #coding #slidingwindow #problemSolving

🚀 Day 79 of My Coding Challenge Today I solved the Super Reduced String problem. The challenge was to repeatedly remove adjacent matching characters from a string until no such pairs remain. If the final string becomes empty, we return "Empty String". 💡 Key Idea: I used a stack-based approach to efficiently remove adjacent duplicates in O(n) time complexity. 📌 Example: Input: aaabccddd Output: abd Steps: aaabccddd → abccddd → abddd → abd 🧠 What I practiced today: Stack-based string processing Efficient character comparison Problem-solving with linear time complexity Consistency is the key — every day a little progress toward becoming a better developer. 💻🔥 #Day79 #CodingChallenge #LeetCode #Programming #ProblemSolving #DataStructures #100DaysOfCode #DeveloperJourney

Day 57 on LeetCode Longest Repeating Character Replacement 🔤✅ Today’s problem was a powerful application of the Sliding Window technique with frequency tracking. 🔹 Approach Used in My Solution The goal was to find the longest substring where we can replace at most k characters to make all characters the same. Key idea in the solution: • Use a frequency array (size 26) to track character counts in the current window • Maintain a variable maxFreq → the highest frequency character in the window • Expand the window using r • If (window size - maxFreq) > k, shrink the window from the left (l) • Continuously update the maximum valid window size This works because we only care about keeping the window valid with at most k replacements. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Mastered sliding window with dynamic constraints • Learned how tracking max frequency optimizes decisions • Strengthened understanding of window validation logic #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