"Day 111 of DSA Challenge: Subsets II with Duplicates"

DSA Practice – Day 52 🚀 Problem: Happy Number (LeetCode 202) 📌 Problem Statement: A number is called happy if repeatedly replacing it with the sum of the squares of its digits eventually leads to 1. Return true if it’s a happy number, otherwise false. 🧩 Brute Force Approach: Keep track of all numbers seen in a set to detect loops. If you reach 1, Happy Number If a number repeats, Not Happy Time Complexity: O(log n) Space Complexity: O(log n) ⚡ Optimal Approach (Floyd’s Cycle Detection): Use two pointers — slow and fast. Move slow by one step and fast by two steps (using sum of squares). If they meet, there’s a cycle (not happy). If you reach 1, it’s a happy number. Time Complexity: O(log n) Space Complexity: O(1) ✨ What I Learned: How to detect cycles in number transformations. Applying Floyd’s cycle detection beyond linked lists. Improved logical problem-solving for number-based questions. #LeetCode #Java #ProblemSolving #DSA #CodingJourney #PlacementPrep

 𝐃𝐚𝐲 𝟑 𝐨𝐟 #𝟓𝟎𝐃𝐚𝐲𝐬𝐎𝐟𝐃𝐒𝐀 Today’s problem was an interesting 𝐚𝐫𝐫𝐚𝐲 𝐦𝐚𝐧𝐢𝐩𝐮𝐥𝐚𝐭𝐢𝐨𝐧 challenge that combined 𝐟𝐫𝐞𝐪𝐮𝐞𝐧𝐜𝐲 𝐨𝐩𝐭𝐢𝐦𝐢𝐳𝐚𝐭𝐢𝐨𝐧 and 𝐬𝐥𝐢𝐝𝐢𝐧𝐠 𝐰𝐢𝐧𝐝𝐨𝐰 𝐥𝐨𝐠𝐢𝐜. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐋𝐢𝐧𝐤 : https://lnkd.in/eTuHbtHe 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐋𝐢𝐧𝐤 : https://lnkd.in/eZpb7TDH 𝐏𝐫𝐨𝐛𝐥𝐞𝐦: Given an array nums and two integers k and numOperations, we can perform up to numOperations changes — where each change lets us add any value from [-k, k] to an unused element. Our goal : Maximize the frequency of any element after all operations. We can achieve this by: Adding 0 to nums[1] → [1, 4, 5] Adding -1 to nums[2] → [1, 4, 4] Approach: Count frequencies of each unique number using a map. Sort the unique keys. Use a sliding window over the range [center - k, center + k] to find the total count of numbers that can be converted into center with the given range and operations. Track the maximum achievable frequency. 𝐂𝐨𝐧𝐜𝐞𝐩𝐭𝐬 𝐮𝐬𝐞𝐝: HashMap for frequency counting Sliding Window Technique Range-based element transformation Language: Java Small optimizations and mathematical reasoning make these types of problems fun to solve! #50DaysOfDSA #DSA #CodingChallenge #LeetCode #Java #ProblemSolving #DeveloperJourney #OpenSource #Day3 #LearningEveryday

🗓 Day 1 / 100 – #100DaysOfLeetCode 📌 Problem 637: Average of Levels in Binary Tree Given the root of a binary tree, the task was to return the average value of the nodes at each level in an array. For example, Input: [3,9,20,null,null,15,7] Output: [3.00000, 14.50000, 11.00000] 🧠 My Approach: Used Breadth-First Search (BFS) traversal to process the tree level by level: Initialized a queue and pushed the root node. For each level, iterated through all nodes, accumulating their values. Calculated the average of that level and added it to the result list. Continued until all levels were processed. This approach effectively uses a queue to handle each level’s nodes in order. ⏱ Time Complexity: O(n) – every node is visited once 💾 Space Complexity: O(w) – where w is the maximum width of the tree 💡 Key Learning: This problem strengthened my understanding of level-order traversal using BFS. It showed how queues can efficiently help process hierarchical structures like trees — not just for traversal, but also for aggregating information level-wise 🌳 #100DaysOfLeetCode #LeetCodeChallenge #Java #ProblemSolving #BinaryTree #BFS #DataStructures #Algorithms #DSA #CodingJourney #CodeEveryday #SoftwareEngineering #LearningInPublic #DeveloperJourney #TechStudent #CodingCommunity #LogicBuilding #CareerGrowth #KeepLearning #Programmer #TechCareer

