Day 44 of 365 Days of code 😵💫 Qn 1) Decode String approach: stack took me a while to solve, but the problem was worth the time taken. 1)keep on pushing the characters into the stack until you encounter a " ] " closing bracket. 2) if a closing bracket is encountered initialize an empty string and keep popping the elements and add it to a string until a open square bracket is found on top of the stack 3) If the top element in the stack is an integer, multiply the integer with the string, and append it to the string 4) elif the top element is a string add the string to the top element 5) else append the string 6) reverse the stack, pop the reversed stack and add it to string res 7) return res gn #365daysOfCode #NeetCode  #leetcode  #DSA  #python #LeetCode #ProblemSolving  #Algorithms #365dayschallenge

Day 35 of 365 days of code So far, so good Qn 1) Online stock span approach: decreasing monotonic stack Inside the constructor(__init__ block): initialize an empty stack we are going to use the stack to store the prices and the span Inside the function block(next): 1) set span=1 2) while the stack is not empty and the price at the top of the stack is less than the price: i) span+=stack.pop() 3) push the price and the span, as a tuple inside the stack. 4) return span. #365daysOfCode #NeetCode  #leetcode  #DSA  #python #LeetCode #ProblemSolving  #Algorithms #365dayschallenge

Recently, I was working on a problem that required dynamically constructing a string. My initial implementation was straightforward and functionally correct. At first glance, it seemed perfectly acceptable. However, upon reviewing the logic more carefully, I revisited how Python handles strings internally. Since strings in Python are immutable, each concatenation inside a loop creates a new string object. This means that with every iteration, memory is reallocated and the existing content is copied over. As input size increases, this results in repeated allocations and copying — leading to unnecessary overhead and potential quadratic time complexity. While this may not be noticeable for small inputs, it becomes increasingly inefficient in production environments where code runs frequently or processes large datasets. To optimize the solution, I refactored the implementation to accumulate values in a list and join them at the end. This approach avoids repeated string creation and achieves linear time complexity, improving both performance and memory efficiency. It was a small refactor, but a meaningful one. Moments like this are a good reminder that understanding language internals — even for simple operations — can significantly impact the quality and efficiency of the code we write. #Python3 #Performance #CleanCode #SoftwareEngineering #Optimization

📌 Day 25 of #100DaysOfCode Today’s problem: LeetCode 14 – Longest Common Prefix This problem looks simple… but it tests your string fundamentals and edge-case handling. 🧠 Problem Insight: We are given an array of strings. Our task is to find the longest common prefix among all strings. If there is no common prefix → return an empty string. 🔎 Key Learning: The prefix must match character by character The shortest string limits the maximum possible prefix Early stopping is important once mismatch is found Edge cases: Empty array Only one string No common prefix 🎯 What I Practiced Today: ✔️ String traversal ✔️ Breaking early for optimization ✔️ Handling corner cases ✔️ Clean logic without overcomplication Small problem. Big clarity improvement. Consistency > Motivation 🔥 #Day25 #LeetCode #DSA #Python #CodingJourney #ProblemSolving #100DaysOfCode

Problem-Solving Focus Binary Addition: When One Line Beats Twenty Challenge: Add two binary strings without converting to decimal. My first instinct? Write a manual carry-propagation algorithm with loops, conditions, and string reversal. Then I realized: Python's int(x, 2) already does the heavy lifting! Before: 25 lines of code After: return bin(int(a, 2) + int(b, 2))[2:] The Lesson: Sometimes optimization isn't about algorithmic complexity—it's about leveraging built-in tools effectively. But here's the thing: In technical interviews, you often need BOTH: → The ability to solve it manually (shows understanding) → The awareness of optimized approaches (shows experience) Do you prefer writing explicit code for clarity or using language shortcuts for brevity? #Python #AlgorithmDesign #TechInterviews #Programming #ContinuousLearning

Headline: Stop writing loops to clean your data. 🛑 One of the most common tasks in Python is handling duplicate entries. While you could write a for-loop with a conditional check, there’s a much faster, more "Pythonic" way to do it: Sets. Sets are unordered collections of unique elements. By casting your list to a set, Python handles the heavy lifting of deduplication instantly. Why use this? ✅ Cleaner, more readable code. ✅ Better performance for large datasets. ✅ Built-in membership testing (O(1) complexity). How are you using Sets in your current workflow? Let’s discuss below! 👇 #PythonProgramming #Pyspiders #CodingTips #SoftwareDevelopment

We all hit those moments. You're debugging a complex function, and a simple, repeated calculation keeps tripping you up. It feels like you're writing the same logic over and over, tangled in nested loops that are hard to trace. This often happens because we're trying to solve a problem by breaking it down into smaller, identical versions of itself. We're thinking about "what's the answer for this input, and how does it relate to the answer for a slightly smaller input?" The fix is to embrace recursion. Think about calculating factorial. 5! is 5 4!. And 4! is 4 3!, and so on, until you reach the simplest case: 1! is just 1. In Python, this looks elegant: def factorial(n): if n == 1: return 1 else: return n * factorial(n - 1) The function calls itself with a smaller input until it hits the base case. This approach leads to cleaner, more readable code. It simplifies complex problems into understandable, self-similar steps. Less code to write. Fewer bugs to find. Easier to reason about. #Python #Recursion #SoftwareEngineering #CodingTips #SeniorEngineer

🚀 Day 7/30 | LeetCode Problem: First Unique Character in a String (387) Problem: Given a string s, find the first non-repeating character and return its index. If it doesn't exist, return -1. Approach: Use a dictionary to count occurrences of each character Traverse the string a second time to find the first character with count 1 Return its index Time Complexity: O(n) → Two passes over the string Space Complexity: O(1) → Dictionary holds at most 26 letters (for lowercase English letters) Python Code: class Solution: def firstUniqChar(self, s): a = {} for i in s: if i in a: a[i] += 1 else: a[i] = 1 for i in range(len(s)): if a[s[i]] == 1: return i return -1 Example: Input: "leetcode" Output: 0 → 'l' is the first unique character Input: "loveleetcode" Output: 2 → 'v' is the first unique character Takeaway: Counting occurrences is a common technique for string problems and can be applied to many scenarios like finding duplicates, frequency analysis, etc. 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day7 #Python #Strings #DSA #ProblemSolving #CodingJourney #SoftwareEngineering #TechCommunity

Day 55 — Revision Day Today wasn’t about solving new problems. It was about strengthening patterns. #Day55 🧩 543. Diameter of Binary Tree Revision made it faster. The recursion pattern is becoming clearer. 🧩 104. Maximum Depth of Binary Tree Dry run calmly. Think twice before running the code. 🧩 226. Invert Binary Tree Tried BFS this time — fantastic way to see the tree differently. 🧩 105. Construct Binary Tree (Preorder + Inorder) Understanding when to use mid vs mid+1 is crucial in Python slicing. Index handling is everything. 🧩 124. Maximum Path Sum Used paper to think it through. Similar state management concept like Diameter — global max tracking matters. 🧩 297. Serialize & Deserialize Binary Tree Big lesson: null handling is everything. First think about serialization structure → then rebuild carefully. What today taught me: Patterns repeat. State management matters. Revision sharpens recognition. Day 55 — not flashy, but powerful. #LeetCode #DSA #Python #BinaryTree #Recursion #Revision #LearningInPublic #Consistency

There's a nagging feeling when you see certain code. The kind that feels like a winding path with too many steps. It often stems from a misunderstanding of how to break down complex problems. We tend to build things up incrementally, sometimes creating unnecessary layers of state management. The fix is simple: embrace recursion. Think of calculating factorial: 5! = 5 * 4!. Each step is the same problem, just a smaller version. Python makes this straightforward. def factorial(n): if n == 0: # Base case return 1 else: return n * factorial(n - 1) # Recursive step This approach leads to cleaner, more elegant solutions. Fewer bugs. Better focus. More maintainable code. #Python #Recursion #SoftwareEngineering #CodeQuality