LeetCode Challenge: Binary String Alternating Pattern

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g6uRPkE6 💡 My thought process: The first approach calculates the bitwise complement by examining each bit of the number. It starts by determining how many bits are needed to represent n using log2(n) + 1. For each bit position i, a mask (1 << i) is used to isolate that bit from n. If the extracted bit is 0, the result for that position is set by adding the same mask, effectively flipping the bit. This creates a new number where all bits within the effective bit length of n are inverted, resulting in the complement. The second approach uses the XOR operation to flip all relevant bits at once. It first calculates the number of bits in n and creates a mask filled with 1s in all those positions using (1 << digits) - 1. This mask represents the highest value that can be formed with the same number of bits. Applying n ^ mask flips every bit within that range because XOR with 1 changes the bit and XOR with 0 leaves it the same, giving the bitwise complement of n. 👉 My Solution: https://lnkd.in/gGCdUW3H 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/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/eC4nGYRx 💡 My thought process: The code checks if two strings can be made equal by swapping characters only between indices that have the same parity. This means characters at even indices can only move among even positions, while those at odd indices can only move among odd positions. To manage this, the code first goes through the first string and records the frequency of characters separately for even and odd indices using two unordered maps. This captures how many times each character appears in each parity group. Next, it goes through the second string. For each character, it checks if it exists in the corresponding parity map. If the current index is even, it checks the even map; if odd, it checks the odd map. When it finds a match, it decreases the frequency and removes the entry from the map if it reaches zero. If a character isn’t found in the required parity map, the function returns false right away. This approach is necessary because checking overall character frequency isn’t enough due to the swapping restrictions. Since characters can’t move between even and odd indices, both parity groups must have identical frequency distributions in both strings. Using separate maps ensures that this rule is enforced. If all characters from the second string match with the corresponding parity groups from the first string, the function returns true, confirming that the transformation is possible. 👉 My Solution: https://lnkd.in/erhV7_HJ 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/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

🚀 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/gYK_vaVH 💡 My thought process: We create a result string of size n + m - 1 filled with placeholders. This size is chosen because each index in str1 corresponds to a substring of length m in the final string. First, we handle all T positions. Wherever str1[i] equals T, we place str2 directly starting at index i in the result. We do this first because these are fixed requirements and cannot be changed later. If we wait, we might create conflicts that are hard to fix. Next, we fill the remaining positions marked with $. For each of these positions, we try characters from a to z and choose the smallest one that does not break any F condition. This keeps the answer lexicographically smallest. To check validity quickly, we use checkLocal. Instead of checking the entire string each time, it only checks the substrings that could be affected by the current position. The idea is simple: changing one position can only impact substrings that include that position, so checking beyond that is unnecessary. If no character can be placed at any position without violating an F condition, we return an empty string since construction is impossible. Finally, we do a full validation. For every index: If it is T, the substring must match str2.   If it is F, the substring must not match str2. This final check ensures that all constraints are satisfied correctly. 👉 My Solution: https://lnkd.in/guMdgMBj 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/gx6PQVMB 💡 My thought process: It is mentioned that the size of the array also denotes the size of each string and the number of unique strings in the array. I took an unordered set, and I generated all the possible binary strings of length n. I only generated n+1 strings because we only need to return any one of them. When the size of the set goes above n, I stop finding anymore binary strings. Then, I iterate over the array and remove those binary strings present in the array from the set. Just simply return the remaining string in the set. 👉 My Solution: https://lnkd.in/gJKMj6vX 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 14 of #Dev #DSA Today I worked on the classic problem: Palindrome Number. 🔍 What I learned: How to reverse a number using mathematical operations (no string conversion). Extracting digits using % 10 and reducing the number using Math.floor(). Comparing the reversed number with the original to check for palindrome. 💡 Key Insight: Instead of converting the number into a string, solving it mathematically improves problem-solving skills and keeps space usage minimal. ⚙️ Approach: Take last digit using % 10 Build reversed number Remove last digit using / 10 Compare reversed with original ⏱️ Time Complexity: O(log₁₀ n) 📦 Space Complexity: O(1) 📌 Takeaway: Simple problems like this help build a strong foundation in number manipulation and logic building. Consistency is the key 🔥 #Day14 #DSAJourney #Coding #JavaScript #LeetCode #ProblemSolving #100DaysOfCode

🚀 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/gfx2E6jb 💡 My thought process: The rotate90 function rotates the matrix 90 degrees clockwise in place. It starts by transposing the matrix, swapping elements across the diagonal. This changes rows into columns. After that, it reverses each row to achieve the final rotated version. The check function compares two matrices element by element. It goes through all the positions and returns false immediately if it finds any mismatch. If all elements match, it returns true, showing that both matrices are the same. The findRotation function tests all possible rotations of the matrix: 0, 90, 180, and 270 degrees. For each rotation, it checks if the current matrix matches the target matrix. If a match is found at any point, it returns true. If not, it rotates the matrix by 90 degrees and continues. If no rotation matches, it returns false. Overall, the method is efficient. Each rotation and comparison takes quadratic time based on the size of the matrix, and it only performs a constant number of rotations. 👉 My Solution: https://lnkd.in/gcj4S5iQ 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