DSA Practice – Day 54 🚀 Problem: Maximum Product Subarray Problem Statement: Find the contiguous subarray within an array (containing at least one number) which has the largest product. ⚡ Brute Force Approach: Generate all possible subarrays. Calculate the product of each subarray. Keep track of the maximum product found. Time Complexity: O(n²) Space Complexity: O(1) ⚡ Optimal Approach (Prefix–Suffix Product): Maintain two running products — prefix (left to right) and suffix (right to left). Reset the product to 1 whenever it becomes 0. Keep updating the maximum product found so far. Time Complexity: O(n) Space Complexity: O(1) ✨ What I Learned: Prefix–suffix logic can simplify problems that seem complex initially. Resetting counters or products helps handle zeros effectively. Great way to practice array traversal from both ends! #LeetCode #Java #DSA #ProblemSolving #CodingJourney #PlacementPrep

💡 Day 97 of My DSA Challenge – Single Element in a Sorted Array 🔷 Problem : 540. Single Element in a Sorted Array 🔷 Goal : Find the single element that appears only once in a sorted array where all other elements appear exactly twice, in O(log n) time and O(1) space. 🔷 Key Insight : The array is sorted, and elements appear in pairs — except for one. We can use Binary Search on Indices : Check the mid element and compare it with neighbors. If mid is unique → return it. Otherwise, depending on whether the pair is on the left or right and the parity of the remaining elements, move left or right. This works because the single element shifts the pairing pattern in the array, allowing us to discard half the search space each time. 🔷 My Java Approach : 1️⃣ Binary search over array indices. 2️⃣ Compare mid with neighbors to detect the single element. 3️⃣ Adjust search space using parity logic. 🔷 Complexity : Time → O(log n) Space → O(1) Binary search isn’t just for sorted numbers — it can also be applied to patterns and structural properties in arrays. Recognizing such patterns allows efficient solutions even when the array has special constraints. 🚀 #100DaysOfCode #Day97 #LeetCode #DSA #Java #ProblemSolving #BinarySearch #CodingChallenge #Programming #LearnToCode #CodingLife #SoftwareEngineering #Algorithms #DataStructures #TechJourney #CodeEveryday #EngineerMindset #DeveloperJourney #GrowthMindset #CodeNewbie #KeepLearning #ApnaCollege #AlphaBatch #ShraddhaKhapra

💻 #Day486 (DSA) – LeetCode 3370: Smallest Number With All Set Bits 🔥 🚀 Problem Summary: Given a positive integer n, find the smallest number x ≥ n such that the binary representation of x contains only set bits (1s). 🧩 Examples: Input: n = 5 Output: 7 → Binary: 111 Input: n = 10 Output: 15 → Binary: 1111 Input: n = 3 Output: 3 → Binary: 11 💡 Intuition: To find the smallest number having all bits set, we can compute numbers like: 1 → (1), 3 → (11), 7 → (111), 15 → (1111), 31 → (11111)... and pick the smallest one ≥ n. 🧠 Approach: Keep generating (1 << k) - 1 until the result is ≥ n. That number will be our answer ✅ 🧩 Code (Java): class Solution { public int smallestNumber(int n) { int x = 1; while (x < n) { x = (x << 1) | 1; // shift and set next bit } return x; } } 🕒 Time Complexity: O(log n) 💾 Space Complexity: O(1) ✨ Key Learning: Mastery in bit manipulation 🧠 Smart usage of left shift and bitwise OR Understanding how binary patterns grow 🏷️ Tags: #LeetCode #DSA #BitManipulation #CodingChallenge #ProblemSolving #Java #DeveloperJourney #Algorithms #KeepLearning #CodeEveryday #TechCommunity 💬 Question for you: If you had to generalize this for the next “all-set bit number” above any given n, how would you optimize it? 🤔

