Angadveer Singh’s Post

🔥 Day 19 of #21DaysOfDSA 🔥 🎯 𝗚𝗼𝗮𝗹 (Problem I solved today): 4Sum – LeetCode 🧩 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗯𝗿𝗶𝗲𝗳: Given an array of integers and a target, find all unique quadruplets [a, b, c, d] such that a + b + c + d = target. The solution set must not contain duplicate quadruplets. 💡 𝗠𝘆 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵: • Started by sorting the array to simplify duplicate handling. • Used two nested loops for the first two numbers, then applied a two-pointer approach for the remaining two numbers. • Carefully skipped duplicates at every step to ensure uniqueness. • Achieved an efficient O(n³) solution — while not linear, it’s optimal for this problem size. 📌 𝗞𝗲𝘆 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 & 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀: • Sorting upfront makes duplicate avoidance much easier. • Multi-sum problems (2-sum, 3-sum, 4-sum) follow similar patterns — mastering one helps with others. • Patience and careful pointer management are key to avoid mistakes in complex iterations. Day 19 ✅ — complex problems are much more manageable when broken into smaller, familiar patterns. 🚀 #21DaysOfDSA #Java #ProblemSolving #CodingChallenge #LeetCode

🧠 Day 72 of #HackerRank Challenge Problem: Maximum Number of Non-Overlapping Intervals Description: Given an array of intervals where each interval has a start and an end time, the goal is to determine the maximum number of non-overlapping intervals that can be scheduled. Approach: ✅ Sort all intervals based on their end times. ✅ Use a greedy algorithm — always pick the next interval whose start time is not earlier than the end time of the last selected interval. ✅ This ensures maximum usage of available time slots without overlaps. Concepts Used: ✔ Greedy Algorithm ✔ Sorting ✔ Interval Scheduling Optimization Time Complexity: Sorting the intervals → O(n log n) Selecting non-overlapping intervals → O(n) ➡️ Overall Time Complexity: O(n log n) Space Complexity: O(1) (excluding input storage, as sorting can be done in place) Platform: HackerRank Language: Java Tags: #Day72 #HackerRank #CodingChallenge #Java #GreedyAlgorithm #ProblemSolving #Amazon #Microsoft #Google #Infosys

🌟 Day 62 of LeetCode Challenge 🌟 📘 Problem: Next Greater Element II 💻 Language: Java 🏁 Platform: LeetCode 🧩 Concept: The problem focuses on finding the Next Greater Element (NGE) for each element in a circular array. For every element, we need to locate the first greater value by traversing the array cyclically. 🧠 Key Learning: Efficient traversal in circular arrays using modulo indexing (i + step) % n. Understanding of nested iteration logic to find the NGE. Learned how to initialize and update arrays for condition-based values. ⚙️ Approach: Iterate through each element of the array. For each element, look ahead (circularly) to find the next greater element. If found, assign it; otherwise, mark as -1. 🏆 Result: ✅ Accepted (223/223 test cases passed) ⏱ Runtime: 89 ms 💾 Memory: 46.47 MB 🏢 Companies: Google | Amazon | Microsoft | Infosys #LeetCode #Day62 #NextGreaterElement #Java #CodingChallenge #ProblemSolving #LearningJourney #Google #Amazon #Microsoft #Infosys

