LeetCode 3666: Minimum Operations to Equalize Binary String

LeetCode Daily Challenge – Matrix Similarity After Cyclic Shifts Today I solved an interesting problem that involves matrix traversal + cyclic shifts logic. Problem Insight: We are given a matrix and an integer k. Even-indexed rows → shift left Odd-indexed rows → shift right We need to check if the matrix remains similar after k cyclic shifts. Key Idea: Instead of actually shifting the rows (which is costly), we calculate the expected index directly using modulo arithmetic. Why? Because shifting k times is equivalent to shifting k % n times (where n = number of columns). Logic Breakdown: For each element mat[i][j]: If row is even (i % 2 == 0) ➝ Left shift → new index = (j + k) % n If row is odd (i % 2 != 0) ➝ Right shift → new index = (j - k + n) % n Then simply compare: If all elements match expected positions → return true Otherwise → return false Why this approach? Avoids extra space No actual shifting needed Efficient → O(m × n) time complexity What I learned: Modulo is powerful for cyclic problems Always try to avoid simulation when math can solve it Pattern-based thinking helps in matrices Would love to hear if you solved it differently! #LeetCode #DataStructures #Java #CodingJourney #100DaysOfCode #ProblemSolving

Today’s random problem was 3310. Remove Methods From Project The problem asks us to determine which methods can be safely removed from a project without breaking any dependencies. Each method may invoke other methods, and if a method is removed, any method depending on it directly or indirectly may also be affected. Key Insight: Methods form a directed graph where edges represent invocations. A method can only be removed if none of the remaining methods depend on it. Instead of checking dependencies repeatedly, we can precompute the indegree of each method (number of methods calling it) and track all methods reachable from the target method. Problem Is Tricky Because of Dependencies: Reachability: Removing a method affects all methods it calls directly or indirectly. Dependency Awareness: Methods with incoming edges from outside the removable set cannot be removed. Mutation Order: We must traverse the graph carefully to avoid corrupting dependency counts during processing. My Approach: I used a DFS-based solution: First DFS: Traverse the graph starting from the target method. Collect all reachable methods into a set. Reduce indegrees of the methods called by each visited method to simulate “removal.” Decision Step: If any reachable method still has incoming edges after DFS, none of the methods can be removed safely, so we keep all methods. Otherwise, we remove all methods not in the reachable set. Complexity: Time: O(n + m) (each method and each invocation visited once) Space: O(n + m) (graph + recursion stack + reachable set) #LeetCode #CodingChallenge #SoftwareEngineering #Java #DataStructures #Algorithms #Graph #DFS #ProblemSolving #TechInterviewPrep

Day 72: Binary Search Squared 🏔️ Problem 3296: Minimum Number of Seconds to Make Mountain Height Zero Today’s problem was a masterclass in optimization. The goal: reduce a mountain's height to zero using workers who take progressively more time for each unit of height they remove. The Strategy: • Binary Search on Answer: Since the time needed is monotonic, I used binary search to find the minimum seconds required to finish the job. • Nested Binary Search: Inside that loop, I ran a second binary search for each worker to calculate the maximum height they could handle within that time limit. • Efficiency: This "Double Binary Search" approach kept the runtime lean even with a massive search space up to 10^16. Solving a "Binary Search inside a Binary Search" problem is a great way to test your grip on time complexity. It’s all about finding that optimal boundary. 🚀 #LeetCode #Java #BinarySearch #Algorithms #ProblemSolving #DailyCode

Day 74/365 – Remove Duplicate Letters Problem: Given a string s, remove duplicate letters so that each letter appears once and the result is the smallest lexicographical order possible. Example: "bcabc" → "abc" "cbacdcbc" → "acdb" 💡 Key Idea Use a Monotonic Stack to maintain characters in lexicographically smallest order. We also track: • Last occurrence of each character • Whether a character is already used in the result 🧠 Approach 1️⃣ Record the last index of each character. 2️⃣ Traverse the string. 3️⃣ Skip characters already included. 4️⃣ While stack top is bigger than current character and it appears later again, remove it to get a smaller result. 5️⃣ Push current character into the stack. 📦 Key Logic while(!stack.isEmpty() && stack.peek() > c && lastIndex[stack.peek() - 'a'] > i) { visited[stack.pop() - 'a'] = false; } This ensures: Lexicographically smallest result Each character appears only once 📊 Complexity ⏱ Time: O(n) 📦 Space: O(1) (since only 26 letters) ✨ Key Learning This is a classic Monotonic Stack + Greedy problem. Pattern to remember: 👉 Remove previous larger elements if they appear again later. This pattern appears in problems like: Smallest Subsequence Remove K Digits Monotonic stack optimization problems #Day74 #365DaysOfCode #LeetCode #MonotonicStack #GreedyAlgorithm #DataStructures #Algorithms #Java #DSA #CodingInterview

✳️Day 23 of #100DaysOfCode✳️ 🚀Solved Remove Duplicate Letters ✅The goal is to remove duplicate letters so that every letter appears once, ensuring the result is the smallest in lexicographical order among all possible results. 🧠 My Approach & Implementation Steps: To solve this efficiently in O(n) time, I used a Greedy approach supported by a Monotonic Stack: 1️⃣Frequency Map: First, I built a frequency array freq[26] to keep track of the remaining count of each character in the string. This tells the algorithm if a character can be safely removed and re-added later. 2️⃣Visited Tracking: I used a boolean array visited[26] to ensure each character is added to our result only once, maintaining the "unique" constraint. 3️⃣Monotonic Stack Logic: As I iterated through the string: I decremented the character's frequency. If the character was already in the stack, I skipped it. 4️⃣The Crucial Part: While the current character was smaller than the top of the stack AND that top character appeared again later in the string (checked via the frequency map), I popped the stack and marked that character as "not visited." 💯Result Construction: Finally, I pushed the current character onto the stack and built the final string using a StringBuilder. 📊 Results: Runtime: 2 ms (Beats 89.98%) Memory: 43.64 MB (Beats 78.91%) ⚡This problem is a great reminder of how powerful stacks can be when you need to maintain a specific order while processing linear data. Onward to the next challenge! 💻🔥 #LeetCode #Java #DataStructures #Algorithms #CodingLife #ProblemSolving #SoftwareEngineering Anchal Sharma Ikshit ..

𝗘𝘀𝗰𝗮𝗽𝗲 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀 𝗶𝗻 𝘁𝗵𝗲 𝗛𝗼𝘁𝗦𝗽𝗼𝘁 𝗝𝗩𝗠: 𝗪𝗵𝗲𝗻 new Object() 𝗗𝗼𝗲𝘀𝗻’𝘁 𝗔𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗖𝗿𝗲𝗮𝘁𝗲 𝗮𝗻 𝗢𝗯𝗷𝗲𝗰𝘁 Optimizing code is great, but sometimes micro-optimization can make code harder to read, and more difficult to maintain. That is why sometimes the JIT compiler does some of the low-level optimization work for you. I wrote about one such optimization, escape analysis in the HotSpot JVM, and how it affects the way we think about writing clean and readable code without worrying too early about performance. Read more here: https://lnkd.in/dkRiugz6

𝗗𝗮𝘆 𝟲𝟲/𝟭𝟬𝟬 — 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗲 𝗥𝗲𝘃𝗲𝗿𝘀𝗲 𝗣𝗼𝗹𝗶𝘀𝗵 𝗡𝗼𝘁𝗮𝘁𝗶𝗼𝗻 Day 66. Two-thirds done. Today's problem? The reason calculators exist. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ #𝟭𝟱𝟬: Evaluate Reverse Polish Notation (Medium) 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: Evaluate expressions in Reverse Polish Notation (RPN). Numbers come first, operators after. Example: ["2","1","+","3","*"] → ((2+1)*3) = 9 No parentheses needed. No order of operations confusion. Just read left to right. 𝗧𝗵𝗲 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: Stack. When you see a number, push it. When you see an operator, pop two numbers, apply the operation, push the result. The last number standing? That's your answer. Used ArrayList as a stack for cleaner syntax with removeLast(). Same LIFO behavior. 𝗪𝗵𝘆 𝗜𝘁 𝗠𝗮𝘁𝘁𝗲𝗿𝘀: This is how calculators and compilers evaluate expressions internally. RPN eliminates ambiguity. "3 + 4 * 5" needs rules. "3 4 5 * +" doesn't. Understanding this makes you understand how expression parsing works. 𝗖𝗼𝗱𝗲: https://lnkd.in/gXwcqVdP 𝗗𝗮𝘆 𝟲𝟲/𝟭𝟬𝟬 ✅ 𝟲𝟲 𝗱𝗼𝘄𝗻. 𝟯𝟰 𝘁𝗼 𝗴𝗼. #100DaysOfCode #LeetCode #Stack #RPN #Algorithms #ExpressionEvaluation #CodingInterview #Programming #Java #MediumLevel #CompilerDesign

🚀 LeetCode Daily Challenge 🧩 Problem: Find Unique Binary String You are given an array nums containing n unique binary strings, each of length n. 🎯 Goal: Return a binary string of length n that does not appear in nums. If multiple answers exist, you can return any of them. 🧠 Key Intuition Since there are: 2ⁿ possible binary strings of length n but only n strings provided in nums There must be at least one binary string that is missing. So the strategy is: Generate possible binary strings of length n Check if they exist in the given set Return the first one that is not present. 🛠 Approach 1️⃣ Store all given binary strings in a set for fast lookup. 2️⃣ Use recursion/backtracking to generate binary strings of length n. 3️⃣ For each generated string: Check if it exists in the set. If not → this is our answer. 4️⃣ Stop further recursion once a valid string is found. This ensures we efficiently explore the binary combinations until we find a missing one. 📈 Complexity Analysis Time Complexity: O(2ⁿ × n) in the worst case Space Complexity: O(n) for recursion + set storage 🔗 Problem https://lnkd.in/ePXw7Y5v 💻 Solution https://lnkd.in/e8HB8Rvb #LeetCode #Cpp #DSA #Backtracking #Recursion #BinaryStrings #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge #Algorithms

Day 78: Balancing X and Y (The Grid Grind) ⚖️ Problem 3212: Count Submatrices With Equal Frequency of X and Y Yesterday’s logic was so good I had to run it back. The mission: count all submatrices starting from (0,0) that have at least one 'X' and an equal number of 'X's and 'Y's. The Strategy: • Net Balance Trick: Assigned 'X' as 1 and 'Y' as -1. If the prefix sum of a submatrix is 0, the frequencies are equal. Simple math, big brain energy. 🧠 • 2D Prefix Sums: Used the inclusion-exclusion principle to keep the count updated in a single pass. • The "At Least One X" Check: Maintained a separate prefix matrix just to track if an 'X' had even shown up yet. No 'X', no entry. It might not be the most "optimized" code in the world yet, but it passes the tests and the logic is solid. In a world of complex algorithms, sometimes the O(M⋅N) "it just works" approach is the real MVP. 🚀 #LeetCode #Java #DataStructures #Algorithms #DailyCode

🚀 Day 544 of #750DaysOfCode 🚀 🧩 Problem Solved: Matrix Similarity After Cyclic Shifts Today’s problem focused on understanding how cyclic shifts affect matrix rows and optimizing the approach instead of brute-force simulation. 🔍 Key Insight: Instead of performing the shift operation k times, we can reduce it using: 👉 k % n (where n = number of columns) This works because after n shifts, the row returns to its original form. 💡 Approach: Even-indexed rows → shift left Odd-indexed rows → shift right Compare each element with its expected position after shifting No need to actually modify the matrix ✅ ⚡ Optimization: Avoided unnecessary operations by directly checking positions using modulo arithmetic. 📊 Complexity: Time: O(m × n) Space: O(1) 🎯 What I Learned: Efficient problem solving is not about doing more operations, but about reducing them smartly. Recognizing patterns like cyclic repetition can drastically improve performance. 💬 Question for you: Have you ever optimized a brute-force solution using mathematical insights like modulo? #LeetCode #DataStructures #Algorithms #Java #CodingJourney #ProblemSolving #TechInterview #100DaysOfCode #LearningInPublic