Mastering 4Sum with LeetCode Discipline

🚀 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 65 on LeetCode Sort Characters By Frequency 🔤📊✅ Today’s problem focused on combining hash maps with custom sorting. 🔹 Approach Used in My Solution The goal was to sort characters in a string based on their frequency in descending order. Key idea in the solution: • Use a hash map to count frequency of each character • Store (character, frequency) pairs in a vector • Apply custom sorting based on frequency (descending order) • Build the result string by repeating characters according to their frequency This approach efficiently organizes characters by importance (frequency). ⚡ Complexity: • Time Complexity: O(n log n) (due to sorting) • Space Complexity: O(n) 💡 Key Takeaways: • Practiced frequency counting using hash maps • Learned how to apply custom comparators in sorting • Reinforced building results based on frequency-driven logic #LeetCode #DSA #Algorithms #DataStructures #HashMap #Sorting #Strings #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

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 47 on LeetCode — Partition Labels ✂️✅ Today’s problem was a great example of greedy strategy with smart indexing. 🔹 Approach Used in My Solution The goal was to split the string into maximum number of partitions such that each character appears in only one part. Key idea in the solution: • First, store the last occurrence of each character in an array • Traverse the string while maintaining a current partition range • Continuously update the end of the partition using the last index of characters encountered • When the current index reaches end, it means the partition is complete • Store the partition size and start a new one This greedy approach ensures each partition is as small as possible while still valid. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Learned how preprocessing (last occurrence tracking) simplifies problems • Practiced greedy partitioning techniques • Strengthened understanding of interval expansion logic #LeetCode #DSA #Algorithms #DataStructures #GreedyAlgorithm #Strings #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Day 38 on LeetCode — Brick Wall ✅ Today’s challenge focused on prefix sums and hash maps to minimize edge crossings. 🔹 Brick Wall The goal was to draw a vertical line that crosses the least number of bricks. Instead of checking every possible position, the optimized idea was to track edge positions of bricks (excluding the rightmost edge) using a hash map. By computing the prefix sum of brick widths in each row, we counted how many times a particular edge appears. The position with the maximum edge frequency means the line passes through gaps between bricks, resulting in fewer bricks crossed. ⚡ Complexity: • Time Complexity: O(n × m) • Space Complexity: O(n) 💡 Key Takeaways: • Learned how prefix sums help track cumulative positions • Applied hash maps for frequency counting • Practiced optimizing problems by transforming the perspective of the task #LeetCode #DSA #Algorithms #DataStructures #HashMap #PrefixSum #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

Day 54 on LeetCode Fruit Into Baskets ✅ Today’s problem was a classic variable-size Sliding Window with Hash Map. 🔹 Approach Used in My Solution The goal was to find the longest subarray containing at most 2 distinct elements. Key idea in the solution: • Use a hash map to track the frequency of fruits in the current window • Expand the window by moving end and adding fruits • If the map size exceeds 2 (more than 2 types), shrink the window from the left • Remove elements from the map when their count becomes 0 • Continuously update the maximum window length This ensures we always maintain a valid window with at most 2 fruit types. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) (since at most 2 types are stored) 💡 Key Takeaways: • Mastered variable-size sliding window problems • Learned how to manage constraints using a hash map • Reinforced dynamic window expansion and contraction logic #LeetCode #DSA #Algorithms #DataStructures #SlidingWindow #HashMap #TwoPointers #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 19 of #100DaysOfCode Solved LeetCode 1456 – Maximum Number of Vowels in a Substring of Given Length today. 🔍 Approach: Used the Sliding Window Technique to efficiently track the number of vowels in a substring of size k. Instead of recalculating vowels for every substring, we adjust the count as the window slides forward. 💡 Key Idea: Add the new character entering the window. Remove the character leaving the window. Keep track of the maximum vowel count. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) This approach optimizes the brute-force solution and makes the algorithm scalable for large inputs. Consistent practice is helping me strengthen my problem-solving and data structures fundamentals. #leetcode #dsaalgorithms #slidingwindow #cpp #codingpractice #programming #softwaredevelopment #100daysofcode #developers #techlearning

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

Just solved a challenging binary tree problem! 🌳💻 🔍 Problem: Given a binary tree and an integer k, find the number of downward-only paths where the sum of node values equals k. ➡️ Paths can start and end at any node, but must always move from parent to child. 💡 Key Insight: Using prefix sum + hashmap during DFS traversal helps efficiently track all valid paths in O(n) time! ✅ All test cases passed ⚡ Optimized approach 🔥 Consistency streak continues! #geekstreak #gfg #npci #coding #dsa #binarytree #algorithms #100DaysOfCode #programming #developers #techgrowth