LeetCode Challenge Solved: Find Unique Binary String

💻 LeetCode Daily Challenge – Find Unique Binary String (Problem 1980) Today's LeetCode Daily Challenge was "Find Unique Binary String". 📌 Problem Summary We are given n unique binary strings of length n. The task is to construct a binary string of length n that does not exist in the given list. 🔎 Approach 1: HashSet + Generate All Possibilities Idea: Store all given strings in a HashSet. Generate binary numbers from 0 to 2^n - 1. Convert each number to a binary string of length n. Return the first string not present in the set. Time Complexity: O(2^n) Space Complexity: O(n) 🔎 Approach 2: Backtracking Idea: Recursively generate all binary strings of length n. Check if the generated string exists in the set. Return the first missing string. Time Complexity: O(2^n) Space Complexity: O(N) 🚀 Approach 3 (Optimal – Cantor’s Diagonalization) This elegant approach guarantees a unique string. Idea: Look at the i-th character of the i-th string. Flip the bit (0 → 1 or 1 → 0). Build a new string using these flipped bits. This ensures the constructed string differs from every string at least at one position. Time Complexity: O(n) Space Complexity: O(n) 💡 Java Implementation (Optimal Approach) class Solution { public String findDifferentBinaryString(String[] nums) { StringBuilder res = new StringBuilder(); for(int i = 0; i < nums.length; i++){ char ch = nums[i].charAt(i); if(ch == '0') res.append('1'); else res.append('0'); } return res.toString(); } } 📚 Key Takeaway This problem demonstrates a clever application of Cantor’s Diagonalization, allowing us to construct a guaranteed unique binary string in linear time. #LeetCodeDaily #DSA #Java #ProblemSolving #CodingPractice #SoftwareEngineering

LeetCode Problem || Find Unique Binary String (1980)🚀 Today I solved the problem "Find Unique Binary String" using Java. 🔹 Problem: We are given an array of n binary strings, each of length n. The goal is to return a binary string of length n that does not exist in the array. 🔹 Approach (Diagonal Flip Technique): The idea is simple but powerful: Traverse the array using index i. Look at the i-th character of the i-th string (nums[i][i]). Flip the bit (0 → 1, 1 → 0). Append it to a result string. 💡 Time Complexity: O(n) Practicing problems like this strengthens logical thinking and problem-solving skills. #LeetCode #Java #CodingPractice #ProblemSolving #DSA

Day 94/100: #LeetCodeChallenge – Grid Partitioning in Java 🧩💻 Another day, another algorithmic deep dive! Today’s problem was about determining whether a grid can be partitioned in a specific way. While the problem may seem straightforward at first, the real challenge lies in handling edge cases, optimizing for efficiency, and ensuring clean, maintainable code. 🔍 Key takeaways from today’s solution: Understanding 2D array traversal and prefix sums Handling edge cases like 1x1 grids early Writing readable code that can scale with larger test cases Even though the sample output shows "You must run your code first," the process of thinking through the logic, testing edge cases, and refining the approach is where the real growth happens. Every problem adds another tool to the problem-solving toolkit. 🚀 Consistency > Intensity. Day 94 is in the books. On to the final sprint! #100DaysOfCode #LeetCode #Java #CodingChallenge #ProblemSolving#GridPartitioning #DataStructuresAndAlgorithms #TechJourney#SoftwareEngineering #CodeNewbie #DeveloperLife #AlgorithmDesign#ConsistencyIsKey

