Solved Picking Numbers with Python's Counter and Frequency Mapping

🚀 Day 29 of #100DaysOfCode — LeetCode + HackerRank Edition! Today’s challenge was all about precision and pattern matching — and I stuck to the essentials. 🔗 Problem: findSubstring(s, words) (LeetCode) 📌 Challenge: Given a string s and a list of words (all the same length), find all starting indices where the concatenation of all words appears exactly once and without overlap. 🔍 Approach: → Calculated the total length of the target substring using len(words[0]) * len(words) → Built a frequency map using Counter(words) → Used a sliding window of size total_len to scan through s → At each position, extracted word-sized chunks and tracked their frequency → Compared the seen map with the original word_count to validate matches → Appended valid starting indices to the result list 💡 What made it click: → Realized that permutations aren’t necessary — just match word frequencies → Stepping through s in word-sized chunks keeps the logic clean and efficient → Using Counter for both the target and current window made comparison seamless 📚 What I learned: ✅ Frequency maps are a powerful alternative to brute-force approaches ✅ Matching dictionaries directly (seen == word_count) is a validation trick ✅ Clean logic and early breaks make the code both readable and performant Have you solved findSubstring before? Did you go with permutations or lean into frequency maps like I did? Let’s swap strategies 💬 #Day29 #LeetCode #SlidingWindow #StringAlgorithms #Python #ProblemSolving #CleanCode #CodeEveryDay #LearnToCode #CodeNewbie #SoftwareEngineering #TechJourney #100DaysOfCode

🚀 Day 33 of #100DaysOfCode — LeetCode + HackerRank Edition! Today’s challenge was a classic twist on binary search — searching in a rotated sorted array. 🔗 Problem: search(self, nums: List[int], target: int) (LeetCode) 📌 Challenge: Given a rotated sorted array, find the index of a target value in O(log n) time. 🔍 Approach: → Used binary search with a twist: at each step, determined which half of the array is sorted → If the left half is sorted, checked if the target lies within it → If not, searched the right half — and vice versa → Carefully updated low, high, and recalculated mid inside the loop → Avoided brute-force by leveraging the sorted structure of one half at every step 💡 What made it click: → Realized that one half is always sorted, even after rotation → Visualized the array and dry-ran examples like [4,5,6,7,0,1,2] to understand the logic → Fixed a key bug: I was calculating mid only once — moving it inside the loop made everything work! → Debugging this helped me appreciate how small details (like mid placement) can make or break binary search 📚 What I learned: ✅ Binary search can be adapted to rotated arrays with clever logic ✅ Always recalculate mid after updating low and high ✅ Dry runs are powerful for catching logic bugs Have you tackled rotated binary search before? Did you use recursion, iteration, or something else? Let’s swap strategies 💬 #Day33 #LeetCode #BinarySearch #RotatedArray #ProblemSolving #Python #DebuggingJourney #CleanCode #LearnToCode #CodeNewbie #SoftwareEngineering #TechJourney #100DaysOfCode

🚀 Day 46 of #100DaysOfCode — Leetcode + HackerRank Edition! Today’s challenge was a twist on yesterday’s recursion puzzle — this time with duplicates in the mix 🔁🧠 🧩 permuteUnique(self, nums: List[int]) -> List[List[int]] — Generate all unique permutations of a list that may contain duplicate integers. 📌 Challenge: → Given a list nums, return all distinct orderings → Each number must appear exactly once per permutation → Example: nums = [1, 1, 2] ✅ Output: [[1,1,2], [1,2,1], [2,1,1]] 🔍 Approach: → Sort the input to group duplicates → Use recursion + backtracking to build paths → Track visited indices with a used[] array → Skip duplicates using: if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]: continue  → Backtrack by popping the last element and resetting used[i] 💡 What made it click: → Visualized the decision tree for [1, 1, 2] — saw how pruning avoids duplicate branches → Practiced dry runs to trace how used[] and sorting work together → Realized how skipping nums[i] when nums[i] == nums[i-1] and used[i-1] == False prevents redundant paths → Appreciated how recursion + pruning = clean, efficient, elegant 📚 What I learned: ✅ How to handle duplicates in permutation problems ✅ How sorting + index tracking helps prune recursion ✅ How to visualize branching decisions and avoid redundant paths ✅ The subtle power of used[] and index-based duplicate checks Have you ever debugged a recursive tree with duplicate values? Let’s swap strategies, dry runs, and visual walkthroughs 💬 #Day46 #Leetcode #Python #Recursion #Backtracking #DryRun #LearnInPublic #CodeNewbie #TechJourney #100DaysOfCode #DSA

