Java String Algorithms Practice - Day 10

Here are some more questions for you guys to check out 😊: 1.How does a Set ensure uniqueness, and what internal checks are performed to detect duplicates? 2.Which sorting algorithm is used internally by Collections.sort() in Java, and why was it chosen? 3.How do you handle circular dependencies in a Spring-based project? What approaches have you used in real scenarios? 4.If the same Spring event is published multiple times with different outcomes, how does Spring differentiate and route these events to the appropriate listeners? 5.How would you design and implement a cache that refreshes itself at fixed intervals without using cron jobs? If these questions helped you, hit like 👍, share 🔁, and tag a fellow developer who might benefit from them. #JavaInterview #SpringInterview #InterviewQuestions #TechInterviews #CodingInterviews

🚀Day 14 of #120DaysOfCode 📌 Problem: Matrix Reshape(566) 📌 Language: Java 🔍Approach 1. Check if Reshape is possible 2. Traverse the original matrix in row order 3. Mapping logic ⏱️ Time and Space Complexity Time Complexity: O(m x n) Space complexity: O(r x c) 🔥One problem closer to mastery #120DaysOfCode #Day14 #Java #Array #Leetcode #ProblemSolving #Consistency #LearningEveryday #LearningPublic #DSA

🚀 Daily DSA Practice – Day 20 | Advanced Linked List Manipulation (Java) As part of my ongoing Data Structures & Algorithms preparation, today I focused on advanced linked list problems involving complex pointer relationships, duplicate handling, and node swapping, all implemented using Java. 📌 Problems Solved (LeetCode): • 138. Copy List with Random Pointer – Created a deep copy using efficient node mapping to preserve random pointers • 82. Remove Duplicates from Sorted List II – Removed all nodes with duplicate values using careful pointer traversal • 24. Swap Nodes in Pairs – Swapped adjacent nodes using in-place pointer manipulation 🎯 Key Learnings: ✔ Improved handling of complex node relationships and deep copy logic ✔ Strengthened understanding of duplicate elimination in sorted lists ✔ Mastered safe node swapping without modifying node values ✔ Implemented O(n) time and O(1) / O(n) space optimized Java solutions These problems pushed my understanding of linked list internals and enhanced my confidence in solving medium-level interview problems involving non-trivial pointer logic. #DSA #LeetCode #Java #LinkedList #ProblemSolving #BackendDeveloper #SoftwareEngineer #InterviewPreparation

🚀Day 5 of #120DaysOfCode 📌 Problem: Height Checker 📌 Language: Java 🔍Approach(Two Pointer Technique) 1. make a copy of heights 2. Sort the copy --> this becomes expected 3. Traverse both arrays 4. Count indices where values differ 🔥 Key Insight 1. Create the expected order by sorting a copy of heights 2. Compare both arrays index by index 3. Count mismatches ⏱️ Time and Space Complexity Time Complexity: O(n log n) Space complexity: O(n) 🔥One problem closer to mastery #120DaysOfCode #Day5 #Java #Array #Leetcode #ProblemSolving #Consistency #LearningEveryday #LearningPublic #DSA

