☁️ Lee Skillen’s Post

Hi LinkedIn connections! 👋 I’ve been exploring Python further on my LeetCode journey, and I recently came across an intriguing problem: Contains Duplicate II. Problem: Given an array of integers and an integer k, determine if there are two distinct indices i and j in the array such that: nums[i] == nums[j] abs(i - j) <= k Approach: To solve this efficiently, I used the sliding window technique with a set to maintain a dynamic range of elements. Here’s the step-by-step logic I followed: -Use a set (window) to store elements within the allowed range k. -Iterate through the array while ensuring that the size of the window does not exceed k. -If the current number is already in the window, we’ve found a duplicate within the range, so return True. -Otherwise, add the current number to the window and continue. -Remove elements that are out of the allowed range as we slide the window. -If no duplicates are found after traversing the array, return False. Here’s the problem link and my solution: https://lnkd.in/dSxMNj6N Every day, I’m excited to see how concepts like algorithms and logic come together to make problem-solving fun and efficient! 🚀 #Python #LeetCode #CodingJourney #ProblemSolving #Algorithms

🌟 Day 66 of 100 Days of LeetCode Challenge Today, I tackled the "Patching Array" problem on LeetCode, focusing on greedy algorithms to ensure the array can represent every number up to a given target in Python. 🔍 Problem Description: The task was to determine the minimum number of patches (numbers added) needed for an array such that every number in the range [1, n] can be formed by the sum of some subset of the array. 🛠️ Solution Approach: To solve this problem, I used a greedy algorithm: 1. Initializing Variables:   - Initialized variables for tracking the current range (`miss`), the number of patches added (`patches`), and the current index in the array. 2. Iterating Through the Array:   - Iterated through the array, adding elements to cover ranges of numbers.   - If the current element in the array is greater than `miss`, a patch (the current `miss` value) is added to extend the range.   - If the current element is less than or equal to `miss`, the range is extended by adding the current element.   - Updated the `miss` value and continued until the range covers all numbers up to `n`. 3. Counting Patches:   - Counted the total number of patches added to achieve the desired range coverage. 🚀 Key Learnings: - Enhanced my understanding of greedy algorithms and their application in covering ranges with minimal additions. - Practiced efficient iteration and condition checking to manage the range coverage. - Improved problem-solving skills by implementing a strategy to ensure complete coverage of numbers up to a target value. This challenge was a valuable exercise in greedy algorithms and range management, further strengthening my proficiency in Python programming. Looking forward to more interesting and challenging problems ahead! #100DaysOfLeetCode #PythonProgramming #LeetCode #Algorithm #ProblemSolving #GreedyAlgorithm #PatchingArray

🌟 Day 62 of 100 Days of LeetCode Challenge Today, I tackled the "Sort Colors" problem on LeetCode, focusing on sorting techniques and in-place array manipulation in Python. 🔍 Problem Description: The task was to sort an array of integers where each element is 0, 1, or 2, representing the colors red, white, and blue respectively. The goal was to sort the array in-place so that elements of the same color are adjacent and in the order of red, white, and blue. 🛠️ Solution Approach: To solve this problem, I used the Dutch National Flag algorithm, which efficiently sorts the array in a single pass: 1. Initializing Pointers:   - Used three pointers: low, mid, and high.   - The low pointer tracks the boundary of 0s (reds), the mid pointer processes the current element, and the high pointer tracks the boundary of 2s (blues). 2. Sorting In-Place:   - Iterated through the array with the mid pointer.   - If the element at mid is 0, swapped it with the element at low and incremented both low and mid pointers.   - If the element at mid is 1, simply moved the mid pointer.   - If the element at mid is 2, swapped it with the element at high and decremented the high pointer. 3. Completing the Sort:   - Continued the process until the mid pointer surpassed the high pointer, ensuring all elements were correctly sorted in-place. 🚀 Key Learnings: - Enhanced my understanding of in-place sorting techniques and the Dutch National Flag algorithm. - Practiced efficient array manipulation using multiple pointers in Python. - Improved problem-solving skills by implementing a linear time sorting algorithm. This challenge was a valuable exercise in in-place sorting and array manipulation, further strengthening my proficiency in Python programming. Looking forward to more interesting and challenging problems ahead! #100DaysOfLeetCode #PythonProgramming #LeetCode #Algorithm #ProblemSolving #Sorting #InPlaceSorting #SortColors

