Understanding Map Implementations in Java

🎉 Day 13 of My 100-Day Programming Challenge! 🚀 Today, I solved the “Minimum Absolute Distance Between Mirror Pairs” problem on LeetCode. The goal is to find the minimum index distance between pairs where one number is the reverse of the other. 🧩 🔍 Approach: I used a HashMap + number reversal technique to efficiently track and compare mirror pairs. ⚙️ Steps: • Traverse the array from left to right • Reverse the current number • Check if the current number already exists in the map • If yes → calculate distance using i - previousIndex • Store the reversed number in the map for future matches 💡 Key Insights: ✔ Reversing numbers helps identify mirror pairs quickly ✔ HashMap enables O(1) lookup for efficient comparison ✔ Single pass solution makes it optimal 🧠 Complexity: • Time Complexity: O(n × d) (d = number of digits) • Space Complexity: O(n) A great problem to strengthen concepts in Hashing, Number Manipulation, and Optimization. Consistency continues — let’s keep building! 💻🔥 #100DaysOfCode #Java #LeetCode #DSA #HashMap #Programming #CodingChallenge

🔥 Day 36 of #LeetCode Journey ✅ Problem: Minimum Distance Between Three Equal Elements I Today’s problem was about finding the minimum distance between three equal elements in an array. 💡 Key Idea: Instead of checking all combinations, we track indices efficiently: Store the last two occurrences of each number When a third occurrence appears, calculate the distance Keep updating the minimum distance 🧠 What I Learned: Optimizing from brute force to O(n) approach Using HashMap effectively for tracking indices Thinking in terms of patterns instead of combinations ⚡ Time Complexity: O(n) ⚡ Space Complexity: O(n) 🔍 Example: Input: [1,2,1,1,3,1] Output: 3 Small optimizations make a big difference 💡 Staying consistent and improving every day! #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #Programming #ProblemSolving

🚀 Day 8 of #LeetCode Challenge 🔍 Problem: Climbing Stairs 💡 Approach: Used an iterative dynamic programming approach (Fibonacci pattern). Each step = sum of previous two steps Used variables instead of array to optimize space Updated values using a loop 📌 Learning: This problem is a classic example of Dynamic Programming, where we reuse previously computed results instead of recalculating. 🔥 #Day8 #LeetCode #Java #DSA #DynamicProgramming#Consistency

🚀 Day 13 of 180 — 3Sum ✅ Today I did the 3Sum problem. How I did it? 1. Using the two pointer technique. 2. Ran a for loop from i = 0 to n - 2, where n = array length. Checked two things: 3. If current element > 0 → not possible to get a valid answer, so break. 4. Avoid same ith number by comparing it with the previous value. If previous value is same as current value, move to next ith element. Initialized pointers: left = i + 1 right = n - 1 5. Found sum: If it is 0 → added triplet to list 6. Checked for duplicates: If left points to same second number → move left If right points to same third number → move right 7. If sum < 0 → left++ to increase sum 8. If sum > 0 → right-- to decrease sum 9. At last, returned the list. Day 13 done. 167 to go. 🔥 #180DaysDSA #Day12 #LeetCode #Java #DSA #TwoPointers #Strings #DSAJourney #CodingJourney #Programming #DataStructures #Algorithms #ProblemSolving #BuildInPublic #CodeNewbie #LearnToCode #100DaysOfCode #SoftwareDevelopment #Developer #StudentDeveloper #TechCommunity #LinkedInTech #CompetitiveProgramming

🚀 Day 15 of 180 — 3Sum Closest ✅ LeetCode 16 — 3Sum Closest First sort the array. Then fix one element and use two pointers for the remaining two — one at left, one at right. For every triplet I calculate the sum and check how far it is from the target: distance = |target - sum| If this distance is less than my current minimum difference, I update my answer. Moving pointers is simple — if sum is greater than target → move right pointer left if sum is less than target → move left pointer right if sum equals target → that's the closest it can get, return immediately The key thing I made sure — keep tracking the minimum difference throughout and update result whenever a closer sum is found. Day 15 done. 165 to go. 🔥 #180DaysDSA #Day15 #LeetCode #Java #DSA #TwoPointers #Sorting #ThreeSum #DSAJourney #CodingJourney #Programming #DataStructures #Algorithms #ProblemSolving #BuildInPublic #CodeNewbie #LearnToCode #100DaysOfCode #SoftwareDevelopment #Developer #StudentDeveloper #TechCommunity #LinkedInTech #CompetitiveProgramming

