Alternating Bits LeetCode Challenge

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g5ggMZxw 💡 My thought process: The approach checks how many mismatches occur if the string follows an alternating pattern starting with 0 (0,1,0,1...), counts the number of positions that violate this pattern, and since the opposite alternating pattern starting with 1 (1,0,1,0...) would require the remaining changes, the minimum of the two mismatch counts represents the minimum number of operations required. 👉 My Solution: https://lnkd.in/gVuWTeKh 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/g5nYsHBR 💡 My thought process: To form a decimal number n using the fewest deci-binary numbers, the key factor is the highest digit in n. Each deci-binary number can contribute a maximum of 1 to any digit position. So, if a digit in n is 7, we need at least 7 deci-binary numbers to reach that sum. Thus, the minimum number of deci-binary numbers needed is simply the highest digit in the provided string. The approach is simple: start with a variable result set to 0. Go through each character in the string, convert it to an integer using n[i] - '0', update result with the greater value between result and digit, and finally return result. 👉 My Solution: https://lnkd.in/ggv3b48t 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/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/gw_xVvrb 💡 My thought process: For the best approach, i am using a lambda function where we are performing sorting based on the number of set bits in the number. We are using the built-in popcount function in C++ to count the number of set bits in a given number. If the set bits are the same, return the smaller number in that scenario. You can use extra space like an ordered map to make it simpler; that code is available on my GitHub. 👉 My Solution: https://lnkd.in/g8x_PxTh 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/geeKcuMP 💡 My thought process: The approach counts the number of special positions in a binary matrix by ensuring that a cell containing 1 is the only 1 in both its row and column. First, the number of rows, m, and columns, n, are determined. Two auxiliary arrays, rowOnes and colOnes, store the count of 1s in each row and column, respectively. The matrix is first traversed row by row to count how many 1s appear in each row and store these counts in rowOnes. Next, it is traversed column by column to count how many 1s appear in each column and store these counts in colOnes. After computing these counts, the matrix is scanned again. For every cell containing 1, it checks whether that row and column both contain exactly one 1. If both conditions are met, the position is considered special, and the count is increased. Finally, the total number of such positions is returned. 👉 My Solution: https://lnkd.in/g9eZdbF2 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/gDzrB9cW 💡 My thought process: This solution creates the binary string step by step, starting from "0". For each level from 2 to n, it forms a new string by taking the previous string, inserting "1" in the middle, and then adding the reversed and bit-flipped version of the previous string (0 changes to 1 and 1 changes to 0). After each construction, it checks if the string has reached or exceeded the required k position. If it has, it immediately returns the k-th character. This approach prevents any extra construction once the answer is found. 👉 My Solution: https://lnkd.in/gFXgkTpm 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 5 of My LeetCode Journey Today I solved LeetCode 150 – Evaluate Reverse Polish Notation (Medium). This problem strengthened my understanding of: Stack data structure Postfix expression evaluation Operator handling (+, -, *, /) Edge case management (negative numbers & division) 💡 Key Learning: Reverse Polish Notation removes the need for parentheses, but requires strong stack logic and careful operand order handling. This problem reinforced how powerful stacks are in expression evaluation and real-world compiler logic. Consistency is the real game changer. On to Day 5 🚀 #LeetCode #DSA #Stacks #ProblemSolving #Cplusplus #CodingJourney #SoftwareEngineering #100DaysOfCode

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g4J85qey 💡 My thought process: If you have a block of three 0s followed by a block of two 1s (00011), you can only create two valid pairs: 01 and 0011. The smaller group always limits the number of matches you can make, which is why the code uses min(prev, curr). To keep track of this, the code uses prev for the size of the block you just finished and curr for the block you’re currently counting. As you go through the string, you keep increasing curr as long as the characters remain the same. The moment the character changes, like when you hit a 1 after a series of 0s, it means you've completed a block. You take the min of the old block and the new block, add it to your total, move the curr count into prev, and start over for the next group. There is one small issue in the code: because that addition only happens when the characters change, the very last block in the string doesn't get processed inside the loop. That’s why there is one extra result += min(prev, curr) at the very end to catch that final transition. 👉 My Solution: https://lnkd.in/gdK35f76 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

𝗗𝗮𝘆 51 𝗼𝗳 𝟯𝟲𝟬 days of LeetCode Challenge. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 :- 1022. Sum of Root To Leaf Binary Numbers You are given the root of a binary tree where each node has a value 0 or 1. Each root-to-leaf path represents a binary number starting with the most significant bit. For example, if the path is 0 -> 1 -> 1 -> 0 -> 1, then this could represent 01101 in binary, which is 13. For all leaves in the tree, consider the numbers represented by the path from the root to that leaf. Return the sum of these numbers. The test cases are generated so that the answer fits in a 32-bits integer. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗶𝗻𝗸:- https://lnkd.in/gKvXnDn3 𝗛𝗶𝗻𝘁:- Basic DFS by forming all the binary string then convert it to decimal number and add it to the sum. 𝗚𝗶𝘁𝗵𝘂𝗯 𝗰𝗼𝗱𝗲:- https://lnkd.in/gM8y3SJF #SoftwareEngineering #DSAJourney #Coding #LeetCode #DSA #TechCareers #SDE

𝗗𝗮𝘆 50 𝗼𝗳 𝟯𝟲𝟬 days of LeetCode Challenge. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 :- 1461. Check If a String Contains All Binary Codes of Given a binary string s and an integer k, return true if every binary code of length k is a substring of s. Otherwise, return false. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗶𝗻𝗸:- https://lnkd.in/gDfaVQby 𝗛𝗶𝗻𝘁:- Don't try to solve the problems with the steps it required, instead try to find the unique substrings with length k and match with expected substring 2 ^ k. 𝗚𝗶𝘁𝗵𝘂𝗯 𝗰𝗼𝗱𝗲:- https://lnkd.in/gCa-GdEc #SoftwareEngineering #DSAJourney #Coding #LeetCode #DSA #TechCareers #SDE