Solved LeetCode 2610 with Python and Hashmap

Day 32 / #120DaysOfCode – LeetCode Challenge Today’s focus: Arrays & Majority Voting Algorithm ✅ Problem Solved: • Majority Element II 💻 Language: Python 📚 Key Learnings: • Applied Boyer-Moore Voting Algorithm (extended version) • Learned how to track two candidates for n/3 majority • Understood the importance of validation step after candidate selection • Improved ability to handle edge cases in frequency problems Consistency builds confidence 🚀 Every day = 1% better 💪 🔗 LeetCode Profile: https://lnkd.in/gbeMKcv5 #LeetCode #Python #DSA #Arrays #Algorithms #Consistency #CodingJourney #120DaysOfCode

Group Anagrams: Frequency Array as Hashable Key Sorting each string costs O(k log k) per string. Character frequency array is O(k) and creates identical signature for anagrams. Fixed 26-element array converted to tuple serves as hashable HashMap key — faster, cleaner grouping. Frequency Signature: Character counts uniquely identify anagram groups without sorting. Tuple conversion makes array hashable for dict keys. Pattern applies to document clustering, duplicate detection. Time: O(n × k) vs O(n × k log k) sorting | Space: O(n × k) #FrequencyArray #Anagrams #HashMap #KeyOptimization #Python #AlgorithmOptimization #SoftwareEngineering

Day 55/100 – #100DaysOfCode 🚀 Solved LeetCode #205 – Isomorphic Strings (Python). Today I practiced hashmap (dictionary) usage to check whether two strings follow the same pattern. Approach: 1) Create two hashmaps to store character mappings in both directions. 2) Traverse both strings together using zip(). 3) Check if the current mapping is consistent in both maps. 4) If any mismatch is found, return False. 5) Otherwise, update the mappings and continue. 6) If all mappings are valid, return True. Time Complexity: O(n) Space Complexity: O(n) Understanding how bidirectional mapping ensures consistency 💪 #LeetCode #Python #DSA #HashMap #Strings #ProblemSolving #100DaysOfCode

💧 Max Water Problem — Two Pointer Optimization Solved Container With Most Water using the Two Pointer technique in O(n) time. Key Idea: Move the pointer with the smaller height, since it limits the water capacity. 📈 Complexity: Time → O(n) Space → O(1) Small logic shift, big optimization. #DSA #Python #TwoPointers #CodingInterview #Algorithms

Day 42/100 – #100DaysOfCode 🚀 Solved LeetCode #2574 – Left and Right Sum Differences (Python). Today I practiced prefix sum logic to calculate the absolute difference between left and right sums for each index. Approach: 1) Calculate the total sum of the array. 2) Initialize leftSum = 0. 3) Traverse the array. 4) For each index, compute rightSum = total - leftSum - nums[i]. 5) Calculate the absolute difference and append it to the result. 6) Update leftSum by adding nums[i]. Time Complexity: O(n) Space Complexity: O(n) Understanding prefix sum helps solve problems efficiently 💪 #LeetCode #Python #DSA #Arrays #PrefixSum #ProblemSolving #100DaysOfCode

🚀 Day 62 of #100DaysOfCode Solved “Remove Nth Node From End of List” 🔗 💡 Today’s focus: Two Pointer Technique (Fast & Slow pointers) Instead of calculating length, I used an efficient one-pass approach to remove the target node. 🧠 Key Learnings: Dummy node helps handle edge cases (like removing head) Fast pointer moves n steps ahead Then move both pointers until fast reaches the end Slow pointer lands just before the node to delete ⚡ Clean, efficient & optimal solution (O(n) time, O(1) space) Consistency is starting to feel powerful now 💪 #DSA #LeetCode #CodingJourney #LinkedInLearning #100DaysOfCode #Day62 #Python #ProblemSolving

Last Stone Weight: Max-Heap via Negation for Collision Simulation Python's heapq is min-heap only. Simulate max-heap by negating values. Repeatedly extract two largest stones (most negative), compute difference, reinsert. Continue until one/zero stones remain. Max-Heap Workaround: Negating values transforms min-heap to max-heap. This pattern applies whenever max-heap needed in Python. Remember to negate back when extracting final values. Time: O(n log n) | Space: O(n) #Heap #MaxHeap #NegationTrick #PriorityQueue #Python #AlgorithmDesign #SoftwareEngineering

DAY 53 🚀 – Bit Manipulation + Subsets 🔥 Exploring power sets and pattern expansion 💯 Day 53 / #120DaysOfCode – LeetCode Challenge ✅ Problem Solved: • 78. Subsets 💻 Language: Python 📚 Key Learnings: • Built subsets using iterative expansion technique • Understood relation to power set (2ⁿ combinations) • Learned alternative approach via bit manipulation • Strengthened understanding of combinatorics in coding 💡 Key Insight: Each element doubles the number of subsets → include / exclude 🔥 Progress: Moving deeper into patterns used in recursion & bit manipulation 💪 🔗 LeetCode Profile: https://lnkd.in/gbeMKcv5 #LeetCode #Python #DSA #BitManipulation #Subsets #Backtracking #Consistency #120DaysOfCode

Most implementations of the State pattern in Python look very “clean”. Lots of small classes. A base interface. One class per state. But if you’ve ever worked with one in a real project, you know the downside: transitions are scattered, behaviour is hard to see in one place, and adding new states often means touching multiple files. In today’s video, I rebuild the State pattern in a very different way. Instead of relying on inheritance, I make the state machine explicit as data and use decorators to define transitions. The result is a small, reusable engine where the entire flow becomes visible at a glance. If you’re interested in writing Python that’s easier to reason about and extend, this is a pattern worth understanding. 👉 Watch here: https://lnkd.in/e9Y3xGNF. #python #softwaredesign #designpatterns #statemachine #cleancode

Day 39/100 – #100DaysOfCode 🚀 Solved LeetCode #2215 – Find the Difference of Two Arrays (Python). Today I practiced set operations to efficiently find distinct elements between two arrays. Approach: 1) Convert both arrays into sets to remove duplicates. 2) Find elements present in nums1 but not in nums2 using set difference. 3) Find elements present in nums2 but not in nums1. 4) Convert both results back to lists. 5) Return the final list of differences. Time Complexity: O(n + m) Space Complexity: O(n + m) Understanding how set operations simplify comparison problems 💪 #LeetCode #Python #DSA #Sets #Arrays #ProblemSolving #100DaysOfCode