LeetCode 78 - Subsets using Bit Manipulation

🔥 Day 508 of #750DaysOfCode 📌 Problem: Binary Number with Alternating Bits (LeetCode 693) Today’s challenge was to determine whether a given positive integer has alternating bits in its binary representation. 👉 A number has alternating bits if no two adjacent bits are the same. 🧠 Example: 5 → 101 ✅ (Alternating → True) 7 → 111 ❌ (Not alternating → False) 11 → 1011 ❌ (Last two bits same → False) 💡 Key Insight If a number has alternating bits: XOR it with itself right-shifted by 1 The result should be all 1s A number with all 1s has the property: 🔎 Why This Works? Example: n = 5 → 101 n = 101 n >> 1 = 010 XOR = 111 Now check: 111 & 1000 = 0 Hence ✅ True. ⏱ Time Complexity: O(1) 📦 Space Complexity: O(1) Day 508 completed. Still building consistency. Still sharpening problem-solving. 💪 On to Day 509 🚀 #750DaysOfCode #Day508 #LeetCode #Java #DSA #BitManipulation #ProblemSolving #CodingJourney #Consistency #TechGrowth

📅 Day 90 of #100DaysOfLeetCode Problem: 3634. Minimum Removals to Balance Array Difficulty: Medium Key Insight: Instead of deciding which elements to remove, focus on keeping the largest possible balanced subarray where max ≤ min × k. Minimum removals = total elements − size of this subarray. Approach: Sort the array to make min/max tracking easy Use a sliding window Expand the right pointer Shrink the left pointer whenever nums[j] > k × nums[i] Track the maximum valid window length Complexity: Time: O(n log n) Space: O(1) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

Day 57/100 – LeetCode Challenge ✅ Problem: Longest Balanced Substring I Difficulty: Medium Language: Java Approach: Brute Force with Frequency Array Time Complexity: O(n² × 26) ≈ O(n²) Space Complexity: O(26) → O(1) Key Insight: A balanced substring requires all occurring characters to have the same frequency. For each starting index, expand substring while tracking character counts. Check if all non-zero frequencies are equal. Solution Brief: Nested loops to generate all substrings. Used fixed-size frequency array (26) for lowercase letters. Helper function issamefreq() verifies all non-zero counts are identical. Tracked maximum valid substring length. #LeetCode #Day57 #100DaysOfCode #String #Java #Algorithm #CodingChallenge #ProblemSolving #LongestBalancedSubstring #MediumProblem #BruteForce #FrequencyArray #Substring #DSA

🚀 Day 76 of #100DaysOfCode Today I worked on a clean and elegant array manipulation problem — LeetCode: Rotate Array ✅ 📌 Problem Summary Given an array, rotate it to the right by k steps in-place, without using extra space. 🧠 Approach Used: Reverse Technique Instead of shifting elements one by one, I used a smart 3-step reverse strategy: Reverse the entire array Reverse the first k elements Reverse the remaining n − k elements This achieves the rotation efficiently and keeps the solution simple. ⚙️ Complexity ⏱ Time: O(n) 💾 Space: O(1) (in-place) 🔥 Key Learnings Sometimes the best solution is about reordering operations, not adding complexity In-place algorithms are powerful when space constraints matter Reverse logic is a recurring and underrated pattern in array problems Onward to Day 77 🚀 Consistency > Motivation 💪 #100DaysOfCode #LeetCode #Java #DSA #Arrays #ProblemSolving #CodingJourney

🚀 Day 89 of #100DaysofLeetCode Problem: Minimum Size Subarray Sum Difficulty: Medium Today’s challenge was about finding the smallest length subarray whose sum is greater than or equal to a given target. Since all elements are positive, this problem is a perfect fit for the Sliding Window technique. Instead of checking all possible subarrays (which would be inefficient), I used two pointers: Expand the window by moving the right pointer and adding to the current sum. Once the sum becomes ≥ target, shrink the window from the left to find the minimum possible length. Keep updating the minimum length during this process. Key takeaways: Positive integers allow efficient window shrinking. Two pointers help reduce time complexity from O(n²) to O(n). Maintain a running sum and dynamically adjust window size. Return 0 if no valid subarray exists. Time Complexity: O(n) Space Complexity: O(1) Another solid sliding window problem completed 💪 #100DaysOfCode #100DaysOfLeetCode #LeetCode #DSA #SlidingWindow #TwoPointers #Java #ProblemSolving #CodingJourney #Algorithms