🚀 Day 26 of #100DaysOfCode — LeetCode + HackerRank Edition! Today’s challenge was all about string precision and pattern matching: 🔗 Implement strStr() (LeetCode) 📌 Challenge: Given two strings haystack and needle, return the index of the first occurrence of needle in haystack, or -1 if it doesn’t exist. 🔍 Approach: → Skipped the built-in .find() to implement it manually → Iterated through haystack only up to len(haystack) - len(needle) → Compared slices haystack[i:i+len(needle)] with needle → Returned the index on match, -1 otherwise 💡 What made it click: → Realized that checking every possible starting index is enough — no need to build substrings manually → Adjusting the loop range to avoid out-of-bound errors was the key → Removing redundant checks like if needle not in haystack made the code cleaner and faster 📚 What I learned: ✅ Substring search is a great intro to sliding window logic ✅ Clean loop bounds = fewer bugs ✅ Sometimes the simplest approach is the most elegant ✅ Writing your own version of built-ins deepens your understanding of how they work under the hood Have you implemented your own strStr() before? Did you go brute-force or try KMP? Let’s compare strategies 💬🔍 #Day26 #LeetCode #StringMatching #CodingChallenge #Python #ProblemSolving #CleanCode #CodeEveryDay #LearnToCode #CodeNewbie #SoftwareEngineering #TechJourney #geeksforgeeks #100DaysOfCode

💯 Day 48 / 100 – 100 Days of #LeetCode Challenge 🔁 Problem: 290. Word Pattern Goal: Given a pattern and a string s, determine if s follows the same pattern. Here, follow means a bijection between a letter in pattern and a unique word in s: Each letter in pattern maps to exactly one unique word in s. Each word in s maps to exactly one unique letter in pattern. No two letters map to the same word and vice versa. Approach: ✅ Split the input string s into individual words. ✅ If the number of pattern characters doesn’t match the number of words → return False. ✅ Use two dictionaries to ensure one-to-one mapping: char_to_word: maps each pattern character to a word. word_to_char: maps each word back to a pattern character. ✅ Verify mappings remain consistent through iteration. Complexity: ⏱ Time: O(n) – single pass through pattern and words. 🗂 Space: O(n) – for two hash maps. 💡 Key Takeaway: This problem emphasizes understanding of bijection (one-to-one mapping). Using two dictionaries ensures the relationship is perfectly mutual — a great lesson in mapping logic and validation. #100DaysOfLeetCode #Day48 #Python #DSA #HashMap #ProblemSolving #CodingChallenge #LeetCode #StringMapping #LogicBuilding

🚀 Day 35 of #100DaysOfCode — LeetCode + HackerRank Edition! Today’s challenge was all about merging two sorted arrays in-place — no extra space allowed, just clean pointer logic. 📌 Challenge: Merge nums2 into nums1, assuming nums1 has enough trailing space. The final array must be sorted — and the merge must happen in-place. 🔍 Approach: → Used a two-pointer strategy from the back to avoid overwriting values in nums1 → Compared the largest elements from both arrays and placed them at the end → Moved pointers backward (p1, p2, p) until all elements were merged → Handled edge cases like empty nums2 or all elements being smaller than nums1 → Avoided sorting after merge — the logic itself ensures order 💡 What made it click: → Realized that merging from the front causes overwrites — merging from the back preserves data → Visualized the pointer movement with a dry run — that helped me catch off-by-one bugs → Learned that in-place algorithms often rely on reverse traversal and smart indexing 📚 What I learned: ✅ Two-pointer techniques are powerful for in-place operations ✅ Always think about overwrite risks when merging arrays ✅ Dry runs and visual walkthroughs are key to debugging pointer logic Have you tried merging sorted arrays in-place before? Did you use reverse traversal or a different trick? Let’s swap strategies 💬 #Day35 #LeetCode #ArrayProblems #TwoPointerTechnique #ProblemSolving #Python #DebuggingJourney #CleanCode #LearnToCode #CodeNewbie #SoftwareEngineering #TechJourney #100DaysOfCode