🚀 Day 6 of Solved LeetCode Problem 66 – Plus One 💡 📌 Problem Summary: Given an array of digits representing a large number, increment the number by 1 and return the updated array. 🔍 Key Learning: Traverse from the last digit (right to left) Handle carry (especially when digit = 9) If all digits are 9 → create a new array like [1,0,0,...] Time Complexity: O(n) () 💻 Approach: Instead of converting to an integer (which may overflow), we simulate manual addition digit by digit. #Day6 #LeetCode #Java #CodingJourney #ProblemSolving #Programming #DSA

🚀 Day 76 — LeetCode Practice 🚀 Today’s problem: Count the Number of Consistent Strings 💡 What I learned today: • Used a boolean array to efficiently track allowed characters • Practiced character indexing (c - 'a') technique • Improved understanding of string traversal using nested loops • Learned how to optimize lookup operations to O(1) 🧠 Key Idea: Store all allowed characters in a boolean array. Then, for each word, check if every character exists in the allowed set. If yes → count it as a consistent string ✅ ⚡ Approach Highlights: • Preprocessing allowed characters • Iterating through each word • Breaking early for invalid characters (optimization) • Counting only valid strings 💻 Language Used: Java Consistency is the key 🔑 — improving step by step every day! #Day76 #LeetCode #Java #CodingJourney #ProblemSolving #100DaysOfCode #Programming #Learning

🚀 Day 90 — LeetCode Practice 🚀 Today’s focus was on bit manipulation and pattern recognition. ✅ Problem Solved: 🔹 Counting Bits 💡 Key Learnings from Today: • Learned how to count set bits (1s) in binary representation • Strengthened understanding of division by 2 and modulo operations • Explored how numbers behave in binary format • Improved problem-solving using iterative approach • Practiced writing clean and efficient logic 📌 Approach Used: Iterated through each number from 0 to n and counted the number of 1s in its binary form using a loop. 🎯 Next Step: Will optimize this using Dynamic Programming (DP) for better performance. Day by day improving consistency and logic 💪 #Day90 #LeetCode #CodingJourney #Java #ProblemSolving #Consistency

🚀 Day 23 of #50DaysOfCode Solved Daily Temperatures (LeetCode 739) 🌡️ Today’s focus was on mastering the Monotonic Stack concept — one of the most powerful patterns in DSA. Learned how to efficiently find the next greater element by storing indices and resolving them smartly instead of brute force. 💡 Key Learnings: • Stack helps reduce time complexity from O(n²) → O(n) • Always think in terms of “pending answers” • Monotonic stacks are 🔥 for interview questions ✅ Status: Accepted ✔️ ⏱️ Optimized approach implemented Every day getting better at problem-solving and consistency 💪 #DSA #LeetCode #Java #CodingJourney #Consistency #100DaysOfCode #Programming

Day 8/30 of my #30DaysDSAChallenge 🚀 Solved Problem 70 on LeetCode: Climbing Stairs 🧗♂️ At first glance, it looks simple — but the real learning was in identifying the pattern. This problem is a classic example of how Dynamic Programming works behind the scenes. 💡 Key Insight: To reach step n, you can either come from n-1 or n-2. Which leads to a Fibonacci-like relation: 👉 ways(n) = ways(n-1) + ways(n-2) Instead of using recursion (which is inefficient), I implemented an optimized iterative approach with O(n) time and O(1) space. 📚 What I learned today: Recognizing DP patterns in problems Converting recursion → optimized iteration Importance of space optimization Small steps every day, but getting stronger with problem-solving 💪 #DSA #LeetCode #Java #ProblemSolving #CodingJourney #Consistency #100DaysOfCode