Solving K Closest Points to Origin with O(n log k) Complexity

I’ve been consistently practicing Data Structures & Algorithms, focusing on understanding the underlying logic and core patterns behind each problem rather than just solving them. Here’s a summary of some recent problems I’ve tackled, along with the key concepts learned 📌 225. Implement Stack using Queues Key Concept: Queue-based simulation of stack operations (using two queues or a single optimized queue) https://lnkd.in/gabQrA_R 📌232. Implement Queue using Stacks Key Concept: Stack-based implementation using two stacks — one for enqueue, one for dequeue operations https://lnkd.in/gwq44Akm 📌102. Binary Tree Level Order Traversal Key Concept: Breadth-First Search (BFS) using a queue for level-wise traversal of binary trees https://lnkd.in/gn4ejwNK 📌239. Sliding Window Maximum Key Concept: Deque-based sliding window to efficiently track the maximum element in each window https://lnkd.in/gwDAFZkP 📌435. Non-overlapping Intervals Key Concept: Sorting by end time + greedy interval selection to minimize overlaps https://lnkd.in/gVwP-2pf 📌1710. Maximum Units on a Truck Key Concept: Greedy approach inspired by the knapsack problem — maximize total units by sorting on value https://lnkd.in/gqxdifBu 📌646. Maximum Length of Pair Chain Key Concept: Similar to non-overlapping intervals — greedy selection based on the smallest end time https://lnkd.in/gik6pJ6K These problems helped me strengthen concepts like queue–stack interconversion, BFS traversal, sliding window optimization, greedy algorithms, and interval scheduling techniques. I’d highly recommend trying these problems out — they’re great for building pattern recognition and problem-solving intuition. Here’s my LeetCode Profile for reference: https://lnkd.in/gp38YMN7 #DSA #LeetCode #Java #Algorithms #ProblemSolving #CodingInterview  #SoftwareDevelopment #SDE #TechJourney #DailyCoding

⚙️ Big O Notation — Explained Simply Whether you’re preparing for interviews or aiming to write efficient code, understanding time complexity is key to becoming a better developer. Here’s a quick breakdown of the most common Big O notations 👇 ⸻ 🟩 O(1) — Constant Time Takes the same amount of time regardless of input size. Example: return arr[0] Super fast — a fixed number of operations. ⸻ 🟦 O(log n) — Logarithmic Time Grows slowly even when the input doubles. Example: Binary Search. You cut the problem in half with each step. ⸻ 🟨 O(n) — Linear Time Execution time increases directly with the number of elements. Example: Looping through an array. One step per item — simple and predictable. ⸻ 🟧 O(n log n) — Log-Linear Time Typical of efficient sorting algorithms (MergeSort, QuickSort). Faster than O(n²), but heavier than O(n). ⸻ 🟥 O(n²) — Quadratic Time Nested loops — comparing each element with every other. Example: Bubble Sort or pairwise comparisons. Good for small inputs, painful for large data. ⸻ ⚫ O(n³) — Cubic Time Triple nested loops or complex matrix operations. Rarely practical for big datasets. ⸻ 🔺 O(2ⁿ) — Exponential Time Each new element doubles the required operations. Example: Recursive Fibonacci. Scales poorly — avoid if possible. ⸻ 🚫 O(n!) — Factorial Time Used in brute-force permutation or combinatorial problems. Grows insanely fast — impractical for most real-world cases. ⸻ 💡 Summary The smaller the Big O, the better your code scales: O(1) → O(log n) → O(n) → O(n log n) → O(n²) → O(2ⁿ) → O(n!) Measure before you optimize — that’s where great engineering starts. ⸻ #BigONotation #SoftwareEngineering #Coding #Algorithms #DevJournal #gudziDevDairy