📅 Day 80 of 100 – #100DaysOfDSA 🧠 Problem Statement Find all valid combinations of k numbers that sum up to n, such that: Only numbers 1 through 9 are used. Each number is used at most once. 💡 Intuition This is another variation of the Combination Sum problem, perfectly suited for Backtracking. Since the numbers are limited (1-9) and must be used at most once, the process is very similar to generating subsets. Our approach (Backtracking with Constraints): 1. The recursive helper function backtrack takes k (remaining numbers needed), target (remaining sum needed), start (the next number to consider), the current combination (path), and the result list (res). 2. Base Case: If the target becomes 0 AND the combination size is exactly k, we've found a valid solution. We add a copy of path to res and return. We also return if target < 0 to prune invalid paths. 3. Recursive Step (The Loop): We iterate through possible numbers from i = start to 9.   i. Pruning: If the current number i is greater than the remaining target, we break the loop, as all subsequent numbers will also be too large.   ii. Inclusion:     a. Add the current number i to the path. b. Recurse with the reduced constraints: backtrack(k, target - i, i + 1, path, res).   iii. Backtrack: Remove the element i from path. 4. The main function initializes the result and calls backtrack starting at start = 1. ✅Time Complexity: O(2^9*k) ✅Space Complexity: O(k) 🌟 The Journey Continues Day 80! We completed the entire section on Backtracking with the Combination Sum III problem. This was a great consolidation of all the patterns: using a start index to prevent duplicates (since the numbers 1-9 are unique), and combining multiple constraints (sum n AND size k) in the base case. Just 20 days left! 🥳 If you're on a similar coding journey, let's connect and share our progress! 🚀 . . . #100DaysOfCode #Day80 #100DaysOfDSA #StriversA2ZDSA #Java #CodingJourney #DSA #ProblemSolving #DailyCode #CodeNewbie #LearningByDoing #CodingCommunity #Backtracking #CombinationSum #Recursion

📅 Day 78 of 100 – #100DaysOfDSA 🧠 Problem Statement Given a set of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates where the candidate numbers sum to target. The same repeated number may be chosen from candidates an unlimited number of times. 💡 Intuition This is another classic problem solved using Backtracking. The core idea is to explore all possible combinations by recursively trying to include a number and reduce the target. Our approach: The main logic is in the recursive helper function subSeqSum. It takes the candidates array, the remaining target, the current combination (temp), the current starting index (idx), and the result list (res). 1. Base Cases: i. If target == 0, we have found a valid combination, so we add a copy of temp to res and return. ii. If idx == candidates.length (we've run out of numbers) OR target < 0 (we've exceeded the target), we stop and return. 2. Recursive Choices at idx: Choice 1: Include the current element (candidates[idx]). i. Add candidates[idx] to temp. ii. Recurse with the same index (idx) but with the reduced target: target - candidates[idx]. This allows for repeated use of the same number. iii. Backtrack: Remove the element from temp. Choice 2: Exclude the current element (candidates[idx]). i. Recurse with the next index (idx + 1) and the same target. This ensures we move on to consider the next candidate number. ✅Time Complexity: O(2^t) where t = target / smallest candidate ✅Space Complexity: O(target) 🌟 The Journey Continues Day 78! We successfully solved the Combination Sum problem, which is a key variation of the backtracking pattern. If you're on a similar coding journey, let's connect and share our progress! 🚀 . . . #100DaysOfCode #Day78 #100DaysOfDSA #StriversA2ZDSA #Java #CodingJourney #DSA #ProblemSolving #DailyCode #CodeNewbie #LearningByDoing #CodingCommunity #Backtracking #CombinationSum #Recursion

Day 20/100 – #100DaysOfCode 🚀 | #Java #DSA #LeetCode #BinarySearch ✅ Problem Solved: Median of Two Sorted Arrays 🔎 Task: Given two sorted arrays nums1 and nums2 of size m and n, return the median of the two sorted arrays. The overall runtime complexity must be O(log (m + n)). 💡 Approach Used: Applied Binary Search on the smaller array. Partitioned both arrays so that all elements on the left side are smaller than those on the right. Calculated median based on partition boundaries. 🧠 Key Concepts: Binary Search, Divide & Conquer, Edge Case Handling ⚙️ Time Complexity: O(log(min(m, n))) 📦 Space Complexity: O(1) ✨ Today’s takeaway: Binary search isn’t just for searching — it’s a powerful tool for optimization problems too! ⚡ #Java #LeetCode #DSA #BinarySearch #ProblemSolving #ProgrammingJourney #100DaysOfCode