Day 5/100 – LeetCode Challenge Problem: Word Search Today’s challenge was a classic 2D Matrix + DFS + Backtracking problem. Problem Summary: Given a 2D board of characters and a word, determine if the word exists in the grid. Rules: Adjacent cells = horizontal or vertical A cell cannot be reused in the same path Approach Used: Traverse every cell as a starting point Apply Depth First Search (DFS) Mark visited cells temporarily Backtrack after exploring all 4 directions Core idea: Base case → If index == word.length() → return true Boundary check + character match validation Mark visited → Explore → Restore (Backtracking) Key Concepts Practiced: Recursion Backtracking 2D matrix traversal State modification & restoration Time Complexity: O(m × n × 4^L) (L = length of word) This problem reinforced an important lesson: Backtracking is about exploring possibilities and undoing choices efficiently. #100DaysOfCode #LeetCode #DSA #Java #Backtracking #SoftwareEngineerJourney #CodingInterview

#100DaysOfCode 🚀  👉Solved: LeetCode #16 – 3Sum Closest  After solving the classic 3Sum problem earlier, this variation pushed me to think slightly differently. Instead of finding an exact triplet sum equal to 0,   this time the goal was to find the sum *closest* to a given target. 🔹 Approach: • Sorted the array   • Fixed one element at a time   • Applied the Two Pointer technique   • Continuously tracked the minimum absolute difference  Key Insight: Sometimes optimization problems are not about exact matches,   but about minimizing deviation. Time Complexity: O(n²)   Space Complexity: O(1)  This problem strengthened my understanding of: ✔ Two Pointers   ✔ Greedy comparison logic   ✔ Edge case handling  What I learned: Small variations in problem statements can completely change the thinking approach. Classic 3Sum focuses on exact zero. 3Sum Closest focuses on minimizing |sum - target|. #LearnInPublic #DSA #Java #LeetCode #TwoPointers #ProblemSolving #CodingJourney #SoftwareEngineering

Day 14/30 – LeetCode streak Today’s problem: Concatenation of Consecutive Binary Numbers  You need the decimal value of '1' + '2' + '3' + ... + 'n' written in binary back-to-back, all under mod (10^9 + 7). Core trick: treat “concatenate in binary” as shift + OR: * When you append 'i' to the right, you’re really shifting the current result left by 'bits(i)' and OR-ing 'i' into the free space. * The number of bits only increases when 'i' hits a power of two (1, 2, 4, 8, …), so you just track 'bits' and bump it whenever '(i & (i - 1)) == 0'. Day 14 takeaway: Once you see that “stick this binary to the right” is the same as “shift by its bit length and OR”, the whole problem becomes a clean for-loop plus the power-of-two trick—no string building or big integer juggling needed. #leetcode #dsa #java #bitmanipulation #consistency

Day 16 – LeetCode 1004 | Sliding Window Done Right (O(n) Solution) Day 16 of solving problems consistently. Solved LeetCode 1004 – Max Consecutive Ones III. Problem: Given a binary array, you can flip at most k zeros. Return the maximum number of consecutive 1s possible. Brute force checks every subarray → O(n²) → wasteful. A better approach is Sliding Window + Two Pointers → O(n). Core logic: • Expand window with right pointer • Count zeros • If zeros exceed k → move left pointer • Track max window length This problem is a good reminder that: Constraints usually hint the optimal technique. If you see “subarray + max/min + linear time” → think Sliding Window first. Consistency builds skill. 16 days. No breaks. Code + explanation in the video 👇 #LeetCode #DSA #Algorithms #SlidingWindow #TwoPointers #Java #ProblemSolving #CodingInterview #SoftwareDeveloper #100DaysOfCode #TechJourney

🚀 Day 88 of 100 Days of LeetCode Problem: Min Cost Climbing Stairs Difficulty: Easy Today’s problem was another classic Dynamic Programming pattern. Each step has a cost, and you can climb either 1 or 2 steps at a time. The goal is to reach the top with the minimum total cost. You can start from index 0 or index 1. The key idea: To reach step i, you must come from either i-1 or i-2. So the recurrence becomes: dp[i] = cost[i] + min(dp[i-1], dp[i-2]) Finally, since you can reach the top from the last or second-last step: answer = min(dp[n-1], dp[n-2]) This problem reinforces the “take minimum of previous two states” DP pattern — very similar to Climbing Stairs but focused on cost minimization instead of counting ways. Time Complexity: O(n) Space Complexity: O(n) → can be optimized to O(1) Another solid DP variation completed. On to Day 89 💪 #LeetCode #100DaysOfCode #DSA #DynamicProgramming #Java #Algorithms #ProblemSolving #CodingJourney