Solved rotated binary search challenge with binary search logic

🚀 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 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 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 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 20- 30DaysChallenge(Leetcode Problem): Merge Sorted Array 🌟 Problem: You are given two integer arrays, nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2, respectively. Merge nums1 and nums2 into a single array sorted in non-decreasing order. The final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n. 🧠Solution: class Solution:   def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:     tmp_nums1 = nums1[:m] # copy the non zero elements of nums1              p1 = 0     p2 = 0              for p in range(n + m):            if p2 >= n or (p1 < m and tmp_nums1[p1] <= nums2[p2]):         nums1[p] = tmp_nums1[p1]          p1 += 1       else:         nums1[p] = nums2[p2]         p2 += 1 #DSA #Python #CodingChallenge #30dayschallenge #Leetcode

🚀 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 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

🚀 Day 45 of #100DaysOfCode — Leetcode + HackerRank Edition! Today’s challenge was a deep dive into recursion and backtracking 🔁🧠 🧩 permute(self, nums: List[int]) -> List[List[int]] — Generate all possible permutations of a list of distinct integers. 📌 Challenge: → Given a list nums, return all possible orderings → Each number must appear exactly once per permutation → Example: nums = [1, 2, 3] ✅ Output: [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]] 🔍 Approach: → Use recursion to build permutations step-by-step → Track current path with curr → Skip numbers already in curr → When len(curr) == len(nums), add a copy to results → Backtrack by popping the last element 💡 What made it click: → Visualized the recursive tree — each level adds one unused number → Practiced dry runs with nums = [1, 2, 3] to see how paths evolve → Realized how curr.pop() resets the state for the next branch → Appreciated how backtracking avoids duplicate paths and keeps memory clean 📚 What I learned: ✅ How to implement recursive backtracking with minimal state ✅ How to use dry runs to trace recursive calls ✅ How to visualize tree-like expansion of choices ✅ The power of copying lists (curr[:]) to preserve snapshots Have you ever visualized recursion like a decision tree? Let’s swap strategies and dry run walkthroughs 💬 #Day45 #Leetcode #Python #Recursion #Backtracking #DryRun #LearnInPublic #CodeNewbie #TechJourney #100DaysOfCode #DSA