Tushar Koundal’s Post

Day 34/100 – LeetCode Challenge 🚀 Problem: Container With Most Water Approach: Used two pointers (left & right) Calculated area using min(height[left], height[right]) × width Moved the pointer pointing to the smaller height Updated maximum area during traversal Time Complexity: O(n) Space Complexity: O(1) Key takeaway: When maximizing area between two boundaries, moving the smaller boundary is the only way to potentially increase the result. #LeetCode #100DaysOfCode #DSA #Java #TwoPointers #ProblemSolving

Day 30/100 – LeetCode Challenge 🚀 Problem: Count Binary Substrings Approach: Counted consecutive groups of 0’s and 1’s For every adjacent pair of groups, added min(prevGroup, currGroup) to the result Avoided generating substrings explicitly Time Complexity: O(n) Space Complexity: O(1) Key takeaway: Many substring problems don’t require generating substrings — they can be solved by analyzing group patterns and transitions. #LeetCode #100DaysOfCode #DSA #Java #Strings #ProblemSolving

🚀 Day 39 / 100 | Non-overlapping Intervals -Intuition: -The goal is to remove the minimum number of intervals so that the remaining intervals do not overlap. -The idea is to always keep the interval that ends earlier because it leaves more space for future intervals. -If an interval overlaps with the previous selected interval, remove it. -Approach: O(n log n) -Sort all intervals based on their ending time. -Initialize last to track the end of the last selected interval. -Traverse through the intervals starting from the second interval. -If the current interval's start is less than the last end, it means overlap exists, remove the interval.(count++) -Otherwise, update last end to the current interval’s end. -Return the count of removed intervals. -Complexity: Time Complexity: O(n log n) Space Complexity: O(1) #100DaysOfCode #Java #DSA #LeetCode #Greedy

Solved "Container With Most Water" on LeetCode today using the Two-Pointer Technique. 🚀 The key insight is that the area formed by two lines depends on the shorter height and the distance between them. Starting with pointers at both ends of the array, we compute the area and move the pointer at the smaller height inward to potentially find a taller boundary and maximize the area. This approach efficiently reduces the problem from O(n²) brute force to O(n) time with O(1) space. Problems like this are a great reminder that the right observation can drastically optimize a solution. 💡 #LeetCode #DSA #TwoPointers #Java #ProblemSolving

Day 26/100 – LeetCode Challenge 🚀 Problem: Remove Duplicates from Sorted List Approach: Traversed the linked list using a pointer Compared each node with its next node Skipped the next node whenever duplicate values were found Time Complexity: O(n) Space Complexity: O(1) Key takeaway: When a linked list is sorted, duplicate removal becomes a simple one-pass pointer manipulation problem. #LeetCode #100DaysOfCode #DSA #Java #LinkedList #ProblemSolving

🚀 Day 27 of My LeetCode Journey 📌 Problem: Maximum Product of Three Numbers (LeetCode 628) Today’s challenge was to find the maximum product of any three numbers in an integer array. The important observation is that the maximum product can come from: • The three largest numbers, or • The two smallest numbers (negative values) multiplied by the largest number. 🧠 Approach Used: Single Pass (Tracking Maximum & Minimum Values) Instead of sorting the array, we iterate through the array once and keep track of: The three largest numbers The two smallest numbers Finally, we compute the maximum between: 1️⃣ max1 × max2 × max3 2️⃣ min1 × min2 × max1 ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) This approach avoids sorting and efficiently finds the result in a single traversal of the array. #Day27 #LeetCode #DSA #Java #ProblemSolving #CodingJourney

🚀 Day 20 – #100DaysOfLeetCode Today’s problem: Product of Array Except Self (Medium) 🔹 Learned how to solve it in O(n) time 🔹 Without using division 🔹 Optimized space complexity The key idea was using prefix and suffix products instead of recalculating product every time. #Day20 #LeetCode #DSA #Java #CodingJourney

🚀 Day 19 of #100DaysOfCode Solved 2. Add Two Numbers on LeetCode ➕🔗 (in-place linked list approach) 🧠 Key insight: Instead of creating a new list, we can reuse the longer linked list and perform addition in place, handling carry carefully across nodes. ⚙️ Approach: 🔹Calculate the size of both linked lists 🔹Use the longer list as the result list 🔹Traverse both lists, adding values with carry 🔹Continue processing remaining nodes of the longer list 🔹Append a new node if a carry remains at the end ⏱️ Time Complexity: O(max(n, m)) 📦 Space Complexity: O(1) (no extra list created) #100DaysOfCode #LeetCode #DSA #LinkedList #Java #ProblemSolving #LearningInPublic #CodingJourney

🚀Day 12/30 LeetCode 190 | Reverse Bits (Easy) A classic bit manipulation problem that tests your understanding of binary operations and shifting. 💡 Key Concept Used: Bitwise AND (&) to extract the last bit Unsigned right shift (>>>) to move bits safely Left shift (<<) to build the reversed number #LeetCode #BitManipulation #Java #DSA #CodingInterview #ProblemSolving #SoftwareEngineering #Day12

🚀 Day 25 of #100DaysOfCode Solved 24. Swap Nodes in Pairs on LeetCode 🔗🔄 🧠 Key insight: Swapping nodes in a linked list doesn’t require extra memory—careful pointer updates are enough to reverse every adjacent pair. ⚙️ Approach: 🔹Traverse the list two nodes at a time 🔹Reverse links between each adjacent pair 🔹Maintain connections with the previous pair to keep the list intact 🔹Handle edge cases for odd-length lists ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #LinkedList #Java #ProblemSolving #LearningInPublic #CodingJourney