Day 91 of 100 Days of LeetCode Challenge Today, I tackled the "Reverse Substrings Between Each Pair of Parentheses" problem on LeetCode, using Python to manipulate strings and stacks. 🔍 Problem Description: The task was to reverse the substrings within each pair of parentheses in a given string. The solution should consider nested parentheses and reverse the contents accordingly. 🛠️ Solution Approach: To solve this problem, I used a stack to manage the string segments and handle the nested structures efficiently: 1. Initialization:   - Initialized an empty stack to keep track of the characters and reversed segments. 2. Iterating Through the String:   - Iterated through each character in the string:    - If the character was '(', pushed a marker onto the stack to signify the start of a new segment.    - If the character was ')', popped characters from the stack until encountering the marker '(', reversed the segment, and then pushed the reversed segment back onto the stack.    - If the character was any other character, pushed it directly onto the stack. 3. Reconstructing the Result:   - After processing all characters, concatenated the remaining elements in the stack to form the final result. 🚀 Key Learnings: - Enhanced my understanding of stack data structures and their applications in string manipulation. - Practiced efficient string operations and handling nested structures. - Improved problem-solving skills by implementing a strategy to reverse substrings based on nested parentheses. This challenge was a valuable exercise in string manipulation and stack usage, further strengthening my proficiency in Python programming. Looking forward to more interesting and challenging problems ahead! #100DaysOfLeetCode #PythonProgramming #LeetCode #Algorithm #ProblemSolving #Stack #StringManipulation

🚀 LeetCode Day 32: Valid Anagram🚀 I tackled a fun problem today: Checking if two strings are anagrams of each other. An anagram occurs when one string contains exactly the same characters as another, but in any order. It's a great exercise to improve your understanding of strings, hash maps, and efficiency! Here’s the approach I took: 1️⃣ Check Lengths First: If the lengths of the two strings are not the same, they can't be anagrams, so I return False right away. 2️⃣ Count Characters: I created a dictionary to count the occurrences of each character in the first string, s. 3️⃣ Compare with Second String: As I loop through the second string, t, I decrease the count for each character in the dictionary. If any character doesn’t exist or its count goes negative, I know the strings aren’t anagrams. 4️⃣ Final Check: After processing both strings, if the dictionary is empty, the strings are anagrams. Otherwise, they aren’t. 💡 Time Complexity: O(n), where n is the length of the strings. This is because we only loop through each string once. 💡 Space Complexity: O(n) due to the dictionary storing counts for each unique character. While the solution works efficiently, I’m thinking about potential improvements: 🔧 Optimization: Perhaps I could avoid using a dictionary entirely and work with simpler methods, like sorting both strings and comparing them, though this could impact performance. 🔧 Code Simplification: There's always room to simplify or add edge-case handling, especially for empty strings. I’d love to hear how others approached this problem! Drop your solutions or thoughts in the comments. 💬 #CodingJourney #Algorithms #DataStructures #ProblemSolving #ProgrammingChallenges #Anagram #Python

🎯 Challenge Completed: Day 112 🎯 Today's LeetCode challenge, "Check If a Word Occurs As a Prefix of Any Word in a Sentence," was a fascinating dive into string manipulation and prefix search! 🌟 This problem required traversing a sentence and pinpointing the first occurrence of a word starting with a given prefix. 1️⃣ Split the Sentence: Used Python's split() function to break the sentence into a list of words. 2️⃣ Enumerate for Position: Iterated through the words with their indices for an easy lookup. 3️⃣ Prefix Check: Leveraged the startswith() function to identify if the current word starts with the given prefix. 4️⃣ Return the Result: Returned the 1-based index of the match or -1 if no match was found. This problem highlighted the elegance of Python's built-in string functions for handling text-related tasks. Simplicity and clarity were key to crafting this solution! ✨ #Day112 #LeetCodeChallenge #ProblemSolving #CodingJourney #StringManipulation #TechSkills #DailyCoding #PythonProgramming #PrefixSearch #LearnAndGrow #CodeSimplified #CodingLife

