"LeetCode #1611: Minimum Bit Operations to Zero"

💡 Day 43 / 100 – Search in Rotated Sorted Array (LeetCode #33) Today’s problem was a twist on the classic binary search — quite literally! The challenge was to find a target element in a rotated sorted array. At first glance, the array looks unsorted, but there’s actually a pattern. By identifying which part of the array is properly sorted at every step, we can still apply binary search logic efficiently — achieving O(log n) time complexity. This problem beautifully blends pattern recognition with logical precision. 🔍 Key Learnings Even when data looks “unsorted,” patterns often exist beneath. Modified binary search can adapt to many problem variations. Understanding midpoint relationships helps in avoiding brute force. 💭 Thought of the Day Adaptability is key — in coding and in life. Just like binary search adjusts to a rotated array, we can adjust to challenges by recognizing the underlying order in the chaos. Clear logic turns confusion into clarity. 🔗 Problem Link: https://lnkd.in/gS8FcbeE #100DaysOfCode #Day43 #LeetCode #Python #BinarySearch #ProblemSolving #Algorithms #CodingChallenge #DataStructures #CodingJourney #PythonProgramming #LogicBuilding #KeepLearning #TechGrowth #Motivation

How Pydantic AI Turned My Chaotic Data Into a Super‑Smart Python Model 🤖 I was juggling a legacy API that returned nested JSON like a tangled ball of yarn—lists inside dicts, optional fields, and a few hidden “type‑mismatch” bugs that broke the whole pipeline. Every time I wrote a new class, I added manual checks, and the codebase grew into a nightmare of try/except blocks. Enter Pydantic AI. I fed it a single example payload, and it instantly generated a hierarchy of BaseModel classes with proper type hints, default values, and validators for the edge cases. The next day, the same API response passed through the model without a single runtime error, and the auto‑generated docs showed exactly what each field meant. Adding a new optional field? Just update the example and let Pydantic AI regenerate—no more hand‑rolled parsing logic. Now my services serialize, deserialize, and validate data in one line, and the code reads like a story instead of a maze. #Python #PydanticAI #DataValidation

A TypeError is not an error. It's a feature. #ZeroToFullStackAI Day 3/135: The Principle of Type Integrity. This is one of the most important concepts in robust software. Why does 5 + 5 equal 10, but "5" + "5" equal "55"? This is Type Integrity. int + int = Mathematical Addition str + str = String Concatenation Python is Strongly Typed. It will not "guess" what you mean. If you try to run 5 + "5", it correctly raises a TypeError instead of producing an unpredictable, silent error. This is a safety system, not a bug. Our tool for this is the type() function. In a real-world application, we never assume the type of data we receive from a user or an API. We verify it. If we need to perform math, we explicitly convert the type. Never assume. Always verify. We've established our primitives. Tomorrow, we scale them into collections. #Python #DataScience #SoftwareEngineering #AI #Developer #Architecture

🔹 Day 2 of 30 – LeetCode Challenge: Postorder Traversal of Binary Tree 🌲Today’s problem was about implementing Postorder Traversal of a binary tree — one of the most fundamental tree traversal techniques in Data Structures and Algorithms. 🧩 Problem: Return the postorder traversal (Left → Right → Root) of a given binary tree. Example: Input: root = [1, null, 2, 3] Output: [3, 2, 1] 💡 Approach: In Postorder Traversal, we: Visit Left Subtree Visit Right Subtree Visit Root Node I implemented both recursive and iterative approaches. The recursive version is simpler, while the iterative version helps understand how to simulate recursion using a stack. ⚙️ Complexity: Time Complexity: O(n) Space Complexity: O(h) 🏆 Result: ✅ All test cases passed 🚀 Runtime Efficiency: 100% 💬 Learning: This problem helped me deepen my understanding of recursion and stack-based traversal logic. Iterative postorder traversal is tricky but a great exercise to strengthen logical thinking in DSA. #LeetCode #Day2 #Python #DataStructures #BinaryTree #PostorderTraversal #Algorithms #Recursion #30DaysOfCode #MTech #CodingChallenge

MetricsQL is powerful. But at scale, managing alerts can get messy. 👋 Meet HeraclesQL: HRT’s open-source Python DSL for writing type-safe, expressive alerts on VictoriaMetrics. Built by the HRT Systems Dev team, HeraclesQL brings Python-native expressiveness, Meta-alerts that catch footguns before prod does, and tooling like Delos & Hermes for testing + iteration. Catch the full deep dive on the HRT Beat: https://lnkd.in/eanHNhT6

🔥 Day 10 of 30 – LeetCode Challenge: First & Last Position in Sorted Array 🎯 Today’s challenge involved finding the starting and ending index of a target value in a sorted array — but with an important constraint: the solution must run in O(log n) time. This makes Binary Search the perfect approach! 🧩 Problem Summary Given a sorted array nums, return the first and last position of a given target. If the target doesn’t exist, return [-1, -1]. Example 1: Input: nums = [5,7,7,8,8,10], target = 8 Output: [3, 4] Example 2: Input: nums = [5,7,7,8,8,10], target = 6 Output: [-1, -1] Example 3: Input: nums = [], target = 0 Output: [-1, -1] 💡 Approach – Modified Binary Search We use Binary Search twice: 1️⃣ First to find the leftmost (first) occurrence 2️⃣ Second to find the rightmost (last) occurrence By narrowing down boundaries instead of stopping at the first match, we maintain O(log n) complexity. ⚙️ Complexity Time O(log n) Space O(1) 🏆 Result & Learnings ✅ Implemented binary search in two forms 📍 Learned how to adjust boundaries to find first/last occurrence ⚡ Better understanding of narrowing search space efficiently ✨ Real-World Use Cases 🔍 Search results pagination (finding first & last index) 📊 Range queries in sorted data 🧠 Used in problems involving frequency count of numbers #Day10 #LeetCode #BinarySearch #Python #CodingChallenge #DSA #30DaysOfCode #WomenWhoCode #ProblemSolving #MTech

Day 57: Binary Tree Zigzag Level Order Traversal 🎢 I'm continuing my journey with an advanced tree traversal problem on Day 57 of #100DaysOfCode: "Binary Tree Zigzag Level Order Traversal." The challenge is to return the nodes of a binary tree level by level, alternating the direction of traversal (left-to-right, then right-to-left, and so on). My solution builds upon the standard Breadth-First Search (BFS) algorithm, using a queue (deque): Level Traversal: I process the tree level by level, finding the level_size in each iteration. Direction Toggle: I use a boolean flag (left_to_right) to track the current direction. Zigzag Logic: Inside the level loop, I use a simple conditional: if left_to_right is true, I append the node value normally. If it's false, I insert the node value at the beginning of the current level's list (current_level.insert(0, node.val)). Optimal Flip: After processing the entire level, I flip the left_to_right flag (left_to_right = not left_to_right) for the next level. This single-pass BFS approach ensures all nodes are visited exactly once, achieving an optimal O(n) time complexity and O(n) space complexity. My solution was accepted with 100% runtime efficiency! #Python #DSA #Algorithms #Trees #BFS #100DaysOfCode #ProblemSolving #Zigzag

🚀 Solving Leetcode 474: “Ones and Zeroes” — Dynamic Programming in Action Today, I tackled Leetcode 474 — Ones and Zeroes, a great example of how to apply dynamic programming (DP) to real-world resource allocation problems. 💡 Problem Overview You’re given an array of binary strings strs, and two integers m and n representing the maximum number of 0s and 1s allowed. Your goal: Find the largest subset of strings that can be formed using at most m zeros and n ones. Essentially, this is a 0/1 Knapsack problem where each string consumes a certain number of zeros and ones — and we want to maximize how many strings fit within our capacity. 🧠 DP Approach We define a DP table: dp[i][j] = the maximum number of strings that can be formed using at most i zeros and j ones. For each string: 1. Count its zeros and ones. 2. Update the DP table in reverse order (to avoid reusing the same string). *⏱️ Complexity* Time: O(len(strs) × m × n) Space: O(m × n) 🔍 Key Takeaways This problem is a perfect example of multi-dimensional dynamic programming. Thinking in terms of capacity (m, n) rather than string order helps simplify the state transitions. DP remains one of the most powerful paradigms for breaking down complex optimization challenges. #DynamicProgramming #Leetcode #Python #ProblemSolving #Algorithms #DataScience #DataAnalytics #MachineLearning #AI

🌙 Day 41 of LeetCode Challenge Problem: 1625. Lexicographically Smallest String After Applying Operations Difficulty: 🟠 Medium 🧩 Problem Summary: We are given a numeric string s (even length) and two integers a and b. We can: 1️⃣ Add a to all digits at odd indices (mod 10). 2️⃣ Rotate the string to the right by b positions. The goal is to find the lexicographically smallest string possible after performing these operations any number of times. 💡 Approach: The problem is based on exploring all possible transformations of the string. Since both operations can be applied infinitely, we use BFS (Breadth-First Search) to systematically try every possible state of the string. At each step: Apply the “add to odd indices” operation. Apply the “rotate by b” operation. Add new unique strings to a queue for further exploration. We also keep track of the smallest string found so far. The process continues until all possible states are explored. 🧠 Key Insights: There are only a finite number of unique strings possible because digits wrap around (mod 10) and rotations eventually repeat. BFS ensures we don’t miss any possible transformation. The smallest string is found naturally during the traversal. 🕹 Example: Input → s = "5525", a = 9, b = 2 After applying multiple add and rotate operations, the smallest string obtained is "2050". ⏱ Complexity: Time Complexity: O(10 × n²) Space Complexity: O(n × 10) 🔥 Takeaway: This problem beautifully combines string manipulation, mathematical operations, and graph traversal (BFS). Even simple operations can lead to complex state spaces — mastering how to explore them systematically is the key! #LeetCode #Day41 #Python #BFS #StringManipulation #CodingJourney 🚀

A Great Lesson in Optimization: From O(n^2) to O(n) with "Two Sum" My initial instinct was to develop a brute-force solution. This approach, which involved two nested loops, correctly found the answer but had a time complexity of O(n^2). I knew there had to be a more efficient method. This prompted me to explore optimization, and I soon discovered the power of using a HashMap (or Dictionary). By leveraging this data structure, I could store the values I had already encountered and their indices. This new approach allowed me to find the solution in a single Loop, completely eliminating the nested loop and achieving a linear time complexity of O(n). Valuable lesson:- the first solution that comes to mind isn't always the best one. It highlighted the critical importance of analyzing time complexity and selecting the right data structure for the job. A simple change in approach can be the difference between a functional solution and a truly efficient one. #DataStructures #Algorithms #ProblemSolving #Optimization #Python #SoftwareDevelopment #LearningJourney