LeetCode Challenge: Circular Array Movement Problem

🚀 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/gXwweaP3 💡 My thought process: This solution finds the longest substring where the characters 'a', 'b', and 'c' appear the same number of times. It approaches the problem by breaking it into three separate cases: substrings with one character, substrings with two distinct characters, and substrings with all three characters. In the single-character case, the method scans the string and tracks the length of the longest continuous run of the same character. This addresses substrings where balance is easily met, as only one character is present. For the two-character case, the technique uses a prefix-difference approach. While scanning the string, it counts the two selected characters and calculates their difference. If the same difference has occurred before, the segment between the last index and the current index must have equal counts of the two characters, making its length a valid option. When a third character appears, it resets the counts and the hash map to prevent invalid matches across segments. In the three-character case, the prefix concept is extended to two dimensions. Instead of tracking one difference, the algorithm focuses on two differences: (count(a) − count(b)) and (count(a) − count(c)). If the pair of differences appears again, it indicates that the counts of all three characters between those indices are equal, creating a balanced substring. A hash map keeps the earliest index for each difference pair, allowing for quick length updates in a single pass through the string. 👉 My Solution: https://lnkd.in/gc_vMxFG 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/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/gR-ZeuhX 💡 My thought process: The approach involves checking all possible valid times that can show on a binary watch. We select the times where the number of LEDs turned on matches the given value. A binary watch displays hours from 0 to 11 and minutes from 0 to 59, so we look at every possible hour and minute combination. For each pair, we count how many bits are set to 1 in the binary representation of the hour and the minute using the built-in `__builtin_popcount()` function. If the total number of set bits in the hour and minute equals the input `turnedOn`, that time is valid. When creating the time string, we add the hour normally, but the minute must always be in two-digit format. A leading zero is added when the minute value is less than 10. We store all valid formatted times in a result list and return it at the end. 👉 My Solution: https://lnkd.in/gN6FMYtF 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/gTrw45pn 💡 My thought process: We check each bit one by one and compare it with the previous bit. We start with prevBit initialized to -1 which means we haven't seen any bit yet. We loop until n becomes 0 and in each iteration we get the rightmost bit using bitwise AND with 1. If the current bit equals the previous bit then we immediately return false because the bits are not alternating. Otherwise we save the current bit as the previous bit for the next comparison and remove the rightmost bit by right shifting n by 1 position. If we complete the entire loop without finding two consecutive same bits then we return true indicating all bits are alternating. 👉 My Solution: https://lnkd.in/gQpKAMSi 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/grkpkPnR 💡 My thought process: The approach uses a greedy strategy. First, for each row in the grid, we count the number of trailing zeros by scanning from the last column to the left until we encounter a 1. We store these counts in a separate array called endZero because only the number of trailing zeros matters for checking whether a row meets the upper triangular condition. For a valid grid, at row index i, we must ensure there are at least n - i - 1 trailing zeros. This way, all elements above the main diagonal can remain zero. We go through each row from top to bottom. If the current row has enough trailing zeros (endZero[i] >= n - i - 1), we proceed to the next row. If not, we look below for the nearest row that meets the requirement. If we cannot find such a row, arranging the grid is impossible, so we return -1. If we do find a valid row, we simulate adjacent row swaps by continually swapping it upward until it reaches position i, counting each swap. This method ensures we use the minimum number of swaps by always choosing the closest valid row. 👉 My Solution: https://lnkd.in/gK4-jM2B 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

𝗗𝗮𝘆 38 𝗼𝗳 𝟯𝟲𝟬 days of LeetCode Challenge. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 :- 3721. Longest Balanced Subarray II You are given an integer array nums. A subarray is called balanced if the number of distinct even numbers in the subarray is equal to the number of distinct odd numbers. Return the length of the longest balanced subarray. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗶𝗻𝗸:- https://lnkd.in/djmqAqhd 𝗛𝗶𝗻𝘁:- 1.Think in terms of a sliding left boundary and maintain a prefix “balance” of distinct odd vs distinct even values; when the left boundary moves past the first occurrence of a value, adjust the balance only until its next occurrence. 2. Use a segment tree with lazy propagation over prefix balances so you can range-update efficiently and query the rightmost index where the balance becomes zero (i.e., a balanced subarray). 𝗚𝗶𝘁𝗵𝘂𝗯 𝗰𝗼𝗱𝗲:- https://lnkd.in/d-kxnEU4 #SoftwareEngineering #DSAJourney #Coding #LeetCode #DSA #TechCareers #SDE

𝗗𝗮𝘆 32 𝗼𝗳 𝟯𝟲𝟬 days of LeetCode Challenge. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 :- 3013. Divide an Array Into Subarrays With Minimum You are given a 0-indexed array of integers nums of length n, and two positive integers k and dist. The cost of an array is the value of its first element. For example, the cost of [1,2,3] is 1 while the cost of [3,4,1] is 3. You need to divide nums into k disjoint contiguous subarrays, such that the difference between the starting index of the second subarray and the starting index of the kth subarray should be less than or equal to dist. In other words, if you divide nums into the subarrays nums[0..(i1 - 1)], nums[i1..(i2 - 1)], ..., nums[ik-1..(n - 1)], then ik-1 - i1 <= dist. Return the minimum possible sum of the cost of these subarrays. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗶𝗻𝗸:- https://lnkd.in/gZAdyJcZ 𝗛𝗶𝗻𝘁:- For each index i, calculate a new circular index by shifting i by nums[i] steps, using modulo arithmetic to handle both positive and negative offsets. Populate the result array by fetching the value at each calculated index, ensuring the logic wraps around the array boundaries correctly. 𝗚𝗶𝘁𝗵𝘂𝗯 𝗰𝗼𝗱𝗲:- https://lnkd.in/giSfinNu #SoftwareEngineering #DSAJourney #Coding #LeetCode #DSA #TechCareers #SDE

🚀 LeetCode Journey – A Realization After 300 Questions After solving 300+ questions on LeetCode, I’ve learned something really important: 👉 Understanding patterns matters more than just solving questions. Earlier, my focus was only on increasing the question count. But over time, I realized that many problems are just different versions of the same core ideas—arrays, two pointers, sliding window, recursion, trees, DP, etc. Once you truly understand a pattern: You don’t panic when you see a new question You can break problems down faster You start thinking in solutions, not syntax Confidence improves automatically Now my approach is: ✔ Learn the pattern ✔ Understand why it works ✔ Practice variations ✔ Focus on clarity, not speed This shift has made problem-solving more enjoyable and meaningful. Still learning. Still improving. 💪 #LeetCode #DSA #ProblemSolving #CodingJourney #Consistency #SoftwareEngineering #LearningMindset