Day 34 of #100DaysOfCode: SearchRange challenge on LeetCode

🚀 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 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 32 of #100DaysOfCode — LeetCode + HackerRank Edition! Today’s challenge was all about frequency mapping and subarray logic — solving the Picking Numbers problem from HackerRank. 🔗 Problem: pickingNumbers(a) (HackerRank) 📌 Challenge: Given an array of integers, find the length of the longest subarray where the absolute difference between any two elements is ≤ 1. 🔍 Approach: → Used Python’s Counter to map frequencies of each number → For each number num, calculated freq[num] + freq[num + 1] → Tracked the maximum such sum to find the longest valid subarray → Avoided brute-force by leveraging frequency patterns instead of scanning all subarrays 💡 What made it click: → Realized that valid subarrays must contain only num and num + 1 → Frequency mapping reveals hidden structure in the data → Clean logic with max() and get() made the solution elegant and readable 📚 What I learned: ✅ Frequency-based thinking can simplify subarray problems ✅ Counter is a powerful tool for pattern detection ✅ Avoiding brute-force leads to scalable, efficient solutions ✅ Sharing dry runs and visual walkthroughs helps others grasp the intuition faster Have you tackled Picking Numbers before? Did you go with sorting, brute-force, or frequency mapping like I did? Let’s swap strategies 💬 #Day31 #HackerRank #SubarrayLogic #FrequencyMapping #Python #ProblemSolving #CleanCode #CodeEveryDay #LearnToCode #CodeNewbie #SoftwareEngineering #TechJourney #100DaysOfCode

🚀 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 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 31 of #100DaysOfCode — LeetCode + HackerRank Edition! Today’s challenge was all about tracking structure and resilience — decoding the longest valid parentheses substring in a given string. 🔗 Problem: longestValidParentheses(s) (LeetCode) 📌 Challenge: Given a string of '(' and ')', find the length of the longest well-formed (valid) parentheses substring. 🔍 Approach: → Used a stack to track indices of unmatched '(' characters → Introduced a base index to reset when encountering unmatched ')' → On each valid match, calculated the distance to the last unmatched index → Continuously updated the maximum valid length found so far 💡 What made it click: → Realized that tracking indices, not just characters, is key to measuring valid spans → Using stack[-1] after a pop gives the start of the current valid substring → Resetting with a base index ensures recovery after mismatches 📚 What I learned: ✅ Stack-based tracking is powerful for nested structures ✅ Index math reveals patterns that raw character matching misses ✅ Defensive coding (checking if stack is empty) prevents crashes and improves robustness ✅ Visual walkthroughs and guided hints make debugging intuitive and rewarding Have you tackled longestValidParentheses before? Did you go with dynamic programming, two-pass scanning, or stack-based logic like I did? Let’s swap strategies 💬 #Day30 #LeetCode #StackAlgorithms #ParenthesesMatching #Python #ProblemSolving #CleanCode #CodeEveryDay #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

🚀 DSA Progress – Day 100 ✅ Problem #1371: Find the Longest Substring Containing Even Counts of Vowels 🧠 Difficulty: Medium | Topics: String, Bitmasking, HashMap, Prefix State Tracking 🔍 Approach: Implemented a bitmask + hashmap based solution to efficiently track the parity (even/odd) of vowel occurrences while traversing the string. Step 1 (Vowel Encoding): Each vowel (a, e, i, o, u) is assigned a specific bit position in a 5-bit integer mask. Example: a → bit 0, e → bit 1, i → bit 2, o → bit 3, u → bit 4 Step 2 (Bit Flipping): While iterating through the string, flip (XOR) the corresponding bit when a vowel is found: mask ^= (1 << bit_position) This keeps track of whether each vowel has appeared an even or odd number of times. Step 3 (State Tracking with HashMap): Use a dictionary to store the first occurrence of every mask state. If the same mask is seen again, it means the substring between those indices has even counts for all vowels. Step 4 (Result Calculation): For each repeated mask, calculate the substring length i - mp[mask] and keep track of the maximum. This approach smartly transforms the problem into a state parity tracking problem, making it efficient and clean. 🕒 Time Complexity: O(n) → Single traversal of the string 💾 Space Complexity: O(32) → Only 32 possible vowel parity states (2^5) 📁 File: https://lnkd.in/gx-_Trp6 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem strengthened my understanding of bitmasking and prefix-based logic. I learned how to represent multiple binary conditions using a single integer mask and efficiently find substring properties using hashmaps. It was a great example of combining bit operations with string traversal for optimized solutions. ✅ Day 100 complete — balanced vowels and flipped bits like a pro! ⚙️🔠✨ #LeetCode #DSA #Python #Bitmasking #HashMap #String #PrefixSum #100DaysOfCode #DailyCoding #InterviewPrep #GitHub #LeetCode1371