🚀 Day 30/100 - Problem of the day:- Delete Nodes From Linked List Present in Array. 🎯 Goal: To remove specific nodes from a singly linked list based on a given array of values efficiently. 💡 Core Idea: Used a HashSet to store deletion values for O(1) lookup and a dummy node to simplify edge-case handling (like deleting the head). Iterated through the linked list once, adjusting pointers to skip nodes that should be removed. 📘 Key Takeaway: Efficient pointer manipulation is crucial in linked list problems. Using a dummy node simplifies deletion logic and edge cases. HashSet greatly optimizes lookup for deletion values. 🧠 Space Complexity: O(n) — for storing values in the HashSet. ⚙️ Time Complexity: O(m + n) — m for inserting into HashSet, n for traversing the linked list. #100DaysChallenge #Java #DSA #Day30 #ProblemSolving #CodingJourney #LeetCode

📅 Day 95 of 100 – #100DaysOfDSA 🧠 Problem Statement Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid. A string is valid if: 1.  Open brackets must be closed by the same type of brackets. 2.  Open brackets must be closed in the correct order. 3.  Every close bracket has a corresponding open bracket of the same type. 💡 Intuition This problem involves maintaining the order and balance of nested structures, which is the classic use case for a Stack data structure. Our approach: 1.  Initialize an empty Stack to store opening brackets. 2.  Iterate through the string character by character:     Opening Bracket: If ch is an opening bracket ('(', '{', '['), push it onto the stack.     Closing Bracket: If ch is a closing bracket (')', '}', ']'):         Empty Check: First, check if the stack is empty. If it is, this means there is a closing bracket without a corresponding opener, so the string is invalid, and we return false.         Pop and Match: Pop the top element from the stack.         Mismatch Check: Compare them. If they are not a matching pair, the order is incorrect, and we return false. 3.  Final Check: After iterating through the entire string, if the stack is empty, it means every opening bracket was correctly closed. If the stack is not empty, it means there are unclosed opening brackets left over. ✅Time Complexity: O(N) ✅Space Complexity: O(N) 🌟 The Journey Continues Day 95! We tackled the fundamental problem of Valid Parentheses. This is an important and common use case for the Stack data structure, demonstrating its power in managing balanced and nested sequences. If you're on a similar coding journey, let's connect and share our progress! 🚀 . . . #100DaysOfCode #Day95 #100DaysOfDSA #StriversA2ZDSA #Java #CodingJourney #DSA #ProblemSolving #DailyCode #CodeNewbie #LearningByDoing #CodingCommunity #Stack #Parentheses #DataStructures

Day 47 of learning and documenting Today's problem on the A2Z sheet was a big one: "3Sum." This is one of those problems that really tests your understanding of core patterns. The key to an efficient solution is to sort the array first. This allows you to use a two-pointer approach to find the other two numbers that sum to the target. It beautifully transforms an O(n³) problem into an O(n²) one. The real challenge was making sure to skip over duplicate values to get a unique set of triplets. #Day47 #100DaysOfCode #LeetCode #geeksforgeeks #StriversA2ZSheet #DSA #Java Akshay Saini 🚀

Day 25/100 – #100DaysOfCode 🚀 | #Java #LeetCode #DSA #BinarySearch ✅ Problem Solved: Find Minimum in Rotated Sorted Array II 🔎 Task: Given a rotated sorted array (which may contain duplicates), find the minimum element. 💡 Approach Used: Used Modified Binary Search to handle duplicates. Carefully adjusted search boundaries when nums[mid] == nums[right] to avoid missing the minimum. Ensured O(log n) in most cases, degrading gracefully to O(n) for worst-case duplicates. 🧠 Key Concepts: Binary Search, Array Rotation, Edge Case Handling ⚙️ Time Complexity: O(log n) average 📦 Space Complexity: O(1) ✨ Today’s takeaway: Binary search isn’t just about finding — it’s about knowing when to shrink the search space smartly ⚔️ #Java #LeetCode #DSA #ProblemSolving #CodingChallenge #100DaysOfCode #BinarySearch