Binary Search in Sorted Array: Find First & Last Position

🚀 50 Important Coding Questions – Question 36/50 🔹 Next Greater Element I | LeetCode A classic Monotonic Stack problem used frequently in coding interviews. 📌 Problem Statement You are given two arrays nums1 and nums2. For each element in nums1, find the next greater element in nums2. The next greater element of x is the first element to the right of x in nums2 that is greater than x. If it does not exist → return -1. Example: Input nums1 = [4,1,2] nums2 = [1,3,4,2] Output [-1,3,-1] 💡 Approach We use a Monotonic Decreasing Stack. Steps: 1️⃣ Traverse nums2 from right to left 2️⃣ Remove all elements from stack ≤ current element 3️⃣ The stack top becomes the next greater element 4️⃣ Store results in a map/array 5️⃣ Finally answer queries for nums1 This avoids checking every element repeatedly. ⏱ Time Complexity: O(n + m) 📦 Space Complexity: O(n) 📌 LeetCode Result: ✔ Accepted ⚡ Runtime: 0 ms 🧠 Concepts Strengthened ✔ Monotonic Stack ✔ Stack-based optimization ✔ Array traversal techniques ✔ Precomputation for faster queries 📍 Question 36 of 50 in my “50 Important Coding Questions” series. Every problem solved improves algorithmic thinking step by step 💯 👉 Question 37 coming next! #DSA #LeetCode #Stack #MonotonicStack #CodingInterview #ProblemSolving #CPlusPlus #TechJourney

🥷 Day 301 of My 365 LeetCode Challenge is done! 💥 Kicked off strong, solved my problem, and the coding vibe is awesome! 🧠 📌 LeetCode 1758 – Minimum Changes To Make Alternating Binary String Sometimes the simplest problems offer the best opportunity to strengthen your fundamentals. Today’s challenge focused on string manipulation and pattern recognition — two concepts that frequently appear in coding interviews. 🧠✨ 🔍 Problem Overview We’re given a binary string consisting only of 0s and 1s. The goal is to determine the minimum number of changes required to make the string alternating. An alternating string means: ✔ No two adjacent characters are the same ✔ Valid patterns would look like "010101..." or "101010..." So essentially, the string must follow one of two possible patterns. ⚙️ Key Idea Behind the Solution Instead of trying complex transformations, we can simply compare the string against the two valid alternating patterns: 1️⃣ Pattern starting with 0 → 010101... 2️⃣ Pattern starting with 1 → 101010... By counting how many positions differ from each pattern, we get the number of changes required for each scenario. The final answer is simply the minimum of the two counts. 💡 Why This Problem Matters Even though it’s categorized as an easy problem, it reinforces several important skills: • Pattern-based thinking • Efficient string traversal • Writing concise and optimized logic • Recognizing that sometimes brute-force comparison can still be optimal 🧠 Key Takeaway Not every coding challenge requires complex algorithms. Many problems reward clear observation and structured thinking. Mastering these fundamentals builds a strong foundation for tackling more advanced algorithmic challenges. On to the next challenge! 💪🔥 #LeetCode #DSA #Strings #Algorithms #ProblemSolving 🧠 #CodingJourney #InterviewPrep #CPlusPlus 🚀

🚀 50 Important Coding Questions – Question 20/50 🔹 Longest Consecutive Sequence | LeetCode (Medium) A powerful Hash Set problem that teaches how to detect sequences efficiently without sorting 👇 📌 Problem Statement Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence. 👉 Must solve in O(n) time. 💡 Optimized Approach (Hash Set) 1️⃣ Store all numbers in a set 2️⃣ Only start counting when num-1 is NOT in set 3️⃣ Keep checking num+1 until sequence ends 4️⃣ Track maximum length ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) ✅ Why this problem is important? ✔ Strengthens Hash Set concepts ✔ Teaches sequence detection logic ✔ Very common in FAANG interviews ✔ Shows how to reduce sorting to linear time 📌 LeetCode Result: ✔ Accepted ⚡ Efficient O(n) solution 🔔 This is Question 20 of my “50 Important Coding Questions” series. Almost halfway — keep the grind going 💪 👉 Question 21 coming soon… #DSA #LeetCode #LongestConsecutiveSequence #HashSet #Arrays #CPlusPlus #CodingInterview #ProblemSolving #50ImportantQuestions

🚀 Coding Practice — Check if a Number Has Alternating Bits (Bit Manipulation) 🔄✨Alternating Bits ⚡ The Binary Seesaw 🔥🔥🔥 Beats 100% Today I worked on a neat bit-manipulation problem: determine whether a number’s binary representation contains alternating bits — meaning no two adjacent bits are the same. Examples: ✅ Valid → 10101, 0101 ❌ Invalid → 110, 1001 🧠 Intuition Think of binary digits like stepping stones that must alternate colors — ⚫⚪⚫⚪ — at every step. If you ever step on two same-colored stones in a row, the pattern breaks. Instead of converting the number to a binary string, we directly inspect each bit using bitwise operations — which is faster and more memory-efficient. Core idea: Extract the last bit using n & 1 Shift right using n >> 1 Compare with the previous bit If equal → not alternating 🛠️ Approach (Step-by-Step) 1️⃣ Capture the least significant bit (LSB) using n & 1 2️⃣ Right shift the number to move to the next bit 3️⃣ Loop while the number is not zero: Store previous bit Extract current bit If both are equal → return False Otherwise continue shifting 4️⃣ If loop completes → all bits alternated → return True 💻 Python Code class Solution:     def hasAlternatingBits(self, n: int) -> bool:         curr = n & 1         n >>= 1         while n:             prev = curr             curr = n & 1             if curr == prev:                 return False             n >>= 1         return True 📊 Complexity Analysis ✅ Time Complexity: O(log n) We check each bit once. A number has about log₂(n) bits. ✅ Space Complexity: O(1) Only constant variables are used. ✨ Bit manipulation problems like this are great for strengthening low-level logic and understanding how numbers are stored internally. Small problems — big thinking benefits. #Python #CodingPractice #BitManipulation #DSA #ProblemSolving #InterviewPrep #LearnToCode #TechLearning

🚀 50 Important Coding Questions – Question 10/50 🎉 🔹 3Sum | LeetCode (Medium) A flagship problem that combines sorting + two pointers and tests your ability to handle duplicates cleanly 👇 📌 Problem Statement Given an integer array nums, return all unique triplets [nums[i], nums[j], nums[k]] such that 👉 nums[i] + nums[j] + nums[k] = 0 The solution set must not contain duplicate triplets. 💡 Optimized Approach (Sorting + Two Pointers) Sort the array Fix one element and apply two pointers on the remaining part Skip duplicates carefully to ensure unique triplets ⏱ Time Complexity: O(n²) 📦 Space Complexity: O(1) (excluding output) ✅ Why this problem is important? ✔ Gold-standard Two Pointers problem ✔ Teaches duplicate handling & optimization ✔ Frequently asked in FAANG & product-based interviews ✔ Foundation for 4Sum & k-Sum problems 📌 LeetCode Result: ✔ Accepted ⚡ Optimized solution (Beats ~99%) 🔔 This is Question 10 of my “50 Important Coding Questions” series. That’s 20% completed — consistency wins 💪 👉 Question 11 coming soon… #DSA #LeetCode #3Sum #TwoPointers #Sorting #CPlusPlus #CodingInterview #ProblemSolving #50ImportantQuestions

Binary Search is NOT just “𝗳𝗶𝗻𝗱 𝗺𝗶𝗱 𝗮𝗻𝗱 𝗰𝗼𝗺𝗽𝗮𝗿𝗲.” It’s a mindset shift most coders miss. I used to think I had mastered Binary Search… until LeetCode started throwing “weird” problems at me. Lower bound. Upper bound. First true. Last true. Suddenly, 𝘄𝗵𝗶𝗹𝗲 (𝗹𝗼𝘄 <= 𝗵𝗶𝗴𝗵) wasn’t enough. I kept getting off-by-one errors. Infinite loops. Wrong indices. The problem wasn’t coding, it was clarity. Then I realized: 𝗕𝗶𝗻𝗮𝗿𝘆 𝗦𝗲𝗮𝗿𝗰𝗵 𝗶𝘀𝗻’𝘁 𝗮𝗯𝗼𝘂𝘁 𝘀𝗲𝗮𝗿𝗰𝗵𝗶𝗻𝗴. It’s about shrinking the answer space. Lower bound → first position ≥ target. Upper bound → first position > target. First/Last true → binary search on a condition. On answer → search the minimum valid value. Peak element → exploit monotonic behavior. Once I stopped thinking in terms of arrays and started thinking in terms of invariants, everything changed. 𝗕𝗶𝗻𝗮𝗿𝘆 𝗦𝗲𝗮𝗿𝗰𝗵 𝘁𝗮𝘂𝗴𝗵𝘁 𝗺𝗲 𝘁𝗵𝗶𝘀: Great problem solvers don’t search data. They search possibilities. Which variation challenged you the most, and how did you finally “get it”? #Java #LeetCode #ProblemSolving #CodingJourney #DeveloperCommunity #BinarySearch #AlgorithmDesign

🚀 50 Important Coding Questions – Question 18/50 🔹 Group Anagrams | LeetCode (Medium) A classic Hashing + Sorting problem that teaches how to group data efficiently 👇 📌 Problem Statement Given an array of strings, group the anagrams together. Two strings are anagrams if they contain the same characters with the same frequency. 💡 Optimized Approach 1️⃣ Sort each string → get a canonical form 2️⃣ Use a Hash Map → key = sorted string 3️⃣ Store original strings in the same group Example: 👉 "eat", "tea", "ate" → all become "aet" → same group ⏱ Time Complexity: O(n * k log k) (k = average string length) 📦 Space Complexity: O(nk) ✅ Why this problem is important? ✔ Strengthens Hash Map concepts ✔ Teaches grouping techniques ✔ Common in FAANG interviews ✔ Foundation for advanced string problems 📌 LeetCode Result: ✔ Accepted ⚡ Efficient hashing solution 🔔 This is Question 18 of my “50 Important Coding Questions” series. You’re already over 1/3 of the way — keep going 💪 👉 Question 19 coming soon… #DSA #LeetCode #GroupAnagrams #Hashing #Sorting #Strings #CPlusPlus #CodingInterview #ProblemSolving #50ImportantQuestions

👩💻 Here's Why You Should Be Using Pydantic in Your Projects 👨💻 Let’s talk about a tool that’ll seriously boost your Python development—Pydantic. If you're just getting started, or even if you’ve been coding for a while, it’s time to level up your game. Here’s how Pydantic can help you out: 🔹 Why Pydantic is a Must-Have Tool: ✅ Data Validation: It automatically checks your data, saving you from tons of bugs. ✅ Type Enforcement: Pydantic makes sure your variables are always the right type. No surprises. ✅ Improved Performance: Pydantic is fast and reliable, even with complex data models. 🔹 Where to Use It? 💡 API Data Handling: If you're building APIs, this is your go-to tool. 💡 Data Parsing: Pydantic simplifies parsing data, so you can focus on logic. 💡 Config Management: Manage your app’s settings easily and safely. 🔹 What’s in it for You? ✅ Ensures Data Integrity: Keep your data clean and accurate from the start. ✅ Reduces Bugs & Errors: With automatic checks, you’ll spend less time debugging. ✅ Boosts Development Speed: You’ll get things done faster, without compromising quality. Start using Pydantic, and watch your Python skills improve. It’s all about writing smarter, not harder. Trust me on this one! 💪 #Python #JuniorDev #Pydantic #DevTips #DataValidation #SoftwareDevelopment #TechForJuniors #PythonTips

Day 36 :- Binary Search & Range Finding: Find First and Last Position of Element ✅ Today’s DSA session was a great exercise in extending the classic Binary Search to handle multiple occurrences of a target value. I tackled LeetCode 34. Find First and Last Position of Element in Sorted Array, focusing on how to efficiently pinpoint a range within a sorted dataset. The Technical Breakdown: Hybrid Search Strategy: I started with a standard Binary Search to find any instance of the target. This immediately gives us an O(log n) starting point. Linear Expansion: Once the target was found, I used two pointers to expand outward from the meeting point. This identifies the exact boundaries where the target values start and end. Edge Case Handling: The logic naturally handles cases where the target isn't present by returning [-1, -1], and it manages single-element arrays or cases where the target spans the entire array. The Trade-off: While this approach is very intuitive, it can reach O(n) in the worst case (e.g., an array of all identical numbers). It’s a great stepping stone before diving into the pure O(log n) approach of finding the "leftmost" and "rightmost" indices independently! It's a solid reminder that Binary Search isn't just for finding a single value—it's the foundation for navigating any sorted range! 🚀 A huge thanks to my mentor, Anchal Sharma and Ikshit .. for the incredible support and for helping me stay consistent on this journey. Having that accountability makes all the difference! #DSA #Java #100DaysOfCode #BinarySearch #TwoPointers #ProblemSolving #Mentorship #LeetCode #SoftwareEngineering

🚀 50 Important Coding Questions – Question 27/50 🔹 Sort List | LeetCode (Medium) A very important Linked List problem that teaches sorting using Merge Sort 📚 📌 Problem Statement Given the head of a linked list, sort it in ascending order. 💡 Optimal Approach – Merge Sort on Linked List Why Merge Sort? Because Linked Lists don’t support random access like arrays. 👉 Steps 1️⃣ Find middle of list using slow & fast pointers 2️⃣ Split list into two halves 3️⃣ Recursively sort both halves 4️⃣ Merge sorted lists 🧠 Why this problem is important? ✔ Teaches Merge Sort logic ✔ Important interview question ✔ Helps in advanced Linked List problems ✔ Improves recursion understanding ⏱ Time Complexity: O(n log n) 📦 Space Complexity: O(log n) (recursion stack) 👉 My approach used array conversion + sorting, but Merge Sort is the optimal in interviews. 📌 LeetCode Result: ✔ Accepted ⚡ Efficient solution 🔔 This is Question 27 of my “50 Important Coding Questions” series. Linked List concepts getting stronger 💪 👉 Question 28 coming soon… #DSA #LeetCode #LinkedList #MergeSort #CodingInterview #CPlusPlus #ProblemSolving #50ImportantQuestions