4Sum Problem Solution and Optimization

Day 9: Mastering the Two-Sum Strategy 🎯 💡 How I solved it: Instead of a slow O(n^2) nested loop to find pairs, I used a One-Pass Hash Map to achieve a lightning-fast O(n) solution. Target Calculation: For every number n, I calculated the diff (target - n) needed to complete the pair. Instant Lookup: I checked if this diff already existed in my prev_map. If it did, I immediately returned the indices. Dynamic Mapping: If the complement wasn't found, I stored the current number and its index {val: index} in the map to be used for future lookups. The Single Pass: This allowed me to find the answer in just one trip through the array. 🧠 Key Takeaway: Efficiency First: Trading a tiny bit of memory O(n) space for a massive gain in speed O(n) time is the hallmark of an optimized algorithm. Complement Logic: Learned that searching for a "pair" is really just searching for a "complement." Dictionary Power: This project reinforced how Python’s dictionary lookups are O(1) on average, making them the ultimate tool for reducing time complexity. One step closer to mastering Data Structures and Algorithms! 💻🔥 The logic is getting sharper every day! 📈🤝 #100DaysOfCode #DSA #Python #TwoSum #ProblemSolving #StriverA2ZSheet #CodingJourney

✅ 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

🚀 LeetCode Win: Missing Number (Beats 100%) Solved this problem using a simple mathematical insight instead of overcomplicating the logic ⚡ 🧠 Core Idea: If a list contains numbers from 0 → n, one number is missing. 👉 So instead of searching for it… I compared: Expected sum (0 → n) Actual sum (given array) ⚙️ Approach: Generate range → 0 to n Compute expected sum Subtract actual array sum ✅ Missing Number = Expected Sum - Actual Sum 🔥 Why this approach stands out: ⏱️ O(n) Time Complexity 💾 O(1) Space Complexity ❌ No extra loops ❌ No sorting ✔️ Clean & efficient 📊 Result: ⚡ Runtime: 0 ms (Beats 100%) 📉 Memory: Optimized 💭 Key Learning: The best solutions aren’t always complex. Sometimes, stepping back and thinking mathematically changes everything. 🚀 Consistency check: Showing up, solving daily, improving 1% 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #Python #CodingJourney #100DaysOfCode #DeveloperLife #WomenWhoCode #TechGrowth #CodeDaily #ProgrammingLife #SoftwareEngineer #ConsistencyWins

✅ Day 73 of 100 Days LeetCode Challenge Problem: 🔹 #3871 – Count Commas in Range II 🔗 https://lnkd.in/gZGbzZ_F Learning Journey: 🔹 Today’s problem asked for the total number of commas used when writing all integers from 1 to n in standard number formatting. 🔹 In this format, a comma appears after every three digits from the right (e.g., 1,000 or 1,000,000). 🔹 Instead of formatting every number individually, I observed that commas start appearing at specific thresholds: • Numbers ≥ 1,000 contribute one comma • Numbers ≥ 1,000,000 contribute two commas • Numbers ≥ 1,000,000,000 contribute three commas, and so on 🔹 I handled each threshold and added the number of integers that contribute commas for that range. Concepts Used: 🔹 Mathematical Pattern Observation 🔹 Conditional Counting 🔹 Large Number Thresholds Key Insight: 🔹 Numbers only start contributing commas after certain digit lengths (powers of 10). 🔹 Counting how many numbers exceed each threshold avoids iterating through all values up to n, making the solution efficient. Complexity: 🔹 Time: O(1) 🔹 Space: O(1) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

Handling outliers has always been a challenge for ML practitioners. From basic statistical methods to modern machine learning approaches, there are many techniques available for detecting and handling outliers. The difficult part is figuring out which method actually works best for your data. To make this easier, I built a Python library called AnLOF that helps handle outliers more effectively. Check it out: PyPI: https://lnkd.in/gCpfPgfs github : https://lnkd.in/gCnQN4Eu I'd love to hear your feedback

