Two Sum Problem Solved with HashMap

📆 Day 21/30 of #30DaysofDSA Streak : 21/30 ✅ Problem : Isomorphic string(LC #205) 🧠 problems was we have Given two strings s and t we have to determine if they are isomorphic. Approach : we will make two maps which tracks mapping from one character to another of second string. Time Complexity -O(n) Space complexity - O(n) 💪 Key takeaways : -one to one map checking using hashmaps while iterating. What approach would u use ?Drop in comments! #DSA #challenge #Leetcode #30DaysofDSA #Java #Data #Algorithm #tech #CodingJourney

🚀 100 Days of Code Day-25 LeetCode Problem Solved: Reverse Nodes in k-Group I recently worked on a Linked List problem that focuses on reversing nodes in groups of size k while preserving the remaining structure if the group size is less than k. 🔹 Strengthened my understanding of pointer manipulation 🔹 Improved problem decomposition skills 🔹 Practiced recursive thinking for efficient implementation 💡 Key takeaway: Breaking complex problems into smaller, manageable parts significantly simplifies the solution approach. Continuing to build consistency in problem-solving and deepen my understanding of Data Structures & Algorithms. #LeetCode #DataStructures #Algorithms #Java #ProblemSolving #SoftwareDevelopment

Day 09 of #50DaysOfLeetCode Challenge Just tackled the "Combination Sum" problem! This was a fantastic exercise in backtracking. The challenge is to find all unique combinations of numbers that sum up to a specific target, with the twist that you can use the same number multiple times. Key Insights: Backtracking Power: It’s all about exploring every possible path and "backtracking" as soon as the sum exceeds the target. State Space Tree: Visualizing how the recursion branches out helped me understand how to avoid duplicate combinations while allowing multiple uses of the same element. Decision Making: Learning when to include an element and when to move to the next index is crucial for optimizing the search. Each day, the logic gets sharper and the problems get more interesting! #DataStructures #Algorithms #CodingJourney #Java #Backtracking #LeetCode #ProblemSolving #SoftwareEngineering

🚀 Day 565 of #750DaysOfCode 🚀 🔍 Problem Solved: Minimum Absolute Distance Between Mirror Pairs Today’s problem was all about identifying mirror pairs in an array — where reversing one number equals another — and finding the minimum index distance between such pairs. 💡 Key Insight: Instead of brute force (O(n²)), we can optimize using a HashMap to track previously seen reversed values. 🧠 Approach: Traverse the array once For each number: Check if it already exists in the map → update minimum distance Compute its reverse Store the reversed number with its index Return the minimum distance, or -1 if no pair exists 📊 Complexity: Time: O(n × d) → d = number of digits Space: O(n) 🔥 Takeaway: Using a reverse transformation + hashmap lookup converts a nested loop problem into a linear scan — a classic optimization pattern! #Day565 #750DaysOfCode #LeetCode #Java #DataStructures #Algorithms #CodingJourney #HashMap #ProblemSolving

🚀 Consistency + Clarity = Progress Today I solved the Root to Leaf Paths problem on binary trees using recursion and backtracking. 🔍 Key Learnings: Understood the backtracking pattern (add → recurse → remove) Learned how to correctly identify leaf nodes Improved clarity on managing state (path list) during recursion 💡 What made the difference: Instead of memorizing, I focused on understanding the pattern — and everything clicked. 📊 Result: ✅ All test cases passed (1115/1115) ✅ 100% accuracy This is part of my ongoing journey to strengthen my Data Structures & Algorithms (DSA) fundamentals. 🎯 Takeaway: Mastering patterns like recursion and backtracking makes complex problems feel simple. #DSA #Java #Coding #ProblemSolving #Recursion #Backtracking #BinaryTree #LearningJourney #Consistency

Day 25 of my #30DayCodeChallenge: The Art of Categorization! The Problem: Group Anagrams. Given an array of strings, group the words that are rearrangements of each other. The Logic: This problem is a perfect example of using Hashing and Canonical Forms to organize unstructured data efficiently. 1. Identifying the "Signature": The core challenge is realizing that all anagrams, when sorted alphabetically, become the exact same string. I used this "sorted version" as a unique key (the signature) for each group. 2. The Hash Map Strategy: I utilized a HashMap<String, List<String>>. Key: The sorted version of the word. Value: A list of all original words that match that sorted key. 3. Efficient Lookups: Using computeIfAbsent, I streamlined the process of initializing lists and adding words in a single pass. This keeps the code clean and the logic tight. Complexity Analysis: Time Complexity: O(N Klog K), where N is the number of strings and K is the maximum length of a string (due to sorting). Space Complexity: O(N K) to store the grouped strings in our map. One step closer to mastery. Onward to Day 26! #Java #Algorithms #DataStructures #Hashing #ProblemSolving #150DaysOfCode #SoftwareEngineering

