💡 LeetCode #15 — 3Sum Today I solved LeetCode Problem 15: 3Sum 🔍 Problem Summary: Given an integer array nums, return all unique triplets (a, b, c) such that: a + b + c = 0 The solution must not contain duplicate triplets. Key Idea: Use sorting + two pointers to reduce the time from O(n³) to O(n²). Steps: Sort the array. Fix one number (nums[f]) in each iteration. Use two pointers (i and j) to find pairs whose sum equals -nums[f]. Skip duplicates for both the fixed index and the pointer values. This efficiently finds all unique triplets. #LeetCode #Java #DSA #TwoPointers #ProblemSolving #CodingChallenge #Algorithms

NeetCode 14 | LeetCode #11 | Container With Most Water Solved using the two-pointer approach — expanding and shrinking boundaries to find the maximum area efficiently in O(n) time. A great example of how logical movement can outperform brute force. #NeetCode #LeetCode #Java #DSA #Algorithms #TwoPointers #ProblemSolving #CodingJourney

💻 Day 34 — LeetCode 912: Sort an Array (Merge Sort Implementation) Today, I learned and implemented Merge Sort, a classic Divide and Conquer algorithm that efficiently sorts arrays with a time complexity of O(n log n). I applied it to LeetCode 912 (Sort an Array) — where the task is to sort an integer array without using built-in sorting methods. This problem helped me understand: How recursion splits the array into halves How merging combines sorted halves Why Merge Sort guarantees stable and consistent performance 🧠 Key takeaway: Merge Sort ensures O(n log n) in all cases (best, average, and worst), making it one of the most reliable sorting algorithms. #LeetCode #Day34 #DSA #SortingAlgorithms #MergeSort #CodingJourney #Java #ProblemSolving

💡 LeetCode #167 — Two Sum II (Input Array Is Sorted) Today I solved LeetCode Problem 167: Two Sum II — Input Array Is Sorted 🎯 Problem Summary: You are given a sorted array and a target. Return the 1-indexed positions of the two numbers that add up to the target. You must use O(1) extra space. Key Idea: Use the two-pointer technique 👈👉 Start with one pointer at the beginning (left) and one at the end (right). If the sum is too large → move right leftward. If the sum is too small → move left rightward. Stop when you find the pair. This works because the array is already sorted. #LeetCode #Java #DSA #TwoPointers #Algorithms #ProblemSolving #CodingChallenge

NeetCode 25 | LeetCode #239 | Sliding Window Maximum Implemented an efficient solution using a deque to track potential maximums within each window. A classic example of optimizing brute force with data structures — achieving O(n) time complexity. #NeetCode #LeetCode #Java #DSA #Deque #SlidingWindow #Algorithms #ProblemSolving #CodingJourney

🚀 115 days of #200DaysOfCode Problem: 24. Swap Nodes in Pairs Problem Statement: Given the head of a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes, only nodes themselves may be changed. Approach: Used a dummy node and iteratively swapped each adjacent node pair via pointer manipulation, which enabled in-place node swaps without extra space. Logic: Leveraged pointer rewiring to achieve the swaps efficiently with O(1) extra space and O(n) time complexity, cleanly iterating through the list to handle both even and odd-length cases. 👉 Question link 🔗: https://lnkd.in/g6cwvMgz #LeetCode #Java #LinkedList #Pointers #DSA #Coding #Algorithms #InterviewPrep #200DaysOfCode

NeetCode 29 | LeetCode #153 | Find Minimum in Rotated Sorted Array Used binary search to find the rotation pivot. Compared nums[mid] with nums[right] to shrink search space efficiently. Time complexity: O(log n) | Space: O(1) #LeetCode #NeetCode #Java #Algorithms #DataStructures #Optimization #Coding

✅Day 41 : Leetcode 153 - Find Minimum in Rotated Sorted Array #60DayOfLeetcodeChallenge 🧩 Problem Statement Given a sorted array that has been rotated at an unknown pivot, find the minimum element in the array. The array contains unique elements, and the solution must run in O(log n) time. 💡 My Approach I used a binary search technique to efficiently find the minimum element. I maintained two pointers, low and high. At each step, I calculated the mid-point. If the left part (nums[low] to nums[mid]) was sorted, I updated my answer with the smaller of nums[low] and current ans, and moved low to mid + 1. Otherwise, I updated my answer with nums[mid] and moved high to mid - 1. This approach ensures we keep narrowing the search space toward the minimum element. ⏱️ Time Complexity O(log n) — Because the search space is halved in each iteration. #BinarySearch #LeetCode #RotatedSortedArray #DSA #CodingPractice #Java #ProblemSolving

📅 Day 82 of #100DaysOfLeetCode Problem: Delete Node in a BST (LeetCode #450) Approach: The goal is to delete a node with a specific key from a Binary Search Tree (BST). The deletion process involves two main steps: Search for the node to be deleted. Delete it while maintaining the BST property. There are three cases when deleting a node: Leaf node: Simply remove it. One child: Replace the node with its child. Two children: Find the inorder successor (smallest value in the right subtree), replace the node’s value with it, and delete the successor recursively. Complexity: ⏱️ Time: O(h), where h is the height of the BST. 💾 Space: O(h), recursive call stack. 🔗 Problem Link: https://lnkd.in/dx4XEUgz 🔗 Solution Link: https://lnkd.in/d3-RJ6yJ #LeetCode #100DaysOfCode #BinarySearchTree #Recursion #Java #DSA #Algorithms #ProblemSolving #CodeNewbie #TreeTraversal #StudyWithMe #DailyCoding #BuildInPublic #LearnToCode #CodingJourney

🔹 Day 40 – LeetCode Practice Problem: Find Greatest Common Divisor of Array (LeetCode #1979) 📌 Problem Statement: Given an integer array nums, find the greatest common divisor (GCD) of the smallest and largest numbers in the array. ✅ My Approach (Java): 1. Find the minimum and maximum elements in the array. 2. Starting from the smaller number and going downwards, check for the highest integer that divides both min and max. 3. Return that integer as the GCD. 📊 Complexity: Time Complexity: O(n + min(a, b)) Space Complexity: O(1) ⚡ Submission Results: Accepted ✅ Runtime: 0 ms (Beats 100%) 🚀 Memory: 43.41 MB (Beats 41.55%) 💡 Reflection: This problem shows how basic math logic and loop optimization can lead to extremely efficient solutions. A simple and powerful way to practice number theory in coding! #LeetCode #ProblemSolving #Java #DSA #CodingPractice #Learning