LeetCode Insight: Total Fruit Problem with Sliding Window

Day 32 – Linked Lists: Why They Exist and When They Matter 🔗 Today I spent time understanding linked lists — why they exist in the first place. At a basic level, a linked list is a collection of elements (called nodes) where: Each node holds some data Each node points to the next one (and sometimes the previous one) Unlike regular Python lists: Linked lists don’t rely on indexes Elements don’t have to sit next to each other in memory So why does this matter? Linked lists are useful when: You need frequent insertions and deletions The order of items changes often You don’t care about fast random access by index Real-world use cases include: Undo/redo functionality in applications Browser navigation (back and forward) Music or image playlists Implementing caches (like LRU cache) Task scheduling and queues The key trade-off: Linked lists are slower to search But very efficient when modifying data in the middle Today reminded me that data structures aren’t just academic ideas — they’re design choices, each with strengths and weaknesses depending on the problem you’re solving. #Day32 #DataStructures #LinkedLists #Python #ComputerScience #LearningInPublic

🚀 Day 11/30 | LeetCode 3190 – Minimum Operations to Make Array Elements Divisible by 3 Problem: Given an integer array nums, in one operation you can increment or decrement any element by 1. Return the minimum number of operations required to make all elements divisible by 3. 🧠 Approach For any number: If num % 3 == 0 → no operation needed If num % 3 == 1 → 1 operation needed If num % 3 == 2 → 1 operation needed Because: 1 step can either increase or decrease to nearest multiple of 3 So the problem becomes: 👉 Count how many numbers are not divisible by 3 ⏱️ Complexity Time Complexity: O(n) Space Complexity: O(1) 🧾 Python Code class Solution: def minimumOperations(self, nums): return sum(i % 3 != 0 for i in nums) ✅ Result Accepted ✅ Runtime: 0 ms (Beats 100%) Clean & concise solution 🎯 Key Learning Sometimes problems look complex but reduce to: 👉 Observing mathematical patterns 👉 Using modulo smartly Writing concise Python like this improves readability and efficiency. 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day11 #Python #Math #DSA #ProblemSolving #CodingJourney #SoftwareEngineering #TechCommunity

Chains worked perfectly for my product analyst agent when the workflow was simple and tool calling was linear: pull data from Sheets → generate charts with Python → return output. But the moment any conditional logic got added at runtime like “if sample size is low, switch to weekly aggregation” or if it couldn't find the data on it's first try, the flow failed. This is when a more structured framework becomes necessary, a framework that doesn't let the agent get thrown away by logic inside prompts that the tools weren't explicitly designed for, so it can reason, retry and dynamically reroute itself. This week’s breakdown: when simple chains are enough, and when something like LangGraph starts to make more sense. Next week: Building an MCP server hands on. Packaging the tools I designed for the product analyst agent into a locally run MCP server. #TuninginTuesdays #AgenticAI #LangGraph

DSA Daily — Hashing Pattern LeetCode 349: Intersection of Two Arrays Day 14 of staying consistent with problem solving Today’s problem was a simple but important example of how sets simplify array problems when uniqueness is a requirement. We’re given two arrays and asked to return their intersection — with no duplicate elements in the result. This problem clearly signals the use of hashing. Key observations: - The result must contain unique elements only - Order does not matter - Fast lookup is more important than maintaining positions Core idea: - Convert one array into a set to remove duplicates and enable O(1) lookup - Traverse the second array - If an element exists in the set, add it to the result set - Using a set for the result automatically ensures uniqueness. Complexity: Time: O(n + m) Space: O(n + m) (sets for lookup and result) Sets are especially useful for intersection-type problems on arrays. This problem fits well with earlier hashing-based questions and reinforces how choosing the right data structure can make solutions both cleaner and more efficient. On to the next one 🚀 #DSADaily #Hashing #LeetCode #ProblemSolving #Python

LeetCode Progress | 228. Summary Ranges (Python) Today I solved “Summary Ranges” on LeetCode. Problem: Given a sorted unique integer array nums, return the smallest list of ranges that cover all numbers exactly. A range should be formatted as: -- "a->b" if a != b -- "a" if a == b My approach: I used a two-pointer style tracking method. -- Set start as the beginning of a range -- Iterate through the array and detect when the sequence breaks -- When it breaks, append either a single number or a start->end range -- Update start to begin the next range Optimal approach: The optimal solution follows the same greedy idea (range tracking in one pass). -- Maintain start and extend the current range while consecutive numbers continue -- When the chain breaks or the array ends, output the range and reset start This provides an efficient solution with: -- Time Complexity: O(n) -- Space Complexity: O(1) (excluding output list) What I learned: -- Range problems become easy when you track only the start and detect breakpoints -- Always handle the last element carefully to avoid missing the final range -- Greedy one-pass scanning is often optimal for sorted arrays #leetcode #python #dsa #datastructures #algorithms #coding #programming #problemSolving #softwareengineering #computerscience #interviewprep #codinginterview #100daysofcode #pythonprogramming

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

hi connections I just moved from Maximum Subarrays to LeetCode 167: Two Sum II. The challenge? Find two numbers that hit a target sum. The "cheat code"? The input array is already sorted. When you see "Sorted Array," your mind should immediately go to Two Pointers. The Strategy: Left Pointer: Starts at the beginning (smallest values). Right Pointer: Starts at the end (largest values). The Logic: If the sum is too low, nudge the left pointer up. If it’s too high, slide the right pointer down. Why I love this approach: Zero Extra Space: Unlike the original Two Sum, you don’t need a Hash Map. O(1) space. Speed: You only pass through the data once. O(n) time. Simplicity: It’s clean, readable, and highly optimized. Programming isn't just about solving the problem; it's about finding the most elegant way to do it by leveraging the constraints you're given. #Coding #DataStructures #Algorithms #TwoSum #Python #LeetCode #SoftwareEngineering #TwoPointers

Just discovered "Pydantic" today and it's a game-changer! If you're building APIs in Python or dealing with data management, this library makes life so much easier. What I learned: -> Automatic data validation - no more manual checks -> Works perfectly with FastAPI -> Clean settings and config management You get validation, error handling, and type safety automatically. If you work with APIs(FastAPI) or external data, definitely check it out. Perfect Source: Chai Aur Code-Pydantic Crash Course(YouTube) #Python #Pydantic #API

🧠 LeetCode Insight — Minimum Window Substring Lately, I’ve been focusing on strengthening my core problem-solving fundamentals, especially patterns that show up repeatedly in real-world engineering problems. One such problem is Minimum Window Substring, which combines: sliding window frequency tracking and careful state management 💡 Core Logic The goal isn’t just to find a valid window — it’s to find the smallest valid window. To do that efficiently: Track required character counts using a frequency map Maintain a dynamic window over the string Expand the window to satisfy constraints Shrink it only when validity is preserved The balance between correctness and optimality is what makes this problem interesting. ✅ Python Implementation: https://lnkd.in/gN-93eB8 🧩 Why This Matters Problems like this test more than syntax — they test: how you manage state how you reason about constraints how you optimize without breaking correctness These are the same skills required when working on scalable backend systems and data pipelines. 🎯 Takeaway The biggest learning for me here was: Sliding window problems aren’t about moving pointers — they’re about knowing exactly when a condition becomes true and when it breaks. Getting that right is what leads to clean, reliable solutions. 👉 Curious how others reason about shrinking windows — what’s your mental model for this pattern? #Python #ProblemSolving #SlidingWindow #DataStructures #SoftwareEngineering #LeetCode #LearningInPublic

🚀 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