Find Missing Positive Integer in Unsorted Array

🚀 Stop iterating through rows like it’s 2010. In a recent pipeline, we were processing 5 million records to calculate a rolling score. Using a standard loop took forever and pegged the CPU at 100%. Before optimisation: for i in range(len(df)): df.at[i, 'score'] = df.at[i, 'val'] * 1.05 if df.at[i, 'flag'] else df.at[i, 'val'] After optimisation: import numpy as np df['score'] = np.where(df['flag'], df['val'] * 1.05, df['val']) Performance gain: 85x faster execution. Vectorisation isn’t just a "nice to have"—it’s the difference between a pipeline that crashes at 2 AM and one that finishes in seconds. By letting NumPy handle the heavy lifting in C, we eliminated the Python overhead entirely. If you're still using `.iterrows()` or manual loops for column transformations, it’s time to refactor. The performance delta on large datasets is simply too massive to ignore. What is the biggest "bottleneck" function you’ve refactored recently that gave you a massive speedup? #DataEngineering #Python #PerformanceTuning #Vectorization #DataScience

🚀 Day 6: Decoding Maximum Consecutive One's 💡 How I solved it: *Maintained a running counter that increments every time I encounter a 1. *Used a global maximum variable to capture the highest streak reached before hitting a 0. *The Reset: Every time a 0 appeared, I reset the current counter to zero to begin tracking the next potential streak. 🧠 Key Takeaway: *Efficiency: Achieved O(n) time complexity and O(1) space—optimal for large datasets. *State Tracking: Learned the importance of maintaining a "local" vs. "global" state. It’s a foundational logic used in many sliding window and greedy algorithm problems. One step closer to mastering Data Structures and Algorithms! 💻🔥 The logic is getting sharper every day! 📈🤝 #100DaysOfCode #DSA #Python #ProblemSolving #StriverA2ZSheet #CodingJourney

Day 8: Cracking the Subarray Sum Logic 🧩 💡 How I solved it: Instead of a slow O(n^2) brute-force approach, I used the Prefix Sum + Hash Map technique to achieve a highly efficient O(n) solution. *Tracked the Running Sum: Maintained a current_sum as I traversed the array. *The Difference Trick: For every element, I checked if (current_sum - k) existed in my hash map. If it did, it meant a subarray summing to k had just been completed. *Frequency Mapping: Used a dictionary to store how many times each prefix sum occurred, ensuring every valid subarray was counted. *Handled the Edge Case: Initialized the map with {0: 1} to correctly catch subarrays that sum to k starting right from index 0. 🧠 Key Takeaway: *Space-Time Optimization: By using O(n) space for the hash map, I eliminated the need for nested loops, drastically speeding up the execution. *Mathematical Insight: Reinforced the logic that Sum(i, j) = PrefixSum(j) - PrefixSum(i-1). This is a powerhouse pattern for any range-sum problem. One step closer to mastering Data Structures and Algorithms! 💻🔥 The logic is getting sharper every day! 📈🤝 #100DaysOfCode #DSA #Python #ProblemSolving #StriverA2ZSheet #CodingJourney

✅ Day 69 of 100 Days LeetCode Challenge Problem: 🔹 #1009 – Complement of Base 10 Integer 🔗 https://lnkd.in/geVPugvi Learning Journey: 🔹 Today’s challenge involved finding the bitwise complement of a base-10 integer. 🔹 I first converted the integer into its binary representation using bin(n)[2:] to remove the 0b prefix. 🔹 Then I iterated through each bit and flipped it: • 0 becomes 1 • 1 becomes 0 🔹 After constructing the flipped binary string, I converted it back to a decimal integer using int(s, 2). Concepts Used: 🔹 Binary Representation 🔹 Bit Manipulation 🔹 String Traversal 🔹 Base Conversion (Binary → Decimal) Key Insight: 🔹 Converting the number to binary makes it easy to flip bits directly. 🔹 After inversion, converting the binary string back to base-10 produces the required complement. Complexity: 🔹 Time: O(b) where b is the number of bits in n 🔹 Space: O(b) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

Don't flatten what naturally has structure. It's tempting to model everything in a single class. Easy to write, easy to read, at least until your data grows. This is where most codebases start, with just one model. But with model composition, each model has a single responsibility. And Pydantic handles nested validation automatically. Structure your models the way your domain is actually structured. The code gets cleaner, the errors get clearer, and reuse becomes obvious. This and other real-world modelling patterns are covered in Practical Pydantic: 👉 https://lnkd.in/eGiB7ZxU Model your domain. Not just your data. #Python #Pydantic #Data #Models #Patterns