🚀 LeetCode Problem Solved: Max Consecutive Ones III (Sliding Window Technique) Day 16 of #75DaysofLeetCode Today I solved LeetCode 1004 – Max Consecutive Ones III, a great problem to practice the Sliding Window / Two Pointer technique. 🔹 Problem: Given a binary array and an integer k, we can flip at most k zeros to ones. The goal is to find the maximum number of consecutive 1’s in the array after performing at most k flips. 💡 Key Idea: Instead of checking every possible subarray, we maintain a sliding window and allow at most k zeros inside the window. If the number of zeros exceeds k, we shrink the window from the left until the condition becomes valid again. ⚡ Time Complexity: O(n) ⚡ Space Complexity: O(1) 💻 Java Implementation: class Solution { public int longestOnes(int[] nums, int k) { int left = 0; int zeroCount = 0; int maxLen = 0; for (int right = 0; right < nums.length; right++) { if (nums[right] == 0) { zeroCount++; } while (zeroCount > k) { if (nums[left] == 0) { zeroCount--; } left++; } maxLen = Math.max(maxLen, right - left + 1); } return maxLen; } } 📚 This problem strengthened my understanding of efficient window management in arrays, which is a common pattern in coding interviews. #LeetCode #Java #SlidingWindow #DSA #ProblemSolving #CodingJourney #SoftwareDevelopment

Tackling the "Silent Overflow" in Java 🛑🔢 I recently worked through LeetCode #7: Reverse Integer, and it was a fantastic deep dive into how Java handles 32-bit integer limits and the dangers of "silent overflows." The Problem: Reverse the digits of a signed 32-bit integer. If the reversed number goes outside the 32-bit signed range of [-2^{31}, 2^{31} - 1], the function must return 0 The "Asymmetry" Challenge: In Java, Integer.MIN_VALUE is -2,147,483,648, while Integer.MAX_VALUE is 2,147,483,647. The negative range is one unit larger than the positive range due to Two's Complement arithmetic. This creates a massive trap: using Math.abs() on the minimum value will actually overflow and remain negative! My Optimized Solution Strategy: I implemented a two-pronged approach to handle these edge cases efficiently: 1️⃣ Pre-emptive Boundary Filtering: I added a specific optimization check at the very beginning: if(x >= Integer.MAX_VALUE - 4 || x <= Integer.MIN_VALUE + 6) return 0;. This catches values at the extreme ends of the 32-bit range immediately, neutralizing potential Math.abs overflow before the main logic even begins. 2️⃣ 64-bit Buffering: I used a long data type for the reversal calculation. This provides a 64-bit "safety net," allowing the math to complete so I can verify if the result fits back into a 32-bit int boundary. Complexity Analysis: 🚀 Time Complexity: O(log_10(n))— The loop runs once for every digit in the input (at most 10 iterations for any 32-bit integer). 💾 Space Complexity: O(1)— We use a constant amount of extra memory regardless of the input size. Small details like bit-range asymmetry can break an entire application if ignored. This was a great reminder that as developers, we must always think about the physical limits of our data types! #Java #LeetCode #SoftwareDevelopment #ProblemSolving #Algorithms #CleanCode #JavaProgramming #DataStructures #CodingLife

Day 21/100: String Compression & Memory 📦 Today I tackled String Compression in Java (e.g., "aaabb" -> "a3b2").  The Goal: Compress a string by counting repeated characters. Example:"aaabbc" becomes "a3b2c1". If the compressed string isn't actually shorter, return the original. Key Learning: StringBuilder vs. String In Java, strings are immutable. If you add to a string in a loop, Java creates a new object every single time. To fix this, I used **StringBuilder**, which is much faster and memory-efficient for building long strings. The Strategy: 1️⃣ Iterate through the string once. 2️⃣ Keep a running count of identical consecutive characters. 3️⃣ Append the character and count to the builder. Simple logic, big performance difference. 🚀 #100DaysOfCode #Java #DSA #Strings #Optimization #Unit2 #CodingJourney #LearnInPublic