🚀 Day 547 of #750DaysOfCode 🚀 🔥 Solved: Check if Strings Can be Made Equal With Operations II (LeetCode Medium) 💡 Problem Insight We can swap characters at indices i and j such that: 👉 (j - i) is even 🧠 Key Observation If (j - i) is even ⇒ 👉 indices belong to the same parity group So: Even indices form one group Odd indices form another group 👉 We can rearrange freely within each group 🚫 But cannot mix between them ⚡ Optimized Approach (Single Array Trick) Instead of using two arrays, we can: Use a single frequency array of size 52 First 26 → even indices Next 26 → odd indices 👉 Clever use of: int off = (i & 1) * 26; i & 1 = 0 → even → offset 0 i & 1 = 1 → odd → offset 26 🚀 Day 547 of #750DaysOfCode 🔥 Solved: Check if Strings Can be Made Equal With Operations II (LeetCode Medium) 💡 Problem Insight We can swap characters at indices i and j such that: 👉 (j - i) is even 🧠 Key Observation If (j - i) is even ⇒ 👉 indices belong to the same parity group So: Even indices form one group Odd indices form another group 👉 We can rearrange freely within each group 🚫 But cannot mix between them ⚡ Optimized Approach (Single Array Trick) Instead of using two arrays, we can: Use a single frequency array of size 52 First 26 → even indices Next 26 → odd indices 👉 Clever use of: int off = (i & 1) * 26; i & 1 = 0 → even → offset 0 i & 1 = 1 → odd → offset 26 📈 Complexity Time: O(n) Space: O(1) 💬 Key Takeaway This problem is a great example of: 👉 Index grouping + frequency balancing And the optimization shows: 👉 How bit manipulation (i & 1) + offset trick can reduce space & simplify logic 🔥 🔁 Small optimizations → Big impact over time Consistency continues 💯 #LeetCode #Algorithms #DataStructures #Java #ProblemSolving #CodingChallenge #750DaysOfCode #Consistency

Day 76/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Lowest Common Ancestor of a Binary Tree A fundamental tree problem that builds strong recursion intuition. Problem idea: Find the lowest node in the tree that has both given nodes as descendants. Key idea: DFS + recursion (bottom-up approach). Why? • Each subtree can independently tell if it contains p or q • Combine results while backtracking • First node where both sides return non-null → answer How it works: • If current node is null / p / q → return it • Recursively search left and right subtree • If both left & right are non-null → current node is LCA • Else return the non-null side Time Complexity: O(n) Space Complexity: O(h) (recursion stack) Big takeaway: Tree problems often rely on post-order traversal + combining child results. Understanding this pattern unlocks many binary tree problems. 🔥 Day 76 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #BinaryTree #Recursion #DFS #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

Day 6 of #100DaysOfLeetCode ✅ Today I solved LeetCode 128 — Longest Consecutive Sequence. 🧩 Problem Summary: Given an unsorted array of integers, the task is to find the length of the longest sequence of consecutive numbers. The challenge is to solve it in O(n) time complexity, which means sorting is not allowed. 💡 Key Learning: Instead of sorting, I used a HashSet for O(1) lookup. The main intuition: 👉 A number starts a sequence only if (num - 1) does NOT exist in the set. Then we expand forward (num + 1) to count the sequence length. ⚡ Concepts Practiced: • HashSet / Hashing • Optimized Searching (O(1) lookup) • Sequence Detection Pattern • Time Complexity Optimization 📈 Time Complexity: O(n) 📦 Space Complexity: O(n) Every day improving problem-solving skills and understanding data structures deeper 🚀 #DSA #LeetCode #Java #CodingJourney #Consistency

Day 57/100 | #100DaysOfDSA ⛰️🔍 Today’s problem: Peak Index in a Mountain Array A perfect use-case of Binary Search on a pattern. Key observation: The array increases → reaches a peak → then decreases. Approach: • Use binary search on the index • Compare mid with mid + 1 • If arr[mid] > arr[mid + 1] → we are on the decreasing side → move left • Else → we are on the increasing side → move right This guarantees we always move toward the peak. Time Complexity: O(log n) Space Complexity: O(1) Big takeaway: Binary search isn’t just for sorted arrays — it works on patterns too. Recognizing these patterns is a game changer. 🔥 Day 57 done. #100DaysOfCode #LeetCode #DSA #Algorithms #BinarySearch #Arrays #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity