Solved findSubstring with frequency maps on Day 29 of #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 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 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 34 of #100DaysOfCode — LeetCode + HackerRank Edition! Today’s challenge was a subtle twist on binary search — finding the first and last position of a target in a sorted array. 🔗 Problem: searchRange(self, nums: List[int], target: int) (LeetCode) 📌 Challenge: Return the starting and ending index of a target value in O(log n) time. 🔍 Approach: → Used two binary searches — one to find the leftmost index, one for the rightmost → In findLeft(), moved left even after finding the target to ensure it's the first occurrence → In findRight(), moved right after finding the target to ensure it's the last occurrence → Carefully handled edge cases like empty arrays and single-element matches → Avoided brute-force scanning by sticking to binary search logic 💡 What made it click: → Realized that finding one match isn’t enough — we need both ends of the range → Fixed a key bug: I was using while low < high — switching to low <= high made it work → Learned that binary search isn’t just about finding a value — it can be adapted to find boundaries 📚 What I learned: ✅ Binary search can be customized to find first/last positions ✅ Always recalculate mid after updating low and high ✅ Dry runs are powerful for catching subtle logic bugs Have you tried boundary-based binary search before? Did you use recursion, iteration, or a hybrid approach? Let’s swap strategies 💬 #Day34 #LeetCode #BinarySearch #SearchRange #ProblemSolving #Python #DebuggingJourney #CleanCode #LearnToCode #CodeNewbie #SoftwareEngineering #TechJourney #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 52 of #100DaysOfCode — Leetcode + HackerRank Edition! Today’s challenge was all about bringing order to chaos — merging overlapping intervals into clean, non-overlapping ranges 🗂️✨ 🧩 def merge(self, intervals: List[List[int]]) -> List[List[int]]: — Combine overlapping intervals into a simplified list 📌 Challenge: → Implement a function to merge overlapping intervals → Avoid brute-force approaches that check every pair → Optimize for clarity and performance 🔍 Approach: → First, sort intervals by their start time → Keep track of the last merged interval (prev[0]) → If the current interval overlaps, extend the end boundary → Otherwise, add it as a new interval 💡 What made it click: → Realized sorting upfront makes merging straightforward → Saw how prev[1] = max(prev[1], interval[i][1]) elegantly handles overlaps → Practiced dry runs with examples like: [[1,3],[2,6],[8,10],[15,18]] → [[1,6],[8,10],[15,18]] 📚 What I learned: ✅ Why sorting is the key to simplifying interval problems ✅ How greedy merging avoids unnecessary comparisons ✅ How to handle edge cases like single intervals or fully nested ranges Ever felt like your calendar was a mess of overlapping meetings? This algorithm is the perfect organizer 🗓️😎 Let’s swap dry runs, edge cases, and interval insights 💬 #Day51 #Leetcode #Python #MergeIntervals #GreedyAlgorithm #DryRun #LearnInPublic #CodeNewbie #TechJourney #100DaysOfCode #DSA

🚀 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 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 40 of #100DaysOfCode — Leetcode + HackerRank Edition! Today’s challenge was a recursive deep dive into combinatorial search using backtracking: 🧩 combinationSum(candidates, target) — Find all unique combinations that sum to a target. 📌 Challenge: Given a list of positive integers, return all combinations that add up to a target. → You can reuse numbers → Combinations must be unique (no duplicates in different orders) → Example: candidates = [2, 3, 6, 7], target = 7 ✅ Output: [[2, 2, 3], [7]] 🔍 Approach: → Used a recursive helper function with backtracking → Explored each candidate starting from a given index to avoid duplicates → Built combinations incrementally and tracked the running total → Pruned paths early if the total exceeded the target → Saved valid paths when the total matched the target 💡 What made it click: → Backtracking is like exploring a maze — try a path, backtrack if it overshoots, and save the ones that hit the goal → Realized the power of path.pop() to undo choices and explore alternatives → Practiced dry runs to visualize how [2, 2, 3] gets built step-by-step → Saw how recursion + pruning = efficient search 📚 What I learned: ✅ How to implement backtracking with recursion ✅ How to avoid duplicate combinations using index control ✅ How to prune invalid paths early for performance ✅ The beauty of recursive tree exploration Have you tried this one before? Did you use recursion or dynamic programming? Let’s swap strategies 💬 #Day40 #Leetcode #Python #Backtracking #RecursionChallenge #LearnInPublic #CodeNewbie #TechJourney #100DaysOfCode #DSA