Binary Search Optimizes LeetCode 1283 Solution

🚀 Day 147 | Frequency Counting Across Multiple Strings Today’s problem was a clean exercise in comparing character frequencies across multiple inputs. 🧩 Problem Solved: 1002. Find Common Characters 🔍 Approach: • Initialized a frequency array using the first word. • For each subsequent word, counted character frequencies and kept the minimum count for each character. • Constructed the result by adding each character as many times as its final minimum frequency. ✨ Key Insight: Using minimum frequency across all strings ensures only truly common characters are included. 📚 Topics: Hashing · Strings · Frequency Counting 💻 Platform: LeetCode #LeetCode #DSA #ProblemSolving #DailyCoding #Strings #Hashing #Java #Consistency

🔹 Day 96 – LeetCode Practice 📌 Problem: First Missing Positive (LeetCode #41) 📊 Difficulty: Hard 🧠 Problem Overview: Given an unsorted integer array, the task is to find the smallest positive integer that is missing from the array. The challenge lies in solving it efficiently with strict constraints on time and space. ✅ Approach Used: Stored all values from the array for quick lookup. Iterated from the smallest possible positive integer to identify the first missing value. Returned the earliest number that was not present. 📈 Submission Results: Status: Accepted ✅ Runtime: 14 ms Memory Usage: 93.44 MB 💡 Reflection: This problem highlights the importance of understanding constraints clearly. While multiple approaches exist, optimizing time and space is the key learning takeaway from this question. #LeetCode #DSA #ProblemSolving #Arrays #Java #CodingJourney #Consistency

Day 6 of #100DaysOfLeetCode 🚀 Today’s challenge was 4Sum — finding all unique quadruplets in an array that add up to a target value. 🔍 Key takeaways: Sorting the array simplifies the problem Using two nested loops + two pointers reduces time complexity Handling duplicates correctly is crucial to avoid repeated results Careful use of data types (like long) prevents overflow issues 💡 Problems like these really reinforce how powerful the two-pointer technique can be when combined with sorting. On to Day 7 — staying consistent and learning one problem at a time 💪 #Day6 #LeetCode #DSA #Java #ProblemSolving #Consistency #CodingJourney

🔹 Day 97 – LeetCode Practice 📌 Problem: Divide Array Into Equal Pairs (LeetCode #2206) 📊 Difficulty: Easy 🧠 Problem Overview: You’re given an integer array containing 2n elements. The goal is to check whether the array can be divided into n pairs such that: Every element is used exactly once Both elements in each pair are equal ✅ Approach Used: Sorted the array to bring identical elements together. Traversed the array while counting occurrences of each number. Verified that every number appears an even number of times, ensuring valid pairs. 📈 Submission Results: Status: Accepted ✅ Runtime: 8 ms Memory Usage: 46.94 MB 💡 Reflection: This problem is a great reminder that sorting can simplify pairing logic significantly. Once the array is ordered, validating pairs becomes straightforward and efficient. #LeetCode #ProblemSolving #Arrays #Java #DSA #CodingPractice #Consistency

🧠 Day 76 of #100DaysOfLeetCode 📌 Problem: Combination Sum II 📊 Difficulty: Medium 💡 Key Insight: Sorting the array helps handle duplicates. While backtracking, duplicates are skipped only in the “not pick” path to ensure unique combinations. 🛠️ Approach: Sort the candidates array Use backtracking to explore combinations Each number can be used once → move to index + 1 Skip duplicate elements to avoid repeated combinations ⏱️ Complexity: Time: O(2^n) Space: O(n) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

Day 42 — LeetCode 215 | Kth Largest Element in an Array (Java) Solved the problem using a Min Heap (PriorityQueue) instead of sorting. Why? Because sorting works, but it’s not optimal. 🔹 Took user input for array size, elements, and k 🔹 Maintained a heap of size k 🔹 Returned the kth largest element efficiently Complexity matters: • Time — O(n log k) • Space — O(k) This approach scales better and is closer to what interviewers expect when they say “optimize your solution.” Building problem-solving depth one question at a time. 🚀 #DSA #Java #LeetCode #PriorityQueue #Heap #DataStructureAndAlgorithm #ProblemSolving #CodingJourney #DailyPractice

🌟 Day 29/30 – Add Two Numbers Approach: Instead of handling multiple loops for different list lengths, I used one single loop. At each step, I: Added values from both lists (if present) Included the carry Created a new node with sum % 10 Updated carry using sum / 10 Missing nodes are treated as 0, which simplifies the logic a lot. Complexity: Time: O(max(n, m)) Space: O(max(n, m)) Key Takeaway: A dummy node + single loop can replace multiple edge-case loops and make the solution much cleaner. #DSA #LeetCode #Java #LinkedList #ProblemSolving #Day29 #30DayChallenge #Coding

🌟 Day 18/30 – Next Greater Element I Approach: used monotonic decreasing stack. When the current number is greater than the stack’s top, pop and map that popped value to the current number (its next greater). Remaining stack elements have no next greater → map them to -1. Build the result for nums1 using the map. Complexity: Time: O(n + m) Space: O(n) Key Takeaway: Monotonic stacks help solve “next greater/smaller” problems efficiently in linear time. #Day18 #DSA #Java #LeetCode #ProblemSolving #30DayChallenge

🚀 DSA Series – Day 29 📌 Problem: Find the Duplicate Number (LeetCode) Today I worked on a classic array problem where the goal is to find the single duplicate number in an array containing n+1 integers from 1 to n. 🧠 What I learned Instead of sorting or nested loops, we can use a frequency array to track how many times each number appears. If a number appears more than once, that is our duplicate. 💡 My Approach -Create an extra array to store counts -Traverse the input array and increase the count -Scan the count array to find the value with frequency > 1 ⏱ Complexity Time: O(n) Space: O(n) #DSA #LeetCode #Java #ProblemSolving

Day 45/100 – #100DaysOfCode 🚀 Solved Remove All Adjacent Duplicates in String (LeetCode) using a Stack. Approach : -> Traverse the string character by character. -> If the stack is not empty and the top character is the same as the current one → pop it (remove the duplicate). -> Otherwise, push the current character onto the stack. -> After processing the full string, the stack contains the final characters (in reverse order). -> Build the result by popping from the stack and reversing it. This approach works in O(n) time and avoids unnecessary comparisons. #DSA #Stacks #LeetCode #ProblemSolving #Java #LearningEveryday #100DaysOfCode