Mamundeeswari Ganesan’s Post

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

Here’s a tiny Python change that pays off fast. Python tip: use `@dataclass(slots=True)` for high-volume models. It removes per-instance `__dict__`, which usually means lower memory usage and slightly faster attribute access. Great for DTOs, parser outputs, event payloads, and cache objects where shape is fixed. Mini rule: if the object schema is stable, add `slots=True` by default. #Python #Performance #CodeQuality #SoftwareEngineering

Stateful UDFs just changed how Python scales. With @daft.cls, you can turn any Python class into a distributed operator that initialises once per worker and reuses state across every row. That means models, API clients, and database connections no longer get rebuilt on every call. The mental model stays simple: write normal Python classes, add a decorator, and Daft handles execution, scheduling, and parallelism. Find out more: https://lnkd.in/e79SePbN #PythonScaling #DaftCls #DistributedComputing #PythonClasses

Top 4 Python patterns every beginner should practice 🐍✨ Pattern programs are one of the best ways to understand nested loops, rows, columns, conditions, spacing, and how logic builds shapes step by step. In this post, you’ll see how Python can print: Heart pattern ❤️ Hollow square pattern ⬛ Pyramid pattern 🔺 Right triangle pattern 📐 These may look simple, but they train your brain to think like a programmer. You learn how loops move line by line. You learn how conditions control the output. You learn how spacing changes the entire shape. You learn how small logic creates a full pattern.

🚀 Day 85 of #100DaysOfLeetCode 🔍 Problem Solved: Ransom Note (LeetCode 383) Today’s problem was all about efficiently checking whether one string can be constructed from another — a classic hashing / frequency counting concept. ⚡ What I Learned: - Importance of frequency maps (hash tables) - Writing optimized solutions over naive approaches - How built-in methods can simplify logic but may impact performance 📊 Performance: ✅ Runtime: 0 ms (Beats 100%) ✅ Memory: Efficient usage 🔥 Takeaway: Small optimizations and choosing the right data structure can make a huge difference, even in easy problem #Day85 #LeetCode #CodingJourney #Python #DataStructures #ProblemSolving #100DaysOfCode

The generator expression that relies on lazy evaluation (iterator) is the most underrated approach for processing large sequence of non strictly numerical data. #GeneratorExpression #Python

Want to check whether a #Python #Pandas series contains another string? Use .str.contains: df['x'].str.contains('a') This returns a boolean series, whose index matches that of df. Keep only those rows containing 'a': df.loc[ pd.col('x').str.contains('a') ] # Pandas 3 syntax

C++26 Reflection & Python Bindings Writing bindings manually is tedious: * Extra code you need to read, maintain(,and write). * Extra dependencies in the project. * Extra bugs. I’ve been exploring C++26 reflection and built a small prototype: automatic Python bindings without writing bindings. Here’s how it works 👇 Post: https://lnkd.in/gwJYhnnF Code: https://lnkd.in/gbQqPVNr #cpp #reflection #c++26

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

called the same API endpoint 5 times in a row. without cache: 2.51s with lru_cache: 0.50s 5x faster. two lines of code. @functools.lru_cache(maxsize=128) def fetch_user(user_id): ... the cache info tells the real story: hits=4, misses=1 first call hits the actual API. next 4? served instantly from memory. this is how production systems handle repeated expensive calls — user profiles, config lookups, ML model loads, anything that doesn’t change every second. lru_cache ships with Python. no libraries. just import functools. two lines between slow and fast. #Python #Backend #DataEngineering #Performance