🚀 Day 38 of #100DaysOfCode —Leetcode + HackerRank Edition! Today’s challenge was a classic logic puzzle wrapped in a deceptively simple interface: 🧩 isValidSudoku(board: List[List[str]]) — Validate a partially filled Sudoku board. 📌 Challenge: Check whether a 9×9 Sudoku board is valid so far, based on three rules: → Each row must contain digits 1–9 without repetition → Each column must contain digits 1–9 without repetition → Each 3×3 sub-box must contain digits 1–9 without repetition 🔍 Approach: → Used three dictionaries of sets to track digits in rows, columns, and boxes → Iterated through each cell, skipping empty ones ('.') → For each digit, checked if it already exists in the corresponding row, column, or box → If duplicate found → return False; otherwise → add to all three sets 💡 What made it click: → Realized that each 3×3 box can be indexed using (i // 3, j // 3) — a neat trick! → Avoided nested loops or extra flags by using clean set logic → Practiced writing readable validation logic that mirrors real-world constraints 📚 What I learned: ✅ How to track multi-dimensional constraints using dictionaries of sets ✅ The power of clean iteration and early returns for validation problems ✅ Sudoku is a great playground for practicing control flow, indexing, and set operations Have you tackled this one before? Did you use sets, arrays, or something else entirely? Let’s swap strategies 💬 #Day38 #HackerRank #Python #SudokuLogic #ValidationChallenge #ControlFlow #ProblemSolving #LearnInPublic #CodeNewbie #TechJourney #100DaysOfCode#DSA

🚀 Day 41 of #100DaysOfCode — Leetcode + HackerRank Edition! Today’s challenge was a twist on yesterday’s recursive puzzle — this time with stricter rules and smarter pruning: 🧩 combinationSum2(candidates, target) — Find all unique combinations that sum to a target, using each number only once. 📌 Challenge: Given a list of positive integers, return all combinations that add up to a target. → Each number can be used once per combination → Combinations must be unique (no duplicates in different orders) → Example: candidates = [10,1,2,7,6,1,5], target = 8 ✅ Output: [[1,1,6],[1,2,5],[1,7],[2,6]] 🔍 Approach: → Sorted the input to handle duplicates cleanly → Used a recursive helper with backtracking → Skipped repeated values at the same recursive level → Moved to the next index after choosing a candidate (no reuse!) 💡 What made it click: → Realized that i > start and candidates[i] == candidates[i - 1] is the key to skipping duplicates → Practiced dry runs to see how [1,2,5] gets built and why [1,2,5] doesn’t repeat → Saw how index control + pruning = clean and efficient recursion → Appreciated how path.pop() lets us rewind and explore new paths 📚 What I learned: ✅ How to implement backtracking with recursion ✅ How to avoid duplicate combinations using sorted input and index checks ✅ How to prune invalid paths early for performance ✅ The elegance of recursive tree exploration Have you tackled this one before? Did you use recursion or dynamic programming? Let’s swap strategies 💬 #Day40 #Leetcode #Python #Backtracking #RecursionChallenge #LearnInPublic #CodeNewbie #TechJourney #100DaysOfCode #DSA