LeetCode #33: Rotated Sorted Array Search in Python

Today I implemented Serialize and Deserialize Binary Tree in Python. The goal of the problem is to convert a binary tree into a string so it can be stored or transferred, and later reconstruct the exact same tree from that string. I used a BFS (level order traversal) approach for this. Idea: • Traverse the tree level by level using a queue. • Store node values in a list. • For missing children, store a special marker (#) so the structure of the tree is preserved. • Join the list into a single string. For deserialization, the process is reversed: • Split the string back into values. • Rebuild the tree using a queue. • Attach left and right children in the same order they were stored. What I liked about this problem is that it shows how important it is to preserve structure, not just values. Without storing null nodes, reconstructing the same tree would be impossible. Time Complexity: O(N) Space Complexity: O(N) Problems like this are a good reminder that tree problems often combine traversal, data representation, and careful reconstruction logic. #DSA #BinaryTree #Python #Algorithms #CodingInterview

In Python, if we write: a = b = [ ] Are we creating two lists or just one? Actually, Python creates only one list in memory, and both variables "a" and "b" reference the same object. This happens because assignment in Python doesn’t copy objects. Instead, it simply makes the variables point to the same object in memory. Let’s look at a simple example: a = b = [ ] a.append(1) print(a) print(b) Output: [1] [1] Even though we only modified "a", "b" changed as well. That’s because both variables are referencing the same list. If you want two independent lists, you should create them separately: a = [ ] b = [ ] 📌 Key takeaway: In Python, variables store references to objects, not the objects themselves. #Python #Programming #DataScience #AI #Instant

Python Tip — Tuples: Small Feature, Big Signal Most developers see tuples as “lists you can’t modify.” That’s surface-level thinking. Tuples are about immutability and intent. When you use a tuple, you’re telling other developers: “This data should not change.” They’re: - Faster than lists - Hashable (usable as dictionary keys) - Safer for fixed data - Perfect for returning multiple values Use lists for collections that evolve. Use tuples for data that represents a fixed structure. In Python, the right data structure isn’t just technical, it communicates design. FOLOW FOR MORE PYTHON TIPS & INSIGHTS #Python #DataStructures #CleanCode #SoftwareEngineering #ProgrammingTips

🚀 Day 10 of my Python Automation Journey Today I built a Text Summarizer using Python. This project automatically generates a short summary from a long paragraph using the LSA (Latent Semantic Analysis) algorithm with the Sumy library. It helps to quickly understand large text by extracting the most important sentences. 🔹 Technologies Used: Python, Sumy Library Summary: • Python is a powerful programming language used in many fields such as web development, data science, artificial intelligence, and automation. • Many developers prefer Python because of its simplicity and readability. Building small automation projects every day to improve my Python and problem-solving skills. #Python #Automation #CodingJourney #PythonProjects

We did not need to replace Python. We needed to move the hot path. On one project, I worked on a scoring platform processing 1,000+ calculations per minute on biological datasets. Python with FastAPI handled the API layer, async jobs, and orchestration very well. The bottleneck showed up in the compute layer: complex mathematical evaluation, 50+ supported functions, and thousands of formula executions per minute. So we moved the compute-intensive formula evaluation into Go modules. The result was a 3x performance improvement over the pure Python implementation. The lesson was not “Go > Python.” It was: strong engineering choices happen per layer, per workload, and per constraint. Python was a great fit for orchestration and product delivery. Go was a better fit for raw compute in the hot path. Both made sense in the same system. I do not really think in terms of favorite languages anymore. I think in terms of what this layer actually needs. #Python #Golang #BackendDevelopment #SoftwareEngineering #SystemDesign #API #GO

Day 13/100 – #100DaysOfCode 🚀 Solved LeetCode #219 – Contains Duplicate II (Python). Today I practiced using a HashMap to efficiently check whether two equal elements exist within a given distance k in an array. Approach: 1) Create a hashmap to store numbers and their latest index. 2) Traverse the array using index i. 3) If the current number already exists in the hashmap, check the index difference. 4) If the difference between indices is ≤ k, return True. 5) Update the hashmap with the current index. 6) If no such pair exists, return False. Time Complexity: O(n) Space Complexity: O(n) Learning how hashmaps help optimize search operations in arrays 💪 #LeetCode #Python #DSA #HashMap #Arrays #ProblemSolving #100DaysOfCode

6 Python Libraries To Boost Your Workflow 1. Tenacity: Offers retry strategies for script resilience. 2. Polars: A fast DataFrame library for large datasets. 3. Shelve: Creates persistent, file-backed dictionaries. 4. Rich: Beautifies terminal output with tables and progress bars. 5. Pendulum: Simplifies datetime management with UTC standards. 6. Inline-Snapshot: Records and updates test values in code. Small tools like these often make a big difference—sometimes it's the unexpected library that solves your biggest headache. New to Python? Learn the basics (nl) 👉 https://lnkd.in/emBgb9gf #GeoICT #Python #GIS #SpatialData #OpenSource

LeetCode #21 – Merge Two Sorted Lists | Python Implementation I implemented an iterative two-pointer merge approach for combining two sorted linked lists. A dummy node serves as the anchor, and a tail pointer builds the merged list by always selecting the smaller current node from either list. After one list is exhausted, the tail directly attaches the remainder of the non-empty list since it's already sorted. This avoids unnecessary node-by-node traversal and keeps the solution clean. This pattern is core to merge sort implementations, database query result merging, and distributed log aggregation systems where sorted streams must be combined efficiently. Key Takeaway: Using a dummy node eliminates edge case handling for the first node insertion, simplifying the logic significantly. The direct attachment of remaining nodes after one list is exhausted is an optimization that leverages the sorted property, avoiding redundant comparisons. Time: O(n + m) where n, m are list lengths | Space: O(1) #LeetCode #DataStructures #Python #LinkedList #TwoPointers #CodingInterview #ProblemSolving #SoftwareEngineering

LeetCode #572 – Subtree of Another Tree | Python Implementation I implemented a recursive DFS approach that checks every node in the main tree as a potential subtree root. Core Insight: Subtree verification is a nested recursion problem — outer recursion finds candidate positions, inner recursion validates exact matches. Reusing the same-tree helper keeps logic clean and modular. Time: O(m × n) worst case where m, n are tree sizes | Space: O(h) recursion depth #LeetCode #DataStructures #Python #BinaryTree #Recursion #DFS #CodingInterview #SoftwareEngineering

🚀 Working with Different File Encodings (Python) Files can be encoded in various formats, such as UTF-8, ASCII, and Latin-1. When opening a file, you can specify the encoding using the `encoding` parameter. If the encoding is not specified, Python uses the default encoding, which may lead to errors if the file is encoded differently. It's crucial to choose the correct encoding to ensure that characters are read and written correctly, preventing data corruption. #Python #PythonDev #DataScience #WebDev #professional #career #development