Weekly Challenge 9: TSP With Farthest Insertion. How do you find the shortest route to visit multiple locations without wasting fuel or time. This is known as the Traveling Salesperson Problem (TSP), one of the most famous challenges in computer science and Operations Research. Since finding the "perfect" route by checking every combination takes too long, we use Heuristics to find highly optimized routes in milliseconds. For Week 9 of my Python challenge, I built a spatial heuristic from scratch: > 1️⃣ Generated random nodes (cities) on a 2D plane. > 2️⃣ Calculated their Euclidean distance from the origin. > 3️⃣ Programmed an **Insertion Sort** algorithm to sort the nodes by distance. > 4️⃣ Compared the random route vs. the optimized route. > 📉 The Result: As you can see in the graph below, just by applying this sorting logic, the route distance is drastically reduced (saving over 30% in travel distance in most random scenarios!). Data visualization makes optimization beautiful. Full source code on my GitHub: https://lnkd.in/epZBxUnQ #Python #Optimization #OperationsResearch #DataScience #Matplotlib #Algorithms #CodingChallenge 

🚀 Day 42/100 – LeetCode Challenge Solved 206. Reverse Linked List today! 🔍 Problem Summary: Given the head of a singly linked list, reverse the list and return the new head. 💡 Approach: Implemented an iterative solution using three pointers (prev, curr, next) to reverse the links efficiently in-place. Also explored the recursive approach to strengthen understanding of linked list manipulation. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) (Iterative) 📌 Key Takeaways: Importance of pointer manipulation Handling edge cases like empty list Difference between iterative vs recursive approaches Consistency is key — one step closer to mastering Data Structures & Algorithms! 💪 #LeetCode #100DaysOfCode #DataStructures #Algorithms #CodingJourney #Python #ProblemSolving #LinkedList

✅ Day 75 of 100 Days LeetCode Challenge Problem: 🔹 #415 – Add Strings 🔗 https://lnkd.in/gHVN5VfP Learning Journey: 🔹 Today’s problem required adding two numbers represented as strings without directly using built-in conversion functions. 🔹 I implemented a helper function to convert a string into its numeric value by iterating through digits and multiplying them with the correct powers of 10. 🔹 After converting both strings to integers, I performed the addition. 🔹 Then, I converted the result back into a string by extracting digits using modulo (%) and reversing the constructed list. Concepts Used: 🔹 String to Number Conversion 🔹 Mathematical Digit Handling 🔹 Modulo & Division 🔹 String Construction Key Insight: 🔹 Manually converting between string and integer helps understand how numbers are built and processed internally. 🔹 Constructing the result in reverse and then reversing it ensures correct digit order. Complexity: 🔹 Time: O(n + m) 🔹 Space: O(n + m) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

✅ Day 74 of 100 Days LeetCode Challenge Problem: 🔹 #653 – Two Sum IV: Input is a BST 🔗 https://lnkd.in/g9vDFKMA Learning Journey: 🔹 Today’s problem required checking whether there exist two nodes in a Binary Search Tree whose values sum to k. 🔹 I performed a Depth-First Search (DFS) traversal using a stack to visit all nodes of the tree. 🔹 While traversing, I stored each node’s value in a list. 🔹 Then I used a hash set to track visited values and checked whether the complement (k - value) already exists. 🔹 If the complement is found, it means two numbers sum to k, so the function returns True. Concepts Used: 🔹 Depth-First Search (DFS) 🔹 Stack-based Tree Traversal 🔹 Hash Set for Fast Lookup 🔹 Two Sum Pattern Key Insight: 🔹 The classic Two Sum approach works well after collecting values from the BST. 🔹 Using a set allows O(1) lookup, making it efficient to check complements during iteration. Complexity: 🔹 Time: O(n) 🔹 Space: O(n) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

🚀 Solved Another Sliding Window Problem on LeetCode! Today’s problem: Maximum Number of Vowels in a Substring of Given Length (LeetCode #1456) 💡 Problem Summary: Given a string s and an integer k, find the maximum number of vowels in any substring of length k. ❌ Brute Force Approach: Generate all substrings of size k Count vowels in each substring Time Complexity: O(n × k) → not efficient ✅ Optimized Approach: Sliding Window Instead of recalculating everything: Count vowels in the first window Slide the window forward: Add next character Remove previous character Track the maximum count 👉 Core Idea: count = count + new_char - old_char 💻 Clean Code: def maxVowels(s, k): vowels = set("aeiou") count = 0 for i in range(k): if s[i] in vowels: count += 1 max_count = count for i in range(k, len(s)): if s[i] in vowels: count += 1 if s[i - k] in vowels: count -= 1 max_count = max(max_count, count) return max_count ⚡ Complexity: Time: O(n) Space: O(1) 🧠 Key Takeaway: Sliding Window is not just a technique — it’s a mindset. You reuse previous computation instead of recalculating everything. 🔥 This pattern applies to: Strings & Arrays Substring / Subarray problems Real-world streaming data #DSA #LeetCode #Coding #SlidingWindow #InterviewPreparation #Python #ProblemSolving