🚀 Day 11 of #50DaysLeetCode Challenge Today I tackled a HARD problem: “Regular Expression Matching” on LeetCode using Java. 🔹 Problem: Given a string "s" and a pattern "p", implement regex matching with support for: • "." → matches any single character • "*" → matches zero or more of the preceding element Return true if the entire string matches the pattern. Example: Input: "s = "aa", p = "a*"" → Output: "true" Input: "s = "aa", p = "a"" → Output: "false" 🔹 Approach I Used: I used Dynamic Programming (DP) — anything else here is inefficient or breaks on edge cases. ✔ Created a 2D DP table "dp[m+1][n+1]" ✔ "dp[i][j]" represents whether "s[0...i-1]" matches "p[0...j-1]" ✔ Handled "*" carefully: - Treat it as zero occurrence → "dp[i][j-2]" - Or one/more occurrence → match previous character ✔ Built the solution bottom-up 🔹 Concepts Practiced: • Dynamic Programming (2D DP) • String pattern matching • Handling complex edge cases #LeetCode #DSA #Java #DynamicProgramming #Algorithms #CodingChallenge #50DaysOfCode

🚀 LeetCode Practice Update Solved “1415. The k-th Lexicographical String of All Happy Strings of Length n” today. It’s an easy–medium problem for anyone comfortable with Backtracking, but a great exercise to strengthen recursive thinking and constraint-based generation. 🧠 Approach The idea is to generate all valid “happy strings” using backtracking and then simply pick the k-th string in lexicographical order. A happy string means: It only contains characters 'a', 'b', 'c' No two adjacent characters are the same ⚙️ Strategy 1. Start with an empty string and recursively build all possible strings of length n. 2. At each step, try adding characters from 'a' → 'c' to maintain lexicographical order. 3. Before adding a character, check the constraint: If the last character of the current string is the same as the character we want to add → skip it. 4. If the string length becomes n, add it to the list of valid happy strings. 5. After generating all valid strings: If k > total strings, return an empty string. Otherwise return the (k-1)th index from the list. 🔁 Key Backtracking Step After exploring a choice, we remove the last character to restore the previous state and try the next option. This pattern of choose → explore → undo (backtrack) is the heart of backtracking problems. 💡 Problems like this really show how powerful backtracking can be when generating all valid combinations under constraints. #LeetCode #Backtracking #Java #DSA #ProblemSolving #CodingJourney

🚀Day 24 of #75DaysofLeetCode LeetCode Problem Solved: Removing Stars From a String (2390) Today I solved the problem “Removing Stars From a String.” 🔹 Problem Statement: We are given a string containing characters and *. Each * removes the closest non-star character to its left, along with the * itself. The task is to return the final string after all stars are processed. 💡 Approach: The most efficient way to solve this is using a Stack-like approach. 1️⃣ Traverse the string from left to right. 2️⃣ If the character is not *, add it to the result (stack). 3️⃣ If the character is *, remove the last added character. 4️⃣ Continue until the string is processed. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) 💻 Java Implementation: class Solution { public String removeStars(String s) { StringBuilder sb = new StringBuilder(); for(char c : s.toCharArray()) { if(c == '*') { sb.deleteCharAt(sb.length() - 1); } else { sb.append(c); } } return sb.toString(); } } ✨ Key Learning: Using a stack or StringBuilder helps efficiently simulate the removal of the closest character on the left. #LeetCode #Java #DataStructures #ProblemSolving #CodingPractice #100DaysOfCode

🚀 Day 15 of #50DaysLeetCode Challenge Today I solved the “Longest Common Prefix” problem on LeetCode using Java. 🔹 Problem: Find the longest common prefix among an array of strings. If no common prefix exists, return an empty string "". Example: Input: ["flower","flow","flight"] Output: "fl" Input: ["dog","racecar","car"] Output: "" 🔹 Approach I Used: ✔ Took the first string as the initial prefix ✔ Compared it with each string in the array ✔ If mismatch occurs, reduced the prefix step by step ✔ Continued until all strings share the same prefix 🔹 Key Insight: You don’t need complex logic — just keep shrinking the prefix until it matches all strings. 🔹 Concepts Practiced: • String manipulation • Iterative comparison • Edge case handling #LeetCode #DSA #Java #Algorithms #ProblemSolving #CodingChallenge #50DaysOfCode