Verify Custom Ordered Lexicographic Dictionary

LeetCode POTD 💫: Description: A string originalText is encoded using a slanted transposition cipher to a string encodedText with the help of a matrix having a fixed number of rows rows. originalText is placed first in a top-left to bottom-right manner. encodedText is then formed by appending all characters of the matrix in a row-wise fashion. Given the encoded string encodedText and number of rows rows, return the original string originalText. Note: originalText does not have any trailing spaces ' '. The test cases are generated such that there is only one possible originalText. Here's my solution: https://lnkd.in/g2EMmfzE #Python #DSA #Leetcode #DailyChallenge

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

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

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

Day 41/100 – #100DaysOfCode 🚀 Solved LeetCode #2529 – Maximum Count of Positive Integer and Negative Integer (Python). Today I practiced simple counting logic to determine whether positive or negative numbers are more in the array. Approach: 1) Initialize two counters: neg = 0 and pos = 0. 2) Traverse the array element by element. 3) If the number is negative, increment neg. 4) If the number is positive, increment pos. 5) Return the maximum of neg and pos. Time Complexity: O(n) Space Complexity: O(1) Strengthening fundamentals with simple counting techniques 💪 #LeetCode #Python #DSA #Arrays #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

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

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

Two sum: Using dictionary (Optimized Solution) Instead of checking every pair: For each number, calculate what number is required. Formula to calculate required : required = target - current_number  Time complexity → O(n) #Python #LogicBuilding #ProblemSolvingSkills #Beginners

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