🚀 Today's LeetCode Problem: Sentence Similarity! 🚀 I worked on a problem where I had to determine if two sentences are similar by comparing their words from both the start and the end. The key part of the solution involved understanding how to use pointers and comparing words in reverse. 💻 Here’s a breakdown of the logic: ---> Split the sentences into words --->Compare words from both the beginning and end --->Check if the number of matching words from the start and end is enough to confirm similarity Here’s a snippet of the code: def areSentencesSimilar(self, sentence1: str, sentence2: str) -> bool:   word1 = sentence1.split()   word2 = sentence2.split()   if len(word1) < len(word2):     word1, word2 = word2, word1   start, end = 0, 0   n1, n2 = len(word1), len(word2)   while start < n2 and word1[start] == word2[start]:     start += 1   while end < n2 and word1[n1 - end - 1] == word2[n2 - end - 1]:     end += 1   return start + end >= n2 This helped me solidify my understanding of handling pointers in Python while solving string manipulation problems. The most challenging part was the comparison from the end of the list, but after breaking it down, it made sense! #LeetCode #Python #ProblemSolving #CodingJourney #WebDevelopment #KeepLearning

🚀 Day 32 of 100 days of code 🚀 🎊 Today’s Highlights: - List Management: We created a list that stores greetings in different languages, starting with our native language and expanding to others. - Random Number Generation: We utilized Python's random module to randomly select a greeting from the list. - User-Friendly Output: The random greeting was displayed using an f-string for clear, formatted output. - Language Exploration: The exercise helped us expand our knowledge of greetings in different cultures and languages. 🔍 Key Concepts: - Lists: Storing multiple items of any data type in a collection, making it easy to manage and access data. - Random Module: Understanding how to generate random numbers within a specific range using Python's built-in random library. - F-Strings: Using f-strings for inserting variables into strings, ensuring clean and readable output. - Indexing Lists: Understanding how to use list indices and how the list starts at index 0, making it easy to access any item in the list. Day 32 of #Replit100DaysOfCode #Python #Programming #Coding

🌟 Day 36 of 118 Days of Consistency - LeetCode Challenge! 🌟 Another day, another problem solved! Today, I worked on LeetCode Problem 1662 - Check If Two String Arrays are Equivalent. 💻 Problem Overview: The task was to determine whether two string arrays, word1 and word2, represent the same concatenated string. Essentially, if joining all the strings in word1 gives the same result as joining all the strings in word2, then the arrays are equivalent. 🧠 Approach & Solution: I initialized two empty strings, string1 and string2, to hold the concatenated results of the two arrays. Using a loop, I iterated through each word in word1 and appended it to string1. Similarly, I iterated through word2 and appended its words to string2. Finally, I compared string1 and string2. If they were identical, the function returned True; otherwise, it returned False. ⚡ Performance Highlights: Runtime: 0 ms (🥇 Beats 100% of all submissions!). Memory Usage: 12.56 MB (💡 Beats 17.23% of submissions). 🎯 Reflections & Learnings: This problem reminded me of the power of breaking tasks into small, logical steps. Although the solution is straightforward, it emphasizes the importance of writing clean, readable code for simple tasks like string concatenation and comparison. It's also a great example of how Python’s string operations make such problems intuitive to solve! 🚀 Next Steps: Explore alternative approaches, like using join() to directly concatenate the arrays or optimizing memory usage further. #LeetCodeChallenge #Day36 #118DaysOfConsistency #Python #StringManipulation #ProblemSolving #KeepLearning