Max Average Subarray in Java with Sliding Window Technique

100 Days of Coding Challenge – Day 32 📌 Problem: Subarray Product Less Than K 💻 Language: Java 🔍 Platform: LeetCode Approach Used: Sliding Window (Two Pointers) 1. Initialize two pointers (left and right) and a variable to track product 2. Expand the window by moving right and multiply elements 3. If product becomes ≥ k, shrink the window from the left 4. For each valid window, count subarrays using right - left + 1 5. Accumulate the count to get the final answer 👉 Key Insight: If a window is valid, all its subarrays ending at right are also valid Time Complexity: O(n) Space Complexity: O(1) 🔗 Problem Link: https://lnkd.in/gFWbBHeF 🔗 Code Link: https://lnkd.in/gxZF2_JA #100DaysOfCode #Day32 #Java #DSA #LeetCode #ProblemSolving #CodingJourney #SlidingWindow #TwoPointers

100 Days of Coding Challenge – Day 33 🚀 📌 Problem: Longest Mountain in Array 💻 Language: Java 🔍 Platform: LeetCode Approach Used: Peak Expansion / Two Pointers 1. Traverse the array and identify a peak element (greater than both neighbors) 2. From the peak, expand left while elements are increasing 3. Expand right while elements are decreasing 4. Calculate the length of the mountain (right - left + 1) 5. Track the maximum length across all valid peaks Time Complexity: O(n) Space Complexity: O(1) 🔗 Problem Link: https://lnkd.in/gS3Uzs3t 🔗 Code Link: https://lnkd.in/gG8gq2KU #100DaysOfCode #Day33 #Java #DSA #LeetCode #ProblemSolving #CodingJourney #TwoPointers #Array

Day 93 - LeetCode Journey Solved LeetCode 9: Palindrome Number in Java ✅ At first glance, it feels like a string problem… but the real challenge is solving it without converting to string. Instead of reversing the whole number, I reversed only half of it and compared both parts. This avoids overflow and keeps it efficient. Smart approach > brute force 💡 Key takeaways: • Handling edge cases (negative numbers, trailing zeroes) • Reversing only half of the number • Avoiding extra space (no string conversion) • Writing optimized mathematical logic ✅ All test cases passed ⚡ O(log n) time and O(1) space Sometimes the best solutions are the simplest ones, just a different way of thinking 🔥 #LeetCode #DSA #Java #Math #ProblemSolving #CodingJourney #InterviewPrep #Consistency #100DaysOfCode

100 Days of Coding Challenge – Day 30 📌 Problem: Find the Index of the First Occurrence in a String 💻 Language: Java 🧠 Concept Used: String Matching (Brute Force) 🔍 Platform: LeetCode Today’s challenge was to find the first occurrence of a substring (needle) in a given string (haystack). If not found, return -1. Example: Input: "sadbutsad", "sad" Output: 0 Approach: ✔ Traverse the string from index 0 to n - m ✔ Extract substring of length m at each position ✔ Compare it with the target string ✔ Return index immediately when match is found ✔ If no match → return -1 Time Complexity: O(n × m) Space Complexity: O(1) 🔗 Problem Link: https://lnkd.in/g2ktYFFS 🔗 Code: https://lnkd.in/gynFixSQ #100DaysOfCode #Day30 #Java #DSA #LeetCode #Strings #ProblemSolving #CodingJourney

100 Days of Coding Challenge – Day 28 📌 Problem: Find First and Last Position of Element in Sorted Array 💻 Language: Java 🧠 Concept Used: Binary Search (Modified) 🔍 Platform: LeetCode Today’s challenge was to find the starting and ending positions of a target value in a sorted array. If the target is not found → return [-1, -1]. Approach: ✔ Use Binary Search since the array is sorted ✔ Perform two searches:     • One to find the first occurrence     • One to find the last occurrence ✔ Narrow the search space based on comparisons ✔ Combine both results into the final answer Time Complexity: O(log n) Space Complexity: O(1) 🔗 Problem Link: https://lnkd.in/gK5EM63Z 🔗 Code: https://lnkd.in/gMwMsF7R #100DaysOfCode #Day28 #Java #DSA #LeetCode #BinarySearch #Arrays #ProblemSolving #CodingJourney

