How HashMaps Simplify Array and String Problems

🚀 Two Pointer Technique — The Hidden Gem of Optimized Problem Solving The Two Pointer technique is one of those elegant patterns that transforms nested loops into clean O(n) solutions. It’s all about using two indices that move through your data — sometimes from opposite ends, sometimes together — to efficiently compare, partition, or traverse arrays and strings. Whether it’s finding pairs with a target sum, removing duplicates in-place, or checking for palindromes, the principle stays the same: 👉 Use movement, not brute force. Instead of restarting the search every time, the Two Pointer method lets you reuse previously processed data, dramatically reducing unnecessary computations. From array problems to linked lists, and even complex challenges like “Container With Most Water” or “3Sum,” mastering this pattern unlocks a new level of clarity and performance in your problem-solving approach. Follow Codekerdos for more algorithm deep-dives, clean code patterns, and practical insights that sharpen your developer mindset 🔥 #Algorithms #TwoPointer #ProgrammingTips #DeveloperMindset #Codekerdos #CleanCode #SoftwareEngineering #100DaysOfCode #google

🚀 DSA Challenge – Day 94 Problem: Design LRU (Least Recently Used) Cache ⚡📦 This was one of those classic data structure design problems that truly tests your understanding of hash maps and linked lists working together seamlessly for O(1) performance! 🧠 Problem Summary: Implement a data structure that behaves like an LRU Cache, supporting: ✅ get(key) → Retrieve value in O(1). ✅ put(key, value) → Insert/update value in O(1). ✅ Automatically evict the least recently used key when capacity is exceeded. ⚙️ My Approach: To achieve O(1) operations, I combined two powerful structures: 1️⃣ HashMap (keyMap) → For constant-time key lookups. 2️⃣ Doubly Linked List → To maintain the order of usage (most recent at the front). 🔹 When a key is accessed or updated: Move it to the front (most recent). 🔹 When inserting a new key: If full → remove the least recently used node (from the tail). Insert the new key-value pair at the front. The linked list allows O(1) addition/removal, and the hashmap ensures O(1) lookup and update. 📈 Complexity: Time: O(1) → For both get and put. Space: O(capacity) → For the hashmap and list nodes. ✨ Key Takeaway: This problem elegantly demonstrates how data structures complement each other — the linked list maintains order, and the hashmap ensures constant-time access. A perfect synergy of logic and structure! ⚙️💡 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #LRUCache #DataStructures #HashMap #LinkedList #Python #Algorithms #SystemDesign #CodingChallenge #EfficientCode #InterviewPrep #TechCommunity #CodeEveryday #LearningByBuilding

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

🚀Day 77 of #120_Days_leetCode Challenge ! LeetCode Problem: Find and Replace Pattern Today’s problem was all about pattern matching with bijective mappings — where we find words that match a given pattern by establishing a one-to-one relationship between letters. 🧩 Problem Summary: Given a list of words and a string pattern, return all words that match the pattern. A word matches if you can permute letters such that each letter in the pattern maps uniquely to a letter in the word. 📘 Example: Input: words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb" Output: ["mee","aqq"] 💡 Intuition: To verify a match, we need to ensure: Each character in the pattern maps to only one unique letter in the word. No two pattern characters map to the same word character. This makes it a bijection problem — a perfect use case for hash maps. 🧠 Key Takeaways: Used two hash maps to maintain bijective character mapping. Achieved O(n * k) time complexity, where n = number of words and k = word length. Great practice for mastering string and hashmap-based logic problems. ✨ Every such problem reinforces how powerful simple mapping logic can be when applied thoughtfully. #LeetCode #ProblemSolving #CodingChallenge #DataStructures #Algorithms #ProgrammingJourney

