Top K Frequent Elements LeetCode Challenge

🚀 Day 48 of my #100DaysOfCode Journey Today, I solved the LeetCode problem: Sort Array By Parity Problem Insight: Rearrange the array so that all even numbers come before odd numbers. The order of elements doesn’t matter. Approach: • Used the two-pointer technique (partition logic) • Maintained a pointer j to track the position for even numbers • Traversed the array using i • Whenever an even number is found, swapped it with index j and incremented j • This ensures all even elements move to the front in a single pass Time Complexity: O(n) Space Complexity: O(1) (in-place solution) Key Learnings: • Two-pointer technique is very useful for array partitioning problems • Swapping helps avoid extra space usage • This pattern is similar to problems like moving zeros or segregating positives/negatives Takeaway: Simple logic + optimal approach = clean and efficient solution. Consistency is making these patterns easier to recognize! #DSA #Java #LeetCode #100DaysOfCode #CodingJourney

🚀 Day 33 of #128DaysOfCode 🧩 Problem Insight: The goal was to check whether a given string can be formed by repeating one of its substrings multiple times. 💡 Key Learning: Instead of checking all possible substrings (which can be inefficient), I learned an elegant trick: By concatenating the string with itself and removing the first and last characters, we can determine if the original string exists within it. ⚡ This approach helped me: - Improve my understanding of string patterns - Learn a smart optimization technique - Avoid brute-force solutions 🛠️ Concepts Practiced: - String manipulation - Pattern recognition - Optimized problem-solving approach 📈 Every day I’m getting better at identifying patterns and writing cleaner, more efficient code. #Day33 #128DaysOfCode #Java #DSA #CodingJourney #ProblemSolving #LeetCode

Day 51/100 – LeetCode Challenge Problem: Third Maximum Number Today I solved the “Third Maximum Number” problem, which focuses on identifying the third distinct maximum value in an array. The key challenge here was handling duplicates while keeping track of the top three distinct values. Instead of sorting the array directly, I used a set to eliminate duplicates first. This simplified the problem by ensuring that only unique values were considered. From there, I handled two cases. If there were fewer than three distinct numbers, I returned the maximum. Otherwise, I iterated through the set and tracked the top three maximum values using variables, updating them as I encountered larger numbers. This approach avoids unnecessary sorting and keeps the logic efficient and controlled. The solution runs in O(n) time with O(n) space complexity due to the set. This problem reinforced the importance of handling duplicates carefully and thinking about edge cases before jumping into implementation. Fifty-one days in. The focus is now on writing cleaner logic with fewer assumptions. #100DaysOfLeetCode #Java #DSA #Arrays #ProblemSolving #Consistency

🚀 Day 66 of #LeetCode Challenge ✅ Problem Solved: Divide a String Into Groups of Size K 💡 What I learned today: • Learned how to break a string into fixed-size groups • Understood how to handle incomplete groups using a fill character • Practiced building strings step-by-step using loops • Improved clarity on index handling and conditions 🧠 Approach: • Traverse the string one character at a time • Build a group until it reaches size k • Store the group and reset • If the last group is smaller, fill remaining positions with the given character 📊 Key Takeaway: Handling edge cases (like incomplete groups) is very important in problem solving 🔥 Consistency is the key — improving step by step every day! #Day66 #LeetCode #CodingJourney #DSA #Java #ProblemSolving #Consistency

Day 90 - LeetCode Journey Solved LeetCode 2181: Merge Nodes in Between Zeros in Java ✅ This problem is all about smart traversal and building a new linked list on the go. I used a dummy node + running sum approach. As I traversed the list, I kept adding values until I hit a zero. Once a zero appeared, I created a new node with the accumulated sum and reset the sum for the next segment. Clean, intuitive, and efficient. Key takeaways: • Using dummy node to simplify list construction • Handling segments using running sum • Clean traversal without extra data structures • Strong understanding of linked list manipulation ✅ All test cases passed ⚡ O(n) time and O(1) extra space Problems like this improve your ability to think in segments and patterns 🔥 #LeetCode #DSA #Java #LinkedList #ProblemSolving #CodingJourney #InterviewPrep #Consistency #100DaysOfCode