💯 Day 42 / 100 – 100 Days of #LeetCode Challenge 🔁 Problem: 744. Find Smallest Letter Greater Than Target Goal: Given a sorted list of letters and a target letter, find the smallest letter that is greater than the target. The list wraps around, meaning if no letter is greater, return the first letter in the list. Approach: ✅ Sort the list to ensure it’s in order (though usually given sorted). ✅ Iterate through the letters: If a letter is greater than the target, return it immediately. ✅ If no such letter exists, return the first letter (wrap-around case). Complexity: ⏱ Time: O(n) – Linear scan through the letters. 🗂 Space: O(1) – Constant extra space. 💡 Key Takeaways: Simple iteration logic can solve problems efficiently without extra data structures. Watch out for wrap-around conditions in sorted arrays. This problem is a good intro to binary search optimization ideas! #100DaysOfLeetCode #Day42 #Python #DSA #Stack #ProblemSolving #CodingChallenge #LeetCode #LearningEveryday

🚀 Day 4/100 — Cracked LeetCode 1611: Minimum One Bit Operations to Make Integers Zero 🔥 Today’s challenge was a deep dive into bit manipulation and recursion. LeetCode 1611 looked deceptively simple—but beneath the surface, it’s a clever twist on Gray code transformations. 🔍 Problem Summary Transform an integer n into 0 using two constrained bit-flipping operations. The trick? You can only flip the rightmost bit, or flip the i-th bit if the (i-1)th is 1 and all lower bits are 0. 🧠 Key Insight This problem maps beautifully to recursive Gray code logic. For any number n, we recursively reduce it by flipping the highest set bit and subtracting the operations needed for the remainder. 📈 What I Learned Bitwise recursion can be elegant and powerful. Understanding binary patterns unlocks optimization. Python’s bit_length() is a hidden gem for bit-level logic. 🔧 Next Steps I’ll be documenting more of these insights as part of my 100-day challenge. If you’re into algorithmic puzzles or want to collaborate on clean, modular solutions—let’s connect! #100DaysOfCode #LeetCode #Python #BitManipulation #GrayCode #CodingChallenge #TechJourney #ScarBuilds

🚀 DSA Challenge – Day 104 Problem: Flatten Binary Tree to Linked List 🌳➡️📄 This problem is a beautiful blend of tree traversal and pointer manipulation. The goal is to transform a binary tree into a linked list following preorder traversal, while modifying the tree in-place. 🧠 Problem Summary: You're given the root of a binary tree. Your task → Flatten the tree into a linked list such that: Each node’s right pointer acts as the “next” pointer. Each node’s left pointer is always None. The resulting order must follow preorder traversal: Root → Left → Right ⚙️ My Approach: I used a recursive DFS approach that processes nodes in a way that supports pointer restructuring: 1️⃣ Flatten left subtree 2️⃣ Flatten right subtree 3️⃣ If the current node has a left subtree: Temporarily store root.right Move root.left to root.right Nullify the left pointer Traverse to the end of this new right chain Attach the original right subtree there This ensures the node order becomes preorder while maintaining pointer correctness. 📌 Key Observations: Although preorder is Root → Left → Right, the flattening requires processing children first. Doing operations in-place ensures optimal space usage. Traversing to the end of the newly attached right subtree ensures that both left and right parts remain connected in correct order. 📈 Complexity: Time: O(n) — Each node is visited once Space: O(h) — Recursion stack (height of the tree) ✨ Key Takeaway: Flattening a binary tree becomes simple once you understand pointer realignment. First flatten both subtrees → then stitch them together → and the final structure becomes a clean preorder linked list. 🌳➡️🪜 🔖 #DSA #100DaysOfCode #Day104 #BinaryTrees #PreorderTraversal #TreeFlattening #Recursion #LeetCode #ProblemSolving #Python #CodingJourney #TechCommunity #LearningEveryday