Java DSA Day 37: Logic Building and Array Rotation

🚀 Day 53 of My Java DSA Journey Today I worked on a Linked List pointer manipulation problem. 💡 Problem: Merge In Between Linked Lists 👉 Given two linked lists, remove nodes from index a to b in list1 and insert list2 in their place. 🧠 Approach: • Traversed to node at position a-1 • Traversed to node at position b • Found the last node of list2 • Reconnected pointers to merge lists efficiently 🔗 Key Idea: Instead of creating new nodes, I directly manipulated pointers to connect: (a-1) → list2 end of list2 → (b+1) ⚡ What I learned: • Pointer manipulation is crucial in linked lists • Traversal control matters for correct connections • Efficient solutions avoid extra memory 🎯 Takeaway: Mastering pointer logic is key to solving Linked List problems. #Day53 #90DaysOfCoding #DSA #Java #LinkedList #CodingJourney

🚀 Java DSA Progress Update I’ve solved 125/310 problems (~40%) as part of my structured Java DSA roadmap. ✔️ Strong in: Arrays, Strings, Linked Lists, Binary Search ⚡ Focusing next on: Heap, Graphs, Dynamic Programming, Sliding Window 📌 Approach: Pattern-based problem solving Time & space analysis Learning from mistakes Re-solving for retention 🎯 Goal: Become interview-ready in 30 days with strong problem-solving fundamentals. Consistent progress > perfection. #Java #DSA #LeetCode #ProblemSolving #SoftwareEngineering

Day 70 of #100DaysOfLeetCode 💻✅ Solved #3136. Valid Word problem in Java. Approach: • Checked if the word length is at least 3 • Traversed each character in the string • Ensured all characters are either letters or digits • Checked for presence of at least one vowel • Checked for presence of at least one consonant • Returned true only if all conditions are satisfied Performance: ✓ Runtime: 1 ms (Beats 99.62% submissions) 🚀 ✓ Memory: 43.08 MB (Beats 93.16% submissions) Key Learning: ✓ Practiced string validation with multiple conditions ✓ Learned efficient use of built-in character functions ✓ Strengthened logic building for edge case handling Learning one problem every single day 🚀 #Java #LeetCode #DSA #Strings #ProblemSolving #CodingJourney #100DaysOfCode

🚀 Day 57 of My Java DSA Journey Today I worked on a classic Dynamic Programming problem: 💡 Subset Sum Problem 🧠 Approach: • Used recursion with memoization • At each step, decided whether to include or exclude an element • Stored intermediate results to optimize performance 🔍 Key Insight: A subset with sum k exists if: We can form k without current element OR We can form k - arr[i] including current element ⚡ What I learned: • DP pattern similar to Knapsack • Importance of proper memoization • Handling boolean DP states 🔥 Complexity: • Time: O(n × k) • Space: O(n × k) 🎯 Takeaway: Many DP problems are variations of a few core patterns. #Day57 #90DaysOfCoding #DSA #DynamicProgramming #Java

🚀 Day 43 / 180 – DSA with Java 🚀 📘 Topic Covered: Linked List Traversal 🧩 Problem Solved: Middle of the Linked List Problem: Given the head of a singly linked list, return the middle node. If there are two middle nodes, return the second middle node. Approach: Traversed the linked list once to count the total number of nodes. Then moved again up to the middle position and returned that node. Key Learning: ✔️ Practicing linked list traversal logic ✔️ Handling even-length edge cases correctly ✔️ Exploring multi-pass solutions before optimizing further If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #LinkedList #ProblemSolving #Consistency

Day 72 of #100DaysOfLeetCode 💻✅ Solved #3866 “First Unique Even Element” problem in Java. Approach: • Traversed the array to find even numbers • For each even number, counted its occurrences in the array • If the count is exactly 1, returned that number • Continued until the first unique even number is found • Returned -1 if no such number exists Performance: ✓ Runtime: 1 ms (Beats 99.36% submissions) 🚀 ✓ Memory: 45.15 MB (Beats 98.39% submissions) Key Learning: ✓ Practiced combining conditions (even + uniqueness) ✓ Improved understanding of nested loop logic ✓ Learned how to filter and validate elements efficiently Learning one problem every single day 🚀 #Java #LeetCode #DSA #Arrays #ProblemSolving #CodingJourney #100DaysOfCode

Day 75 of #100DaysOfLeetCode 💻✅ Solved #278. First Bad Version problem in Java. Approach: • Used Binary Search to minimize API calls • Narrowed search space using isBadVersion(mid) • Moved left/right pointers based on condition • Final position gives the first bad version Performance: ✓ Runtime: 16 ms (Beats 10.29% submissions) ✓ Memory: 42.16 MB (Beats 42.59% submissions) Key Learning: ✓ Practiced Binary Search with API-based problems ✓ Improved optimization by reducing unnecessary calls ✓ Strengthened problem-solving using monotonic conditions Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinarySearch #ProblemSolving #CodingJourney #100DaysOfCode

🚀 Day 51 of My Java DSA Journey Today was a mix of Dynamic Programming 💡 Problem I solved: 📌 Longest Increasing Subsequence (LIS) • Used Dynamic Programming • Built a dp[] array to track longest subsequence ending at each index • Compared all previous elements to extend the sequence 🔍 Key idea: For each element: Find all smaller previous elements and extend the longest subsequence. ⚡ DP Relation: dp[i] = max(dp[j] + 1) where j < i and nums[i] > nums[j] 🎯 Takeaway: Dynamic Programming helps break complex problems into smaller subproblems. #Day51 #90DaysOfCoding #Java #DSA #DynamicProgramming #LIS #leetcode

Day 94/100 – Consistency Journey Today’s focus: Strings in DSA + Java Multithreading Practiced string problems involving sliding window, two pointers, and pattern-based thinking. Realized how much efficiency improves when you move from brute force to optimized approaches. On the backend side, explored ExecutorService in Java — understanding how thread pools help manage multiple tasks efficiently instead of creating threads manually every time. Key takeaway: DSA builds problem-solving mindset, while backend concepts like multithreading show how things actually scale in real-world systems. Slowly connecting both worlds. Consistency > Motivation. #Day94 #100DaysOfCode #DSA #Java #BackendDevelopment #LearningInPublic

🚀 Day 46 / 180 – DSA with Java 🚀 📘 Topic Covered: Matrix Manipulation 🧩 Problem Solved: Rotate Image Problem: Given an n x n matrix representing an image, rotate it 90 degrees clockwise in-place. Approach: First transposed the matrix by swapping rows and columns across the diagonal. Then reversed each row to complete the 90-degree clockwise rotation efficiently without extra space. Key Learning: ✔️ Breaking matrix problems into smaller transformations ✔️ Understanding transpose operations ✔️ Solving in-place matrix rotation with O(1) extra space If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Matrix #ProblemSolving #Consistency 💙