📌 DSA Series — Day 2 - Problem 2 | Arrays Problem: Rotate Array (Rotate Right by k Steps) 🔹 Problem Understanding: Given an array, rotate it to the right by k steps, where k can be greater than the array length. 🔹 Approach: Reduce k using modulo (k % n) to avoid unnecessary rotations. Store the last k elements in a temporary array. Shift the remaining elements to the right by k positions. Copy the stored elements back to the front. 🔹 Why this works: Right rotation essentially moves the last k elements to the front while preserving the order of the rest. 🔹 Time Complexity: O(n) 🔹 Space Complexity: O(k) 🔹 Java Implementation: class Solution { public void rotate(int[] nums, int k) { if (nums == null || nums.length == 0) return; k %= nums.length; if (k == 0) return; // Createing a Temp array int n = nums.length; int[] temp = new int[k]; // Copy last k elements for (int i = 0; i < k; i++) { temp[i] = nums[n - k + i]; } // Shift remaining elements for (int i = n - 1; i >= k; i--) { nums[i] = nums[i - k]; } // Restore temp for (int i = 0; i < k; i++) { nums[i] = temp[i]; } } } 🔹 Key Insight: Using modulo prevents redundant rotations when k is larger than the array size. 📈 Continuing my daily DSA problem-solving series. #DSA #Arrays #Java #ProblemSolving #StriversA2Z #CodingJourney

day 93/100 #leetcodegrind “Find Minimum in a Sorted Rotated Array” problem — a classic example of Binary Search in action. 💡 Key idea: In a rotated sorted array, the minimum element is the pivot. By comparing mid and high elements, we can efficiently narrow the search space to find the minimum in O(log n) time. 🧠 What I practiced: Binary search on rotated arrays Identifying the pivot element efficiently Handling edge cases like non-rotated arrays Writing clean and optimized Java code It’s a simple problem, but it reinforces the power of binary search in non-traditional ways. Rotation? No problem! 🔄🚀 #DSA #ProblemSolving #Java #BinarySearch #Arrays #LeetCode #CodingPractice #DailyLearning

🚀 Daily DSA Practice – Day 16 | Linked List Operations (Java) As part of my continued Data Structures & Algorithms preparation, today I practiced essential linked list manipulation problems, focusing on node comparison, deletion, and clean list restructuring using Java. 📌 Problems Solved (LeetCode): • 21. Merge Two Sorted Lists – Merging two lists using a dummy node for clean pointer management • 83. Remove Duplicates from Sorted List – Eliminating consecutive duplicates in a sorted list • 203. Remove Linked List Elements – Removing nodes with a target value using dummy head technique 🎯 Key Learnings: ✔ Improved confidence with dummy nodes to simplify edge cases ✔ Strengthened understanding of pointer traversal and node deletion ✔ Handled head-node modifications safely and cleanly ✔ Implemented O(n) time and O(1) space optimized Java solutions These problems further solidified my grasp of linked list fundamentals, which are commonly tested in technical interviews. #DSA #LeetCode #Java #LinkedList #ProblemSolving #BackendDeveloper #SoftwareEngineer #InterviewPreparation

🧠 DSA Wednesday | LeetCode – 4Sum (Java) Solved 4Sum using sorting + two pointers 💡 🔍 Problem: Given an array, find all unique quadruplets whose sum equals the target. ✨ Key ideas that make this work: • Sorting the array → enables two-pointer approach • Skipping duplicates → avoids repeated answers • Using long sum → prevents integer overflow (🔥 important line!) 📌 Why this approach matters: Brute force is slow ❌ Optimized logic = clean, efficient, and interview-ready ✅ DSA is not about writing long code — it’s about thinking smart and handling edge cases. 👉 Would you like a breakdown of the duplicate-skipping logic next? #DSA #LeetCode #Java #ProblemSolving #WednesdayWisdom #CodingJourney #TwoPointers #InterviewPrep

DSA Practice | Pair Sum Problem (Brute Force Approach) :- Problem Statement: Given an array of integers and a target value, check whether any pair of elements in the array sums up to the target. Practiced a Data Structures and Algorithms problem using Java, where the task was to determine whether a pair of elements in an array adds up to a given target value. I implemented a brute-force approach using nested loops to check all possible unique pairs in the array. To keep the solution clean and efficient, I used a boolean flag instead of strings and applied proper loop control to stop unnecessary comparisons once the required condition was met. This problem helped reinforce important Java and DSA concepts such as: Pair-wise comparison using nested loops Using boolean flags for condition tracking Writing clean, readable, and interview-friendly code Understanding time and space complexity Time Complexity: O(n²) #DSA #JAVA

DSA journey 🚀 📌 LeetCode #4 – Median of Two Sorted Arrays 💻 Language: Java 🔹 Approach: Merge both sorted arrays into a single sorted array If the total length is even, calculate the median using the formula: Median = (arr[n/2] + arr[n/2 − 1]) / 2 If the total length is odd, the median is: Median = arr[n/2] ⏱ Time Complexity: O(n + m) 🧩 Space Complexity: O(n + m) Step-by-step clarity before optimization 💡 Consistency over perfection 💯 #DSA #Java #LeetCode #ProblemSolving #LearningInPublic #DSAWithedSlash 🚀