Master Binary Search on LeetCode & CodeForces

🚀 Day 6/100 — LeetCode Challenge Solved LeetCode 704: Binary Search Simple problem, but it tests your understanding of the basics. 💡 Approach: 1) Use two pointers: low and high 2) Find mid element 3) Compare with target and eliminate half of the search space 👉 Repeat until target is found or search space becomes empty. What I realized: Binary Search is not just about the idea, but about handling boundaries correctly (low <= high, mid calculation, etc.) 🧠 Time Complexity: O(log n) 💾 Space Complexity: O(1) Sometimes mastering the basics is more important than jumping to advanced problems. Back to consistency 💪 #LeetCode #DSA #100DaysOfCode #Cpp #BinarySearch #CodingJourney

🚀 Day 16 of My LeetCode Journey Today, I solved LeetCode Problem #747 – Largest Number At Least Twice of Others. 🔍 Problem Summary: Given an array of integers, we need to find whether the largest element is at least twice as much as every other number. If yes, return its index; otherwise, return -1. 💡 Approach I Used: First, find the largest and second largest elements in the array. Then check if the largest element is at least twice the second largest. If yes, return the index of the largest element. 🧠 Key Learning: This problem improved my understanding of: Array traversal Maintaining multiple variables (max & second max) Writing optimized O(n) solutions 📈 Progress: Consistency is the key 🔑 — improving step by step every day. #LeetCode #DSA #Java #CodingJourney #ProblemSolving #100DaysOfCode

Day 11 – Remove K Digits 🚀 Continuing my DSA practice with Striver’s A2Z Sheet / LeetCode problems. Today’s problem focused on forming the smallest possible number by removing k digits, which uses a Greedy approach with a Monotonic Stack. 💡 Key Idea To make the number smallest, we should remove digits that are larger than the next digit. Approach Step 1 – Traverse Digits For every digit remove the larger digit . Step 2 – Push Current Digit If no removal is needed, push the digit into the stack. Step 3 – Handle Remaining Removals If k is still left remove digits from the end . Step 4 – Remove Leading Zeros. Time Complexity : O(N) . Space Complexity : O(N) . GitHub Code :- https://lnkd.in/gi9HrDaH #LeetCode #DSA #StriverA2Z #CodingJourney #Java #Stack #Greedy #MonotonicStack #ProblemSolving #CodingPractice #SoftwareEngineering #TechInterviewPrep #DAY11 #DeveloperJourney

Solved an interesting problem on Leetcode today!! It looks simple at first glance, but asked to solve with O(1) space. The problem asks the array to rotate by k steps initially. I thought it was by k elements, but later I found out it doesn't work in this way. Approach: 1. Reverse the array  2. Reverse from start to start+k  3. Reverse form start+k to end. Key takeaway: This problem really helped me understand how to rotate the array in an efficient way. #Leetcode #DSA #ProblemSolving #CodingJourney #Arrays

🚀 Day 36 — LeetCode Practice 🚀 Today’s focus was on mastering array manipulation and optimizing in-place operations. ✅ Problem solved today: 🔹 Merge Sorted Array 💡 Key learnings from today: • Strengthened understanding of the two-pointer technique • Learned how to merge arrays efficiently without using extra space • Understood why starting from the end prevents overwriting important values • Improved handling of edge cases like empty arrays • Practiced writing clean, optimal, and readable Java code Initially, I thought of creating a separate array to store the merged result. But then I realized the problem could be solved in-place by working backwards from the last index. That shift in approach made the solution more efficient — achieving O(m + n) time complexity with O(1) extra space. This problem reminded me: Optimization isn’t always about adding more — sometimes it’s about using what’s already given in a smarter way. Cleaner logic. Better pointer control. Stronger fundamentals. 💪 On to Day 37 🚀 #Day36 #DSA #LeetCode #ProblemSolving #Java #CodingJourney #Consistency #FutureEngineer

Day 65/100 – #100DaysOfLeetCode 🚀 🧩 Problem: LeetCode 204 – Count Primes (Medium) 🧠 Approach: Create a boolean array to mark prime numbers and iteratively mark multiples of each prime as non-prime. 💻 Solution: class Solution:   def countPrimes(self, n: int) -> int:     if n <= 2:       return 0           isPrime = [True] * n     isPrime[0] = isPrime[1] = False           i = 2     while i * i < n:       if isPrime[i]:         for multiple in range(i * i, n, i):           isPrime[multiple] = False       i += 1           return sum(isPrime) ⏱ Time | Space: O(n log log n) | O(n) 📌 Key Takeaway: The Sieve of Eratosthenes efficiently finds all prime numbers up to n by eliminating multiples of each prime. #leetcode #dsa #development #problemSolving #CodingChallenge

🧩 LeetCode Challenge – Day 77 ✅ Today’s problem was more about careful condition handling and implementation than applying a heavy algorithm. 🔗 LeetCode 3461 The challenge required translating the problem statement precisely into code and making sure all constraints were handled correctly during iteration. 💡 Key Takeaways: • Clear understanding of constraints is crucial for correctness • Simple logic can fail if edge cases are ignored • Writing clean and structured conditions improves reliability #Day77 #LeetCodeChallenge #365DaysOfCode #DSA #CodingJourney #ProblemSolving #Arrays

🚀 Day 37 — LeetCode Practice 🚀 Today’s focus was on strengthening linked list fundamentals and mastering pointer manipulation. ✅ Problem solved today: 🔹 Merge Two Sorted Lists 💡 Key learnings from today: • Strengthened understanding of the two-pointer technique in linked lists • Learned how using a dummy node simplifies head handling • Practiced merging nodes without creating a new list • Improved clarity on pointer movement and reference updates • Handled edge cases like one list being null Initially, I was carefully thinking about how to manage the head of the merged list. Then I realized that using a dummy node removes unnecessary conditional checks and makes the logic much cleaner. That small structural decision made the implementation simpler and more readable — achieving O(n + m) time complexity with O(1) extra space. This problem reminded me: Sometimes clean structure matters more than complex logic. Better pointer control. Cleaner implementation. Stronger linked list foundation. 💪 On to Day 38 🚀 #Day37 #DSA #LeetCode #ProblemSolving #Java #LinkedList #CodingJourney #Consistency #FutureEngineer

🚀 Day 47 – LeetCode practice update Today I solved: • Check if Strings Can Be Made Equal With Operations II Separated characters at even and odd indices for both strings into two arrays. Compared the frequency of characters in even positions and odd positions separately for both strings. If both matched, the strings could be made equal. Time Complexity: O(n) Good practice on using indexing constraints and frequency comparison to simplify the problem. #LeetCode #DSA #Strings #Hashing #ProblemSolving #CodingPractice #Consistency

🚀 Day 38 — LeetCode Practice 🚀 Today’s focus was on number transformation and identifying patterns in repeated operations. ✅ Problem solved today: 🔹 Happy Number 💡 Key learnings from today: • Practiced extracting digits using % 10 and reducing numbers using / 10 • Learned how to compute the sum of squares of digits step by step • Understood how some numbers eventually reach 1, while others fall into a repeating cycle • Strengthened my understanding of loops and number manipulation • Improved logical thinking while handling iterative transformations At first, the problem looked simple — just square the digits and add them. But after a few iterations, I noticed that some numbers keep repeating instead of reaching 1. That observation helped me understand an important concept: Sometimes in algorithms, we must also think about cycles and termination conditions, not just the main computation. This problem reminded me: Good problem solving is not only about writing code — it’s about recognizing patterns in how data changes over time. More practice. Better logic. Stronger fundamentals. 💪 On to Day 39 🚀 #Day38 #DSA #LeetCode #ProblemSolving #Java #CodingJourney #Consistency #FutureEngineer