Construct Minimum Bitwise Array with Java

Day 7 of Daily DSA 🚀 Solved LeetCode 167: Two Sum II – Input Array Is Sorted Approach: Used the two-pointer technique leveraging the sorted nature of the array. Moved pointers inward based on the comparison with the target to find the answer in one pass. Complexity: • Time: O(n) • Space: O(1) (constant extra space) LeetCode Stats: • Runtime: 2 ms (Beats 96.10%) • Memory: 48.54 MB (Beats 38.87%) This problem highlights how understanding input constraints can turn a brute-force solution into an optimal one. #DSA #LeetCode #Java #TwoPointers #ProblemSolving #Consistency

Day 3 of Daily DSA 🚀 Solved LeetCode 1: Two Sum Approach: Used a HashMap to store numbers with their indices. For each element, checked if the complement (target - current) already exists. Complexity: • Time: O(n) • Space: O(n) Performance: Runtime: 2 ms (Beats 99.15%) Memory: 47.34 MB Focusing on writing clean and efficient solutions before over-optimizing. Consistency > Intensity 💯 #DSA #LeetCode #Java #ProblemSolving #Consistency

🚀 Day 100 of #100DaysOfLeetCode Problem: 127. Word Ladder Difficulty: Hard Key Insight: This is a shortest-path problem where each valid word transformation is an unweighted edge — BFS guarantees the minimum sequence length. Approach: Used BFS starting from beginWord. At each step, generated all possible words by changing one character (a–z). Used a HashSet for O(1) lookup and removed visited words to avoid revisits. Complexity: Time: O(N × L × 26) Space: O(N) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

🔥 Day 82 of #100DaysOfLeetCode ✅ Problem: Number of Longest Increasing Subsequence ✅ Difficulty: Medium 💡 Key Insight: Instead of tracking only the LIS length, we also maintain the number of ways each LIS can be formed. For every element, we check all previous smaller elements and update both length and count dynamically. 🛠 Approach: Use two arrays: dp[i] → Length of LIS ending at index i cnt[i] → Number of LIS ending at index i If a longer subsequence is found → update length and copy count. If another subsequence of the same length is found → add the counts. Finally, sum counts for indices having the maximum LIS length. ⏱ Complexity: Time: O(n²) Space: O(n) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

📅 Day 74 of #100DaysOfLeetCode 🧩 Problem: 3315. Construct the Minimum Bitwise Array II 📊 Difficulty: Medium 🧠 Key Insight For each prime number nums[i], we need to find the minimum integer x such that: x | (x + 1) == nums[i] x | (x + 1) is always odd Therefore, if nums[i] is even, no valid x exists → answer is -1 For odd nums[i], the minimum x can be formed by flipping the lowest 0-bit in nums[i] and setting all lower bits to 1 ⚙️ Approach Initialize the answer array For each number nums[i]: If nums[i] is even → assign -1 Otherwise: Find the lowest bit position where nums[i] has 0 Clear that bit Set all lower bits to 1 Store the resulting value as the minimum valid x ⏱ Complexity Time: O(n) Space: O(1) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

🚀 Day 1 / 100 | Search a 2D Array. ->Today’s problem helped me understand how a 2D matrix can be treated like a 1D sorted array to apply Binary Search efficiently.  •Problem Solved: 74. Search a 2D Matrix. 📚Topics: Binary Search, 2D array indexing. 🔑 Key Insight: By mapping a single index to (row, col) using division and modulo, we can apply Binary Search efficiently without extra space. #100DaysOfCode #LeetCode #DSA #BinarySearch #Java #ProblemSolving

🌳 Day 59/100: Preorder Traversal - Root, Left, Right Day 59. Learning tree traversals. Preorder: Visit root first, then explore. 🎯 📌 Problem: Return preorder traversal of binary tree. 🎯 Recursion: Base case: If node is null, return. Recursive case: Add value, go left, go right. Simple and clean. 📊 Complexity: O(n) time, O(h) space (recursion stack) 🌱 Tree Traversals: Preorder: Root → Left → Right Inorder: Left → Root → Right Postorder: Left → Right → Root Day 59. Traversal patterns building. 🌳 #100DaysOfCode #DSA #LeetCode #Day59 #Java #PreorderTraversal #BinaryTree #TreeTraversal

Day 60/100 – LeetCode Challenge ✅ Problem: #67 Add Binary Difficulty: Easy Language: Java Approach: Reverse Iteration with Carry Time Complexity: O(max(n, m)) Space Complexity: O(max(n, m)) Key Insight: Binary addition follows same rules as decimal: Sum bits + carry Result bit = sum % 2 New carry = sum / 2 Solution Brief: Iterated from rightmost bits of both strings. Tracked carry and built result from right to left using StringBuilder. Reversed final string for correct order. #LeetCode #Day60 #100DaysOfCode #Binary #Java #Algorithm #CodingChallenge #ProblemSolving #AddBinary #EasyProblem #StringManipulation #BitManipulation #DSA

📌 Day 93 of #100DaysOfLeetCode Problem: 1382. Balance a Binary Search Tree Difficulty: Medium Key Insight: An inorder traversal of a BST produces a sorted sequence. A height-balanced BST can be built by recursively choosing the middle element of this sorted list as the root. Approach: Perform inorder traversal to store node values in a list Recursively construct a balanced BST using the middle element as root Left subtree from left half, right subtree from right half Time Complexity: O(n) Space Complexity: O(n) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

🚀 Day 4 of #100DaysOfCode Solved Single Element in a Sorted Array on LeetCode using Binary Search ⚡ 🧠 Key insight: In a sorted array where every element appears twice except one, index parity (even/odd) helps decide which half to search. ⚙️ Approach: 🔹Apply binary search 🔹Compare mid with its adjacent element 🔹Use index parity to move left or right 🔹Narrow down until the single element is found ⏱️ Time Complexity: O(log n) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #BinarySearch #Java #ProblemSolving #LearningInPublic #CodingJourney