Day 55 of #100DaysOfLeetCode 💻✅ Solved #434. Number of Segments in a String problem in Java. Approach: • Initialized a counter to track number of words (segments) • Traversed the string character by character • Checked for non-space characters • If the current character is not a space and either it is the first character or the previous character is a space, incremented the count • This ensures counting only the starting of each word Performance: ✓ Runtime: 0 ms (Beats 100% submissions) 🚀 ✓ Memory: 41.83 MB (Beats 99.81% submissions) Key Learning: ✓ Practiced string traversal without using extra space ✓ Learned how to identify word boundaries efficiently ✓ Improved logic building for handling spaces and edge cases Learning one problem every single day 🚀 #Java #LeetCode #DSA #Strings #ProblemSolving #CodingJourney #100DaysOfCode

Day 13 of #LeetCode75 Complete! 75 Days of Coding Topic: Sliding Window Problem: Maximum Average Subarray I Today, I attempted the Maximum Average Subarray I problem on LeetCode using the Java programming language. The problem required me to find the maximum average value among all possible contiguous subarrays of size 𝑘. 🔍 Approach: I did not use the sliding window technique to find the solution to the problem. Instead, I implemented the optimized solution using the prefix sum technique: I created the prefix sum array to store the cumulative sum. I computed the sum of the subarray using the formula: prefix[i] - prefix[i - 𝑘] and divided the maximum sum by 𝑘. 📚 What I learned: I learned how to use the prefix sum array to store the cumulative sum. I learned how to avoid redundant calculations. I learned the different techniques that could be implemented to solve the sliding window problems. 📌 Key Insight: The prefix sum array is helpful in avoiding redundant calculations. #LeetCode75 #LeetCode #Java #DS #SlidingWindow #ProblemSolving

Day 95 - LeetCode Journey Solved LeetCode 1700: Number of Students Unable to Eat Lunch in Java ✅ At first it looks like a simulation problem using queue + stack… but the real trick is to avoid simulation completely. Instead of rotating the queue again and again, I simply counted preferences and matched them with sandwiches. Smart counting beats brute force 💡 Key takeaways: • Avoid unnecessary simulation • Use counting instead of queue operations • Greedy thinking simplifies the problem • Writing clean and optimal logic ✅ All test cases passed ⚡ O(n) time and O(1) space Sometimes the best solution is not doing what the problem is asking literally 🔥 #LeetCode #DSA #Java #Greedy #ProblemSolving #CodingJourney #InterviewPrep #Consistency #100DaysOfCode

Day X of #LeetCode75 Complete! 75 Days of Coding Topic: Sliding Window Problem: Maximum Number of Vowels in a Substring of Given Length I solved the Maximum Number of Vowels in a Substring problem on the LeetCode platform using Java. I had to find the maximum number of vowels present in any substring of size k. 🔍 Approach: I applied the sliding window concept to the problem. Count the number of vowels in the initial window size 𝑘. Slide the window one character at a time. Increment the window size by including the next character. Decrement the window size by removing the leftmost character. Maintain the maximum count during the process. 📚 What I learned: Efficient usage of the sliding window concept for fixed window size. Avoiding redundant computation using the sliding window. Efficient usage of character checking using the vowel set. 📌 Key Insight: Normally, checking all substrings individually would take O(n*m) time. But using the sliding window concept, we can achieve O(n) time complexity. #LeetCode75 #CodingChallenge #Java #DSA #SlidingWindow #ProblemSolving

Day 56/100: Today I revised OOP fundamentals in LLD. - Classes and Objects : - Enums : - Interfaces - Encapsulation - Abstraction - Inheritance - Polymorphism When we are designing any system, these are the important concepts required during LLD. Although Golang is my primary langauage, these are the fundamentals need to be clear. Go is not a traditional object-oriented language like Java or C++ because it lacks classes and hierarchies However, it supports an object-oriented style of programming through struct, methods and interfaces. Time to do it again tomorrow :) #systemdesign #100daysofcode #softwareengineering #consistency