Optimize LeetCode 3013 with Sliding Window Technique

This is demo for my Algorithm class where we would take a couple of algorithms and visualize them in a python program to demonstrate how fast they each run both on runtime and with visual feedback. The main goal was to demonstrate big O notation through visuals and including the time each one took. We would randomize the numbers and pass them through the algorithms to see how they ran, how fast they ran and organized them. It was clear that with big data sets Quick and merge were the best at handling larger and more scattered sets. One of the key takeaways was seeing just how each was useful in its own way and how even one that is clearly much faster than the rest like merge or quick would maybe be overkill when it comes to smaller changes which bubble sort would be better at #CSUF #AlgorithmEngineering #Spring2026

LeetCode Problem 19: "Given the head of a linked list, remove the nth node from the end of the list and return its head." The below implementation is simple and clear- Approach Double traverse the list, once to calculate the length of the list and second time to find the position of the node to be deleted. Maintain two pointers at each iteration, one to keep track present node and second to keep track of previous node. position is calculated by using the formula: pos = (len of list-n)+1 Complexity Time complexity: O(m) where m is length of list Space complexity: O(1) i.e. constant #Python #LeetCode #CompetitiveProgramming #TwoPointers #ProblemSolving #LinkedList #Algorithms #DataStructures

🔥 Day 30 of #100DaysOfCode 📌 LeetCode 26 – Remove Duplicates from Sorted Array Today’s problem focused on in-place array manipulation and strengthening the two-pointer technique. 🧠 Problem Summary Given a sorted array, remove duplicates such that each unique element appears only once. Return the count of unique elements (k). Important: Do it in-place with O(1) extra space. 💡 Key Insight Because the array is already sorted, duplicates are always adjacent. So instead of checking all elements repeatedly: 👉 Compare current element with previous one. 👉 If different → place it at the next unique index. This is where the Two Pointer Approach shines: Pointer i → traverses array Pointer k → tracks position of next unique element 📊 Complexity ⏱ Time: O(n) 📦 Space: O(1) Consistency > Motivation 30 Days Done. Still going strong 💪 #Day30 #LeetCode #DSA #100DaysOfCode #Python #CodingJourney

#Day - 32 LeetCode #334 – Increasing Triplet Subsequence (Medium) In this problem, the goal was to determine whether an array contains an increasing triplet subsequence in O(n) time and O(1) space complexity. 🔹 Approach Used: Maintained two variables (first and second) initialized to infinity. Iterated through the array once. Updated first and second dynamically. Returned True when a valid third element was found. This problem strengthened my understanding of: ✅ Greedy algorithms ✅ Optimized space complexity ✅ Efficient single-pass solutions ✅ Logical thinking for edge cases Under the Guidance of : Rudra Sravan kumar #LeetCode #ProblemSolving #Python #DataStructures #Algorithms #CodingJourney #SoftwareDeveloper

LeetCode Problem 83: Given the head of a sorted linked list, delete all duplicates such that each element appears only once. Return the linked list sorted as well. The below implementation in Python successfully resolves this in time complexity of O(n) where n is length of the list with constant space complexity. The approach is simple, handle the base case first like list having 0 or 1 number of nodes and then write the logic of handling lists of length greater than one. Maintain two pointers, one to keep track of present node and other to keep track of previous node. Check if the value of both nodes match or not, if match update the pointing of previous node, point its next to the present.next. #LeetCode #LinkedList #Python #CompetitiveProgramming #Algorithms #DataStructures #ProblemSolving

LeetCode Problem 1404: "Number of steps to reduce a number in binary representation to one": Given the binary representation of an integer as a string s, return the number of steps to reduce it to 1 under the following rules: If the current number is even, you have to divide it by 2. If the current number is odd, you have to add 1 to it. Approach: First convert the given binary string to decimal using int() function with base '2'. Then use a while loop, at each iteration check if the number is even divide it by 2, if it is odd add one to it, the loop continues until the number equals to one, a variable "count" initiated to 0 is incremented at each loop, return the "count" variable, simple and straightforward. #LeetCode #Python #Strings #CompetitiveProgramming #ProblemSolving #Algorithms #DataStructures #OptimalSolution #Coding

Solved an interesting array problem using prefix sums + hash maps 🚀 This solution efficiently finds the longest subarray based on a comparison condition (arr[i] > k) by converting the problem into a prefix sum balance and tracking first occurrences with a hashmap. ✅ O(n) time complexity ✅ Smart use of prefix sums ✅ Great example of turning a complex condition into a simple math problem Always fun when problem-solving meets optimization! 💻📊 #Python #DataStructures #Algorithms #CodingInterview #ProblemSolving #100DaysOfCode

🚀 Day 42 / 200 – Minimum Window Substring (Hard) Solved LeetCode 76 – Minimum Window Substring today! 💪 This problem was a great test of Sliding Window + HashMap concepts. The challenge was to find the smallest substring that contains all characters of another string (including duplicates). 🔎 Key Learnings: Mastered the two-pointer (left & right) sliding window technique Used frequency counters to track required characters Optimized window shrinking to ensure minimum length Improved understanding of handling duplicate character constraints ✅ 268 / 268 test cases passed ⚡ Runtime: 75 ms 🐍 Language: Python Problems like this strengthen real-world problem-solving skills and improve optimization thinking. Consistency > Motivation. 200 Days. No excuses. 💯 #Day42 #200DaysChallenge #LeetCode #Python #DataStructures #Algorithms #SlidingWindow #ProblemSolving #CodingJourney

🚀 Day 5/30 | LeetCode Problem: Repeated Substring Pattern (459) Problem: Given a string s, check if it can be constructed by repeating one of its substrings multiple times. Approach (Smart String Trick): Concatenate the string with itself → (s + s) Remove the first and last characters If the original string s exists inside this new string, then it is made of a repeating substring This works because repeating patterns always reappear in the middle of (s + s). Sometimes, clever observations can replace complex loops and conditions. 📌 Accepted ✅ | All test cases passed 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day5 #Python #Strings #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering #TechCommunity