⚙️ Day 38 of My LeetCode Journey — Problem #2654 “Minimum Number of Operations to Make All Array Elements Equal to 1” (Java Solution) 💡 Today’s challenge beautifully combined number theory with algorithmic optimization. The goal: turn every element in an array into 1 using the minimum operations — and the key insight was rooted in GCD properties. 🔍 My thought process: If any 1s exist → we just need to handle the rest (n - count(1)). Otherwise → find the shortest subarray with GCD = 1, since it’s the only way to generate a 1. The final answer = minimal window length + (n - 1) operations. It’s fascinating how understanding mathematical relationships can drastically simplify code complexity 🔢 Each problem reminds me — elegant logic is what turns code into art 🧠💻 #Day38 #LeetCode #Java #ProblemSolving #NumberTheory #Algorithms #DSA #CodingJourney #100DaysOfCode #CodeEveryday #SoftwareEngineering #LearningInPublic #TechCommunity

DSA Practice – Day 48 🚀 Problem: Sort Array by Parity(LeetCode 905) Problem Statement: Given an integer array nums, move all even integers to the beginning of the array followed by all the odd integers. Return any array that satisfies this condition. ⚡ Brute Force Approach: Create a new array. First, add all even numbers from nums to it. Then, add all odd numbers. Return the new array. Time Complexity: O(n) Space Complexity: O(n) (because of the extra array) ⚡ Optimal Approach (Two Pointer Technique): Use two pointers — one at the start (left) and one at the end (right). If the left element is odd and the right is even, swap them. Move pointers accordingly until they meet. This sorts even and odd numbers in-place without extra space. Time Complexity: O(n) Space Complexity: O(1) ✨ What I Learned: How to use the two-pointer approach for in-place array rearrangement. Simple logic can drastically reduce space usage in problems like these. #DSA #LeetCode #Java #Arrays #TwoPointer #ProblemSolving #Coding #InterviewPrep

DSA Practice – Day 58 🚀 Problem: Linked List Cycle (LeetCode 141) Problem Statement: Given the head of a linked list, determine if the linked list has a cycle in it. A cycle exists if a node’s next pointer points to a previous node in the list. ⚡ Brute Force Approach: Use a HashSet to store visited nodes. While traversing the list: If a node is already in the set → cycle detected. Otherwise, add it to the set. If traversal ends (null reached) → no cycle. Time Complexity: O(n) Space Complexity: O(n) ⚡ Optimal Approach (Floyd’s Cycle Detection): Use two pointers — slow and fast. Move slow by one step and fast by two steps. If they meet → cycle exists. If fast or fast.next becomes null → no cycle. Time Complexity: O(n) Space Complexity: O(1) ✨ What I Learned: The Floyd’s Cycle Detection Algorithm is a clever way to find loops efficiently. Two-pointer techniques are extremely useful in linked list problems. #DSA #Java #LinkedList #FloydCycleDetection #ProblemSolving #LeetCode #CodingJourney #PlacementPrep

🚀 116 days of #200DaysOfCode Problem: 113. Path Sum II Problem Statement: Given the root of a binary tree and an integer targetSum, return all root-to-leaf paths where the sum of the node values in the path equals targetSum. Each path should be returned as a list of the node values. Approach: Used Depth-First Search (DFS) to explore all root-to-leaf paths while tracking the current path and sum. Added valid paths to the result when a leaf was reached and the sum matched the target. Logic: DFS with backtracking efficiently explores all possible paths and ensures only valid ones are stored. This approach is intuitive for tree problems and leverages recursion for clean path management. 👉 Question link 🔗: https://lnkd.in/gEp7MAYW #LeetCode #Java #Tree #DFS #Backtracking #DSA #Coding #Algorithms #InterviewPrep #200DaysOfCode