Solved LeetCode 290 Word Pattern with Python

Day 55/100 – #100DaysOfCode 🚀 Solved LeetCode #205 – Isomorphic Strings (Python). Today I practiced hashmap (dictionary) usage to check whether two strings follow the same pattern. Approach: 1) Create two hashmaps to store character mappings in both directions. 2) Traverse both strings together using zip(). 3) Check if the current mapping is consistent in both maps. 4) If any mismatch is found, return False. 5) Otherwise, update the mappings and continue. 6) If all mappings are valid, return True. Time Complexity: O(n) Space Complexity: O(n) Understanding how bidirectional mapping ensures consistency 💪 #LeetCode #Python #DSA #HashMap #Strings #ProblemSolving #100DaysOfCode

Day 50/100 – #100DaysOfCode 🚀 Solved LeetCode #28 – Find the Index of the First Occurrence in a String (Python). Today I practiced string matching using a brute-force approach to find the first occurrence of a substring. Approach: 1) Traverse the main string (haystack). 2) For each index, try to match the substring (needle). 3) Compare characters one by one. 4) If all characters match, return the starting index. 5) If mismatch occurs, break and move to the next index. 6) If no match is found, return -1. Time Complexity: O(n × m) Space Complexity: O(1) Understanding basic string matching techniques step by step 💪 #LeetCode #Python #DSA #Strings #ProblemSolving #100DaysOfCode

Day 42/100 – #100DaysOfCode 🚀 Solved LeetCode #2574 – Left and Right Sum Differences (Python). Today I practiced prefix sum logic to calculate the absolute difference between left and right sums for each index. Approach: 1) Calculate the total sum of the array. 2) Initialize leftSum = 0. 3) Traverse the array. 4) For each index, compute rightSum = total - leftSum - nums[i]. 5) Calculate the absolute difference and append it to the result. 6) Update leftSum by adding nums[i]. Time Complexity: O(n) Space Complexity: O(n) Understanding prefix sum helps solve problems efficiently 💪 #LeetCode #Python #DSA #Arrays #PrefixSum #ProblemSolving #100DaysOfCode

Most implementations of the State pattern in Python look very “clean”. Lots of small classes. A base interface. One class per state. But if you’ve ever worked with one in a real project, you know the downside: transitions are scattered, behaviour is hard to see in one place, and adding new states often means touching multiple files. In today’s video, I rebuild the State pattern in a very different way. Instead of relying on inheritance, I make the state machine explicit as data and use decorators to define transitions. The result is a small, reusable engine where the entire flow becomes visible at a glance. If you’re interested in writing Python that’s easier to reason about and extend, this is a pattern worth understanding. 👉 Watch here: https://lnkd.in/eg22yEHR. #python #softwaredesign #designpatterns #statemachine #cleancode

Most implementations of the State pattern in Python look very “clean”. Lots of small classes. A base interface. One class per state. But if you’ve ever worked with one in a real project, you know the downside: transitions are scattered, behaviour is hard to see in one place, and adding new states often means touching multiple files. In today’s video, I rebuild the State pattern in a very different way. Instead of relying on inheritance, I make the state machine explicit as data and use decorators to define transitions. The result is a small, reusable engine where the entire flow becomes visible at a glance. If you’re interested in writing Python that’s easier to reason about and extend, this is a pattern worth understanding. 👉 Watch here: https://lnkd.in/e9Y3xGNF. #python #softwaredesign #designpatterns #statemachine #cleancode

Python Clarity Series – Episode 25 Topic: Mutable vs Immutable Function Behavior 📌 Why did my list change after function call? def modify(lst): lst.append(100) a = [1, 2] modify(a) print(a) Output: [1, 2, 100] 👉 Lists are mutable → changes reflect outside Now: def modify(x): x = x + 10 a = 5 modify(a) print(a) Output: 5 👉 Integers are immutable → no change outside 💡 Rule: Mutable → changes persist Immutable → changes don’t This confusion causes logic errors. #PythonBasics #FunctionConcepts #StudentClarity #python #clarity

Day 43/100 – #100DaysOfCode 🚀 Solved LeetCode #2610 – Convert an Array Into a 2D Array With Conditions (Python). Today I practiced hashmap (frequency counting) to construct a 2D array based on given conditions. Approach: 1) Create a frequency map to count occurrences of each element. 2) Initialize an empty result list. 3) While the frequency map is not empty: 4)  Create a new row. 5)  Iterate through keys and add each number once to the row. 6)  Decrease its frequency and remove it if it becomes zero. 7) Add the row to the result. 8) Return the final 2D array. Time Complexity: O(n) Space Complexity: O(n) Learning how frequency maps help in structuring data efficiently 💪 #LeetCode #Python #DSA #HashMap #Arrays #ProblemSolving #100DaysOfCode

Python Challenge – Can you solve this? Today was all about deep-diving into Lists vs. Sets and I came across a common mistake that we can sometimes overlook. Let’s test your Python understanding👇 numbers = [1, 2, 3] numbers.append([4, 5]) print(len(numbers)) A) 3 B) 4 C) 5 D) Error It’s a classic interview question that tests if you truly understand how Python handles memory and lists. Day 15/30 #30DaysOfCode #DataStructures #Day15 #PythonQuiz

Day 53/100 – #100DaysOfCode 🚀 Solved LeetCode #125 – Valid Palindrome (Python). Today I practiced string cleaning and validation to check whether a given string is a palindrome. Approach: 1) Traverse the string and keep only alphanumeric characters. 2) Convert all characters to lowercase. 3) Build a cleaned string. 4) Compare the string with its reverse. 5) If both are equal, return True; otherwise, return False. Time Complexity: O(n) Space Complexity: O(n) Learning how preprocessing simplifies string problems 💪 #LeetCode #Python #DSA #Strings #ProblemSolving #100DaysOfCode

Copying vs Reference 🐍 I thought this would create a copy: b = a It didn’t. a = [1, 2, 3] b = a b.append(4) print(a) 👉 [1, 2, 3, 4] Both variables point to the same list. No copy was made. In Python, variables are just labels, not containers. When you use =, you aren’t duplicating data, you’re just giving the same memory address a second name. To actually copy: b = a.copy() Looks the same. Behaves completely differently. 💡 And also: .copy() only goes one layer deep and that's why we need deep copy. ➡️ Assignment ≠ Copy Day 17/30 #Python #30DaysOfCode #SoftwareEngineering