Lessons Learned Today: Handling API Responses and Robust Code Design Today’s deep dive into building a resilient search system with the Eyecon API reminded me how critical it is to design code that’s both robust and predictable. Here’s what stood out: 1️⃣ Always anticipate missing or unexpected data Empty responses, empty lists, or missing images aren’t errors — they’re just “no data” cases. Treat them accordingly rather than letting your system crash. 2️⃣ Graceful fallbacks save headaches By returning `None` for missing or unprocessable images, and default messages for empty responses, we keep our system safe while maintaining meaningful output. 3️⃣ Be careful with assumptions in code Even a harmless debug line like `image_data[:100]` can crash if the variable is `None`. Always safeguard before slicing or indexing. 4️⃣ Legacy logic can be preserved safely We maintained legacy behavior (merging images to the first user) while improving resilience and modernizing handling of API data. 5️⃣ Asynchronous flows need careful orchestration With `asyncio.gather`, we can run multiple API calls concurrently, but we must handle exceptions individually to avoid one failure breaking the entire pipeline. The takeaway? Writing robust code isn’t just about handling happy paths . it’s about designing for every edge case, gracefully. Today was a reminder: thoughtful error handling, safe defaults, and clear data expectations make all the difference in production systems. #Python #AsyncProgramming #APIIntegration #SoftwareEngineering #RobustCode #LearningEveryday

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

🚀 How do you geocode 100,000+ messy addresses... with a $0 budget?🚀 Geocoding is easy — until it isn’t. When you deal with hundreds of thousands of records, costs explode fast. Most premium APIs charge per request, and suddenly, your “simple” data project turns into a budget nightmare. So I took on a challenge: 👉 Build a geocoding solution for a massive global dataset using only free tools (like Nominatim / OpenStreetMap). Goal: maximize completion rate at virtually zero cost. But this wasn’t just a one-off script — it turned into a resilient data pipeline in #Python. Here’s what it took to make it work 👇 1️⃣ Zero Data Loss If your script crashes 3 hours in, you can’t afford to start over. ➡️ I built a checkpoint system that saves progress in batches, so the process can resume anytime. 2️⃣ Smart Error Handling Free APIs can be picky. ➡️ I added a 3-stage fallback logic to clean and simplify bad addresses (like “PO Box” or “S/N”), dramatically improving the success rate. 3️⃣ Respecting the API Free ≠ unlimited. ➡️ The pipeline strictly follows rate limits, uses time.sleep() intelligently, and auto-retries on network timeouts — avoiding bans and keeping things smooth. 4️⃣ Full Traceability Every failed address is automatically logged with its error reason, without stopping the main process. 🎯 The result: We successfully geocoded above 90% of the dataset automatically — the rest neatly logged for manual review. By investing development time upfront, we turned a recurring external cost into a reliable internal asset. 💡 Have you tackled large-scale geocoding or data automation challenges? I’d love to hear your approaches! #DataEngineering #Python #ETL #Automation #CostOptimization #OpenStreetMap #Nominatim #Pandas #DataOps

🚀 Day 19 of #45DaysOfLeetCodeChallenge😎🌱 💡 Problem: Remove Nth Node from End of List 🧩 Platform: LeetCode 🔗 Problem :https://lnkd.in/d8DvFdvf 📌Today’s challenge was all about linked lists — one of the most fundamental and tricky data structures in problem solving. This problem tested my ability to traverse, manipulate, and modify linked lists efficiently without breaking the chain. 🔍 Understanding the Problem: Given the head of a linked list, remove the nth node from the end and return its head. Sounds simple? Not quite — the challenge lies in keeping track of the position from the end while maintaining the structure of the list. ⚙️ Approach: 🔹Used the two-pointer technique (fast and slow pointers). 🔹Moved the fast pointer n steps ahead first. 🔹Then, moved both pointers together until the fast pointer reached the end. 🔹The slow pointer now points to the node before the one to be deleted. 🔹Updated links carefully to remove the target node in one pass 💪 ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) 🔥 Key Learnings: ✅ Refreshed my understanding of linked list traversal ✅ Practiced edge case handling (like removing the head node) ✅ Strengthened problem-solving using two-pointer patterns ✅ Enhanced debugging mindset for pointer-based problems 💭 Every day with LeetCode reminds me that consistency > perfection. The more you practice, the more patterns you begin to recognize. And today was another step toward mastering data structures & algorithms! #LeetCode #100DaysChallenge #Day19 #ProblemSolving #CodingChallenge #DSA #LinkedList #TwoPointerTechnique #WomenInTech #KeepCoding #SoftwareEngineerJourney #ConsistencyIsKey

🚀 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