🚀 Day 5 – DSA Daily Series Today’s Problem: Container With Most Water (LeetCode 11) Today I worked on this interesting problem and really enjoyed the process of figuring out the optimal approach. 🧠 Problem Given an array height where each element represents the height of a vertical line, we need to find two lines that together with the x-axis can form a container that holds the maximum amount of water. The amount of water the container can hold depends on: • The shorter height between the two lines • The distance between them Formula used: Area = min(height[i], height[j]) × (j - i) 💡 Approach At first glance, it may look like we need to check all pairs of lines, which would lead to a brute-force O(n²) solution. Instead, I used the Two Pointer technique: • Start with one pointer at the beginning and another at the end of the array • Calculate the area between them • Keep track of the maximum area found • Move the pointer pointing to the smaller height, since moving the larger one won’t increase the area This makes the solution much more efficient. ⏱ Complexity Time Complexity: O(n) Space Complexity: O(1) 🔎 Key Learning Problems like this are interesting because they show how the right observation can reduce a brute-force solution into a much more efficient one using patterns like Two Pointers. Continuing the DSA Daily Series — one problem at a time. 🚀 #DSA #LeetCode #Python #Algorithms #ProblemSolving #CodingJourney

🚀 Day 11 – DSA Daily Series Today’s Problem: Find Minimum in Rotated Sorted Array (LeetCode 153) Today I solved an interesting problem that involves finding the minimum element in a rotated sorted array. 🧠 Problem You are given a sorted array that has been rotated several times. The task is to find the minimum element in the array. Example: Input: nums = [3,4,5,1,2] Output: 1 💡 Approach I solved this problem using Binary Search. Key idea: • In a rotated sorted array, the minimum element lies at the rotation point • Compare the middle element with the rightmost element • If nums[mid] > nums[high], the minimum lies in the right half • Otherwise, it lies in the left half including mid By narrowing the search space, we efficiently locate the minimum element. ⏱ Complexity Time Complexity: O(log n) Space Complexity: O(1) 🔎 Key Learning Binary Search can be extended beyond simple searching and used to identify structural properties of arrays like rotation points. Continuing the DSA Daily Series — solving and learning one problem at a time. 🚀 #DSA #LeetCode #Python #Algorithms #BinarySearch #CodingJourney #ProblemSolving

🚀 DSA Practice – Move All Zeros to the End of an Array Today I tackled a common array manipulation problem: Moving all zeros to the end while maintaining the relative order of non-zero elements. 📌 Problem Statement: Given an array arr[], push all the zeros to the end of the array. The relative order of the non-zero elements must remain the same. 🧠 My Approach: 1️⃣ Initialize a pointer count to keep track of the position where the next non-zero element should be placed. 2️⃣ Traverse the array. Every time a non-zero element is encountered, swap it with the element at the count index and increment count. 3️⃣ By the end of the single traversal, all non-zero elements are at the front, and zeros are naturally pushed to the back. ⚙️ Example: Input: [3, 5, 0, 0, 4] Output: [3, 5, 4, 0, 0] 📊 Complexity: Time Complexity: $O(n)$ (Single pass through the array) Auxiliary Space: $O(1)$ (In-place swap, no extra space used) 💻 Language Used: Python This problem is a classic example of the Two-Pointer technique, which is essential for writing efficient, in-place algorithms. Keeping the momentum going as I prepare for upcoming placements! 💪 #DSA #Python #CodingPractice #ProblemSolving #Arrays #TwoPointers #LearningInPublic

✅ 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

🔍 Debugging a Graph Problem: Longest Cycle in a Directed Graph Today I worked on an interesting problem — finding the longest cycle in a directed graph using DFS + cycle detection. Initially, my approach was correct, but I ran into errors due to small mistakes like: ❌ Typo in variable name (inCureentDfs) ❌ Wrong operator (. instead of -) ❌ Missing proper cycle detection handling After fixing them, the solution worked perfectly 🚀 💡 Key Concept: To detect a cycle and calculate its length: Use visited[] to track visited nodes Use inCurrentDfs[] to detect cycles Use dist[] to calculate cycle length 👉 Formula used: Cycle Length = dist[current] - dist[cycle_start] + 1 💻 Final Solution: class Solution: def longestCycle(self, V, edges): self.res = -1 self.next = [-1] * V for u, v in edges: if v != -1: self.next[u] = v self.visited = [False] * V self.dist = [0] * V self.inCurrentDfs = [False] * V def dfs(u): self.visited[u] = True self.inCurrentDfs[u] = True v = self.next[u] if v != -1: if not self.visited[v]: self.dist[v] = self.dist[u] + 1 dfs(v) elif self.inCurrentDfs[v]: self.res = max(self.res, self.dist[u] - self.dist[v] + 1) self.inCurrentDfs[u] = False for i in range(V): if not self.visited[i]: dfs(i) return self.res ✨ Learning: Sometimes, it's not about logic — it's about attention to detail. Small bugs can break the entire solution. #DataStructures #Algorithms #Python #CodingJourney #Debugging #GraphTheory #Learning