𝐃𝐚𝐲 𝟕𝟕 – 𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 | 𝐀𝐫𝐫𝐚𝐲𝐬 🚀 Today’s problem focused on finding all elements that appear more than n/3 times in an array. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝 • Majority Element II 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 – 𝐇𝐚𝐬𝐡𝐌𝐚𝐩 • Counted frequency of each element using a map • Calculated threshold = n / 3 • Collected elements whose frequency exceeded the threshold 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 • At most 2 elements can appear more than n/3 times • HashMap is straightforward for frequency counting • Understanding constraints helps reduce possibilities • This problem has an optimized Boyer-Moore Voting (extended) solution 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 • Time: O(n) • Space: O(n) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲 Constraints often reveal hidden patterns — understanding them leads to better optimizations. 77 days consistent 🚀 On to Day 78. 🔗 Problem Link: https://lnkd.in/dDwdWYJs #DSA #Arrays #HashMap #LeetCode #Java #ProblemSolving #DailyCoding #LearningInPublic #SoftwareDeveloper

🚀 Day 69 — LeetCode Practice 🚀 Today’s focus was on string manipulation and careful indexing. ✅ Problem solved today: 🔹 Find Common Characters 💡 Key learnings from today: • Understood how to find common characters across multiple strings • Learned the importance of character frequency counting • Practiced handling nested loops efficiently • Realized how small mistakes in indexing can affect the entire logic • Improved attention to detail while working with strings Initially, I made a mistake by using the wrong variable inside charAt(). This caused incorrect indexing, which can either lead to wrong output or even StringIndexOutOfBoundsException. After fixing it, the logic worked perfectly by correctly comparing characters and tracking their minimum frequency across all words. This problem reinforced an important lesson: Sometimes errors are not in logic — but in small details like indexing and variable usage. Accuracy matters as much as logic. Step by step, getting better 💪 On to Day 70 🚀 #Day69 #DSA #LeetCode #ProblemSolving #Java #CodingJourney #Consistency #FutureEngineer

Day 83 of #100DaysOfCode Today’s problem: Ugly Number An ugly number is a positive integer whose prime factors are limited to 2, 3, and 5. Approach: Instead of checking all factors, I kept dividing the number by 2, 3, and 5 repeatedly: If the number reduces to 1 → it’s ugly ✅ If something else remains → not ugly ❌ 🔍 Key Insight: Efficient problem-solving is often about reducing complexity, not increasing checks. 🧠 What I learned: How to simplify factor-based problems Importance of repeated division in optimization Writing clean and efficient logic ⚡ Example: 6 → 2 × 3 → Ugly ✅ 14 → includes 7 → Not Ugly ❌ Consistency is slowly building confidence 💪 On to Day 84! #DSA #Java #CodingJourney #ProblemSolving #LeetCode #100DaysOfCode

🚀 100 Days of Code Day -27 LeetCode Problem solved- Divide Two Integers Solved this interesting problem where division is performed without using multiplication, division, or mod operators. 💡 Key Learnings: Used bit manipulation (left shift) to optimize repeated subtraction Handled edge cases like overflow (Integer.MIN_VALUE) Achieved efficient solution with O(log n) complexity 📌 This problem really strengthens understanding of low-level operations and optimization techniques. Always fascinating to see how basic operations can be built from scratch! #LeetCode #Java #DSA #CodingInterview #ProblemSolving

🚀 LeetCode Challenge 3/50 💡 Approach: Two Pointer (In-Place) The straightforward way uses an extra array — but the problem specifically says no copying! So I used the Two Pointer technique to solve it in-place with a single pass. 🔍 Key Insight: → Use a 'left' pointer to track where the next non-zero element belongs → Traverse with 'right' pointer — place non-zeros at left, then increment → Fill remaining positions with 0s at the end 📈 Complexity: ✅ Time: O(n) — single pass ✅ Space: O(1) — no extra array, truly in-place Sometimes the constraint IS the optimization. Working within limits pushes us to think smarter! 🧠 #LeetCode #DSA #TwoPointer #Java #ADA #PBL2 #LeetCodeChallenge #Day3of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #MoveZeroes