LeetCode Challenge: Bitwise Complement Solution

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gBvd5iWy 💡 My thought process: For this question, I am precalculating the total sum of the grid and row-wise and column-wise sums. Store the precalculated values in a vector and then simply do a cumulative sum over the vector. If the cumulative sum equals the total sum - cumulative sum, this means that a single cut is possible to split the array. The calculation part is done in another method, and I simply call the method twice for row-wise check and then column-wise. 👉 My Solution: https://lnkd.in/gNYsk6iz If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gSiw_GQq 💡 My thought process: It uses a two-pointer approach. One pointer starts at the top row of the submatrix, and the other starts at the bottom row. For each pair of rows, it goes through all columns within the submatrix range and swaps the elements column by column. This process continues until the top and bottom pointers meet or cross. This ensures the submatrix is reversed in place without using any extra space. The updated grid is then returned. 👉 My Solution: https://lnkd.in/g_cAfrtb If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gbtaBXYW 💡 My thought process: The algorithm first calculates a normalized shift value using k % n. Shifting a row by its total length, n, returns the original configuration. Therefore, any shift k is the same as k modulo n. Instead of rotating memory physically or creating a temporary matrix, the code uses a virtual mapping strategy. It goes through each cell (i, j) and finds the index of the element that would be in that position after the shift. For even rows (left shift), to find the original value that moves into position j after a left shift, the code looks at the index (j - shift). It manages negative results by wrapping around with an addition of n. For odd rows (right shift), it checks the index (j + shift) % n. The function has a fail-fast mechanism; it returns false right away if it finds the first difference between a cell and its shifted counterpart. 👉 My Solution: https://lnkd.in/g5myRYRj If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/giAcdv2U 💡 My thought process: This solution uses 3D dynamic programming to find the maximum coins that can be collected from the top-left to the bottom-right of a grid, allowing up to 2 neutralizations for negative cells. The state dp[i][j][k] stores the maximum coins reachable at cell (i, j) using k neutralizations. For each cell, transitions are taken from the left and top cells. If the current cell is negative, two options are considered: either neutralize it (if k > 0) and carry forward the previous value without adding the negative, or do not neutralize and add the cell value. For non-negative cells, the value is simply added to the best of the previous states. The starting cell is initialized separately based on whether it is neutralized or not. The final answer is the maximum value among dp[m-1][n-1][0], dp[m-1][n-1][1], and dp[m-1][n-1][2]. 👉 My Solution: https://lnkd.in/gZWS3Kns If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g-twtNFT 💡 My thought process: In the first pass (reverse order: bottom-right to top-left), we keep a running suffix product that shows the product of all elements after the current cell in row-major order. We store this value in the result matrix p[i][j] before updating the suffix with the current grid value. In the second pass (forward order: top-left to bottom-right), we maintain a running prefix product that represents the product of all elements before the current cell. For each cell, we compute the final result by multiplying the prefix (product before) with the already stored suffix (product after), and then we update the prefix with the current grid value. This method makes sure that for every cell, we calculate the product of all other elements in O(n × m) time with O(1) extra space aside from the output matrix. It also correctly handles large values using modular arithmetic. 👉 My Solution: https://lnkd.in/g2Q_GgpZ If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

Day 36 of My DSA Journey Today I solved LeetCode 150 – Evaluate Reverse Polish Notation (RPN) on LeetCode. 📌 Problem Evaluate the value of an arithmetic expression in Reverse Polish Notation. Valid operators are: +, -, *, / Each operand may be an integer. Example: Input: ["2","1","+","3","*"] Output: 9 Explanation: (2 + 1) * 3 = 9 🧠 Approach – Stack This problem is a perfect application of the Stack data structure. Steps I followed: • Traverse the tokens array. • If the element is a number → push it onto the stack. • If it is an operator: Pop the top two elements (a and b) Perform the operation (a operator b) Push the result back into the stack • At the end, the stack contains the final result. ⏱ Time Complexity: O(n) — We process each token once 📦 Space Complexity: O(n) — Stack to store operands 💡 Key Learnings ✔ Understanding Reverse Polish Notation (Postfix Expression) ✔ Applying stack for expression evaluation ✔ Handling operator precedence implicitly using stack This problem connects DSA with compiler/interpreter concepts, which makes it even more interesting 🚀 Consistency continues — improving every day 💪 #100DaysOfCode #DSA #Stack #LeetCode #Java #ProblemSolving #CodingJourney #DeveloperJourney #Programming #SoftwareEngineering

🚀 Day 11 of 100 Days LeetCode Challenge Problem: Complement of Base 10 Integer Today’s problem is a clean example of bit manipulation fundamentals 🔥 💡 Key Insight: To find the complement: Convert the number to binary Flip all bits (0 → 1, 1 → 0) Convert it back to decimal 👉 But here’s the trick: We only flip significant bits (ignore leading zeros) 🔍 Optimized Approach: Create a bitmask with all bits set to 1 (same length as n) Then: complement = n XOR mask 👉 Example: n = 5 → (101) mask = 111 Result = 101 ⊕ 111 = 010 → 2 🔥 What I Learned Today: XOR is powerful for bit flipping operations Bitmasking simplifies binary problems Always consider binary representation constraints 📈 Challenge Progress: Day 11/100 ✅ Bit by bit improving! LeetCode, Bit Manipulation, XOR, Binary Representation, Bitmasking, DSA Practice, Coding Challenge, Problem Solving, Algorithms #100DaysOfCode #LeetCode #DSA #CodingChallenge #BitManipulation #Binary #XOR #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gJUJE-YA 💡 My thought process: The provided code uses a backtracking approach to generate all possible strings of length n that satisfy the happy string condition: no two adjacent characters can be identical. The algorithm builds these strings in lexicographical order by exploring 'a', 'b', and then 'c'. The main logic is in the solve function, which acts as a recursive explorer. It takes the current string and the number of characters left to add. At each step, it tries appending 'a', 'b', and 'c'. Before adding a character, it checks for safety by ensuring that the character is not the same as the last one in the string. This prevents violating the happy constraint. Once a character is added, the function calls itself with n-1 to fill the next position. After finishing that branch of the search, it removes the character to backtrack and try the next alphabetical option. In the getHappyString function, the process starts by launching three separate recursive chains: one with 'a', one with 'b', and one with 'c'. Since the loops and initial calls follow alphabetical order, the allStrings vector is filled with every valid combination in sorted order. Finally, the code checks if the requested index k exists within the total count of generated strings. If k is within bounds, it returns the string at index k-1; otherwise, it returns an empty string. 👉 My Solution: https://lnkd.in/gKDqj84r If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 Day 26 | 100 Days of Coding Challenge #DrGViswanathanChallenge 📘 Problem Solved: Single Number (LeetCode) 🔧 Approach Used (Brute Force): • Checked each element and counted its occurrences • Returned the element that appears only once ⏳ Complexity: Time: O(n²) Space: O(1) 🧠 Key Learning: Brute force works, but understanding constraints helps us optimize further. 💡 Optimal Insight: This problem can be solved in O(n) using XOR: 👉 a ^ a = 0 and a ^ 0 = a → all duplicates cancel out, leaving the single number. 📂 Topics Covered: Arrays, Brute Force, Bit Manipulation #100DaysOfCode #DSA #CPP #LeetCode #CodingJourney #CompetitiveProgramming

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gK993p-S 💡 My thought process: The main function, minAbsDiff, goes through all possible top-left positions of the k × k submatrices. For each position (i, j), it calls the helper function solve to find the result for that submatrix and stores it in the answer matrix, which has a size of (m − k + 1) × (n − k + 1). The solve function collects all elements from the k × k submatrix starting at (i, j) and puts them into a set. This automatically sorts the elements and removes duplicates. If the set has only one unique element, the function returns 0 because all values are the same. If there are multiple unique elements, the function goes through the sorted set and calculates the absolute difference between each pair of consecutive elements. Since the set is sorted, the minimum absolute difference will be between adjacent elements. The smallest difference is tracked and returned. The overall time complexity is O((m − k + 1) × (n − k + 1) × k² log(k²)) because each submatrix requires inserting k² elements into a set and iterating through it. The space complexity is O(k²) for storing elements of each submatrix. 👉 My Solution: https://lnkd.in/gj6juuUU If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari