LeetCode 1200: Minimum Absolute Difference in Array

🚀 Day 13 — LeetCode Progress (Java) 🔹 Majority Element 🕒 Required: Identify the element that appears more than ⌊n/2⌋ times in the array while maintaining efficient time complexity and minimal extra processing. 💡 Idea: Since one element dominates the frequency, tracking occurrences during traversal helps quickly determine which value exceeds the threshold without needing multiple passes . ⚙️ Approach: Implemented a HashMap to store element frequencies while iterating through the array. Updated counts dynamically and leveraged the frequency data to determine the majority element based on occurrence dominance ✅. #LeetCode #DSA #Java #CodingJourney

🚀 Day 9 — LeetCode Progress (Java) 🔹 Next Greater Element I → Built a mapping using HashMap by scanning the second array and identifying the next greater value for each element, then used it to construct the result efficiently without repeated searches. ━━━━━━━━━━━━━━━━━━━━ Today’s focus was on improving array traversal logic and understanding how mapping relationships between elements can simplify future lookups. Instead of brute force comparisons for every query, pre-processing the array helped reduce unnecessary checks and made the solution cleaner. 💭 Takeaways: • Precomputing relationships using hashing can drastically reduce complexity. • Writing readable loops is just as important as getting the correct answer. • Small optimizations in logic structure make solutions easier to scale later. Consistency continues. One step closer to stronger fundamentals. 🔥 #LeetCode #DSA #Java #CodingJourney

🚀 Day 15 — LeetCode Progress (Java) 🔹 Find Lucky Integer in an Array 🕒 Required: Find the largest integer in the array whose value is exactly equal to its frequency. If no such number exists, return -1. 💡 Idea: The key observation is that we need both the value and how many times it appears. So the problem naturally reduces to frequency counting. Once frequencies are known, we can compare each number with its count and track the maximum valid one. ⚙️ Approach: Iterate through the array and store frequencies using a HashMap. After building the frequency map, traverse through the entries and check where key == value. Among all valid candidates, keep updating the maximum lucky number. This ensures correctness while keeping the logic clean and readable. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) #LeetCode #DSA #Java #CodingJourney

Day 21 — LeetCode Progress (Java) Problem: Find Peak Element Required: Given an array where adjacent elements are not equal, return the index of any peak element. A peak element is strictly greater than its neighbors. The solution must run in O(log n) time. Idea: Instead of checking every element linearly, observe this property: If nums[mid] < nums[mid + 1], then a peak must exist on the right side. If nums[mid] > nums[mid + 1], then a peak must exist on the left side (including mid). This works because the array behaves like a slope — moving toward the higher neighbor always leads to a peak. That transforms it into a binary search problem. Approach: Used binary search with two pointers: Calculated mid. Compared nums[mid] with its neighbors. Moved left or right depending on which side guarantees a peak. Returned mid when it satisfies peak conditions. Time Complexity: O(log n) Space Complexity: O(1) #LeetCode #DSA #Java #BinarySearch #CodingJourney

Day 24 — LeetCode Progress (Java) Problem: Reverse String Required: Given a character array, reverse the array in-place. You are not allowed to use extra arrays or built-in reverse utilities. The operation must modify the original array directly with O(1) extra space. Idea: Reversing doesn’t require rebuilding the string. It’s just symmetric swapping. First element swaps with last, Second swaps with second last, And so on — until pointers meet in the middle. This is a classic two-pointer pattern: One pointer from the start One pointer from the end Move inward while swapping. Approach: Initialize l = 0 and r = n - 1 While l < r: Store s[l] in a temp variable Assign s[l] = s[r] Assign s[r] = temp Increment l Decrement r Stop when pointers cross No extra array. No additional memory structure. Time Complexity: O(n) Space Complexity: O(1) Core Insight: In-place problems usually hint at two pointers. If the structure is symmetric, think mirror swaps before thinking extra space. #LeetCode #DSA #Java #TwoPointers #CodingJourney

Day 4 of #60daysofLeetcode, #7. Reverse Integer - https://lnkd.in/dqA_ciDP is the question. Solution. To reverse the integer, we repeatedly extract the last digit using modulo 10,  then build the result from left to right. Each iteration: extract the last digit,  update result = result * 10 + digit, and divide input by 10. We continue until  the input becomes zero. Before each result update, we check if the operation would cause overflow, and if so, return 0. Time Complexity is O(log n) or O(d) where d is the number of digits. Space complexity is O(1). #LeetCode, #Java, #DSA, #LearningInPublic

Day: 25/365 Problem: Find Smallest Letter Greater Than Target Easy #POTD #365DaysOfCode #DSA #Java #ProblemSolving #Consistency 🥷 Key takeaways/Learnings from this problem: 1. This one’s a classic reminder that binary search isn’t just for numbers, it works beautifully on sorted characters too.

Day 25 — LeetCode Progress (Java) Problem: Remove Duplicates from Sorted Array Required: Given a sorted array, remove duplicates in-place such that each unique element appears only once. Return the new length of the modified array. No extra array allowed — modification must be done in-place with O(1) extra space. Idea: Because the array is already sorted, duplicates are always adjacent. That means we don’t need hashing or extra storage — just compare with the previous element. This becomes a controlled overwrite problem: One pointer reads through the array. Another pointer tracks the position where the next unique element should be placed. Approach: Initialize a write pointer l = 1 (first element is always unique). Traverse the array using a read pointer r from index 1 onward. If nums[r] != nums[r - 1]: Place nums[r] at nums[l] Increment l Continue until traversal ends. Return l as the new length. The first l elements of the array now contain unique sorted values. Time Complexity: O(n) Space Complexity: O(1) Core Insight: When an array is sorted, duplication detection becomes a neighbor comparison problem — not a frequency counting problem. Sorted structure reduces complexity naturally. #LeetCode #DSA #Java #TwoPointers #CodingJourney

Java 22 is here to revolutionize your workflow! Following our first deep dive, Part 2 focuses on the features that maximize your productivity and slash boilerplate code. What’s inside: Stream Gatherers: Mastering Batching & Windowing. Unnamed Variables: Using _ for cleaner code. Statements Before super(): Logic-first constructors. Implicit Classes: Java at scripting speed. Swipe to see the code! #Java #SoftwareEngineering #CleanCode #Java22

Day 28 — LeetCode Progress (Java) Problem: Sort Array By Parity Required: Given an integer array, rearrange it so that all even numbers come first, followed by all odd numbers. Return the modified array. Idea This is a simple partitioning problem. Even and odd separation can be done by: Collecting evens first Then placing odds No sorting required. Just grouping. Approach Create a result array of same length. Traverse once: If number is even → place in result. Traverse again: If number is odd → place in result. Return result. Time Complexity: O(n) Space Complexity: O(n) (extra array used) #LeetCode #DSA #Java #Arrays #TwoPointers #CodingJourney