The code is perfect. The user is not. #ZeroToFullStackAI Day 5/135: The Challenge Solution & The Next Prerequisite. Outstanding work on the Day 4 calculator challenge. I am sure many of you had written the correct, functional solution. The attached code is the 100% correct answer for the tools we've established (Days 1-3). It correctly uses `int()` and `float()` to perform explicit type casting and calculate the revenue. This demonstrates mastery of our primitives. But now, we introduce a new variable into our system: the unpredictable user. What happens if a user types "apple" instead of "50"? Our code works perfectly: the `int()` function, doing its job as a feature, raises a `ValueError` to tell us "this is not a valid integer." Remember 'Value Error' is not an error but a feature to make the system robust. This is not a "flaw." It's an *unhandled event*. Our current tools allow us to execute statements. They don't allow us to make *decisions* or *handle exceptions*. We have no "safety net" because we haven't built one yet. This `ValueError` is the logical prerequisite for our next lesson. To handle it, we need a new class of tools. Tomorrow, we forge the first one: **Control Flow (`if/else`)**. #Python #DataScience #SoftwareEngineering #AI #Developer #Architecture

A script executes. An application decides. #ZeroToFullStackAI Day 6/135: The Principle of Control Flow. For the past five days, our code has been a simple, top-to-bottom script. It executes one line after another, no matter what. The `ValueError` from our Day 5 challenge proved this is not enough. We need a way to handle different conditions. Today, we build the "brain" of our application. This is "Control Flow". It’s the mechanism that allows our code to analyze a situation and make a decision. Our tool for this is the `if/elif/else` structure: 1. 'if' : The primary gate. It asks a `True/False` question. 2. 'elif' : The secondary gate. It *only* asks its question if the `if` was `False`. 3. 'else': The "catch-all." It runs *only* if all preceding conditions were `False`. This is the first and most fundamental tool for writing non-linear, intelligent logic. We can now create different paths for our program to follow. We've taught our code to make logical decisions. But we still haven't built the "safety net" for when it receives bad data (like the `ValueError`). That is the final piece of our foundation. Tomorrow, we build the safety net: **Error Handling**. #Python #DataScience #SoftwareEngineering #AI #Developer #Logic

A "for" loop works on a known quantity. A while loop works until a condition is met. One is for data; the other is for state. #ZeroToFullStackAI Day 10/135: The 'while' Loop (Conditional Iteration). Yesterday, we built an engine (the for loop) to iterate over a finite collection—like a list of prices. But what if you don't know how long something will take? How long until a user enters "quit"? How long until a web service is "online"? How long until a game level is "complete"? This requires a different kind of engine: the while loop. A while loop doesn't iterate over a collection. It iterates as long as a specific condition remains True. It's the mechanism we use to build listeners, game loops, and services that "poll" for a status change. This is our tool for managing iteration based on an unknown and conditional future state. We've mastered our iteration engines. But our List data structure is slow for finding data. Tomorrow, we build a new structure for high-speed lookups: The Dictionary. #Python #DataScience #SoftwareEngineering #AI #Developer #Automation

A script executes. An application decides. #ZeroToFullStackAI Day 6/135: The Principle of Control Flow. For the past five days, our code has been a simple, top-to-bottom script. It executes one line after another, no matter what. The ValueError from our Day 5 challenge proved this is not enough. We need a way to handle different conditions. Today, we build the "brain" of our application. This is Control Flow. It’s the mechanism that allows our code to analyze a situation and make a decision. Our tool for this is the if/elif/else structure: if: The primary gate. It asks a True/False question. elif: The secondary gate. It only asks its question if the if was False. else: The "catch-all." It runs only if all preceding conditions were False. This is the first and most fundamental tool for writing non-linear, intelligent logic. We can now create different paths for our program to follow. We've taught our code to make logical decisions. But we still haven't built the "safety net" for when it receives bad data (like the ValueError). That is the final piece of our foundation. Tomorrow, we build the safety net: Error Handling. #Python #DataScience #SoftwareEngineering #AI #Developer #Logic

📚🌃 Continuing my dive into data structures and algorithms. 🙂 🌳 Tonight’s Focus: Chapter 19 – Binary Tree Traversal In linear structures like arrays or linked lists, we move step-by-step: 0️⃣ ➡️ 1️⃣ ➡️ 2️⃣ ➡️ 3️⃣ But trees are hierarchical 🌳, so we use a different approach: Breadth-First 🔺 and Depth-First 🐋 Traversal ✅ FYI -Tree depth helps us understand how far a node is from the root -The goal is to visit every node and represent the full structure ⚙️ Traversal Basics Each node goes through two phases: Discovered Collection – We identify a node (starting from the root) and add it to this list as soon as it's found. Explored Collection – After a node is discovered, we examine its children. Once all its children have been discovered, we move the node to this list. 🔺 Breadth-First Traversal -Uses a queue (First In, First Out) -Visits nodes level by level, left to right, moving nodes from the discovered to explored collection as they are processed -Example order: A → B → C → D → E… 🐋 Depth-First Traversal -Uses a stack (Last In, First Out) -Nodes are discovered by traversing deep down the left-most path, then backtracked to the nearest unexplored node. During processing, nodes are moved from the discovered collection to the explored collection. ⚡ Performance Time: O(n) Space: O(n) Same across best, average, and worst cases 📚 Might just do half a chapter for the more involved chapters next. If you’re learning too (or just love emoji-powered breakdowns), follow along for more chapters in this series! 🚀 #JavaScript #Algorithms #Coding #DevNotes

🚀 DSA Challenge – Day 93 Problem: Find Median from Data Stream 📊⚙️ This was an exciting deep dive into data structures and real-time computation — maintaining the median efficiently while continuously adding numbers from a stream. 🧠 Problem Summary: You need to design a class MedianFinder that can: ✅ Add numbers dynamically from a data stream. ✅ Return the median at any point in time. If the total number of elements is even → median = mean of the two middle values. If odd → median = middle value. ⚙️ My Approach: 1️⃣ Use two heaps to maintain balance: A max heap (maxHeap) for the smaller half of numbers. A min heap (minHeap) for the larger half. 2️⃣ Whenever a new number arrives: Push it into the maxHeap (inverted to simulate max behavior). Balance both heaps so that their size difference is never more than 1. 3️⃣ Ensure heap order: the maximum in maxHeap ≤ minimum in minHeap. 4️⃣ The median is: The top of the larger heap (if odd count). The average of both tops (if even count). 📈 Complexity: Time: O(log n) → For insertion and heap balancing. Space: O(n) → To store all elements in heaps. ✨ Key Takeaway: This problem highlights how heaps can turn complex real-time median calculations into a smooth, efficient process — a great example of data structure synergy in action. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Heaps #PriorityQueue #DataStructures #Algorithms #Median #Python #CodingChallenge #InterviewPrep #EfficientCode #DynamicProgramming #TechCommunity #LearningByBuilding #CodeEveryday

📚🌃 Continuing my dive into data structures and algorithms. 🙂 🫧 🔁 🫧 Tonight’s focus: Chapter 22: Bubble Sort ❌ Bubble Sort is one of the simplest sorting algorithms, but also one of the most inefficient. It’s often taught not because it’s fast, but to help you recognize and avoid sluggish 🐌 sorting patterns in your own code. ⚙️ How Bubble Sort Works -Start at the beginning of the list. -Compare each pair of adjacent elements. -If the first is greater than the second, swap them. -Move one step forward and repeat the comparison. -Once you reach the end, go back to the beginning and repeat the process. -Continue this cycle until all items are sorted. -When it runs a full pass with no swaps, the list is officially sorted. ✅ Key Notes -Its best-case scenario is a sorted list, ironically, the one time you don’t need a sort. -It’s slowest when the list is in reverse order because every element needs to be moved. ⚡🐢🐌 Performance -Time complexity: Worst and average case is O(n²). -Even small lists can take many steps, sorting 4 numbers might involve 8+ steps. -Requires multiple passes through the list. It will still pass through elements that have already been sorted, so it’s inefficient for large datasets. If you're learning too, or just love a good emoji-powered breakdown, follow along for more chapters in this series! 🚀 #JavaScript #Algorithms #Coding #DevNotes