LeetCode Daily Challenge: Minimizing Maximum Pair Sum with Sorting

🚀 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/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

𝗗𝗮𝘆 40 𝗼𝗳 𝟯𝟲𝟬 days of LeetCode Challenge. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 :- 3714. Longest Balanced Substring II You are given a string s consisting only of the characters 'a', 'b', and 'c'. A substring of s is called balanced if all distinct characters in the substring appear the same number of times. Return the length of the longest balanced substring of s. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗶𝗻𝗸:- https://lnkd.in/dqJiZzXm 𝗛𝗶𝗻𝘁:- 1. Break the problem by number of distinct characters: handle single-character runs, then for two characters use prefix-difference (count₁ − count₂) with a hashmap, and for three characters track two independent differences. 2. Whenever the same difference state reappears, the substring between those indices has equal counts, so update the maximum length. 𝗚𝗶𝘁𝗵𝘂𝗯 𝗰𝗼𝗱𝗲:- https://lnkd.in/dHNThed3 #SoftwareEngineering #DSAJourney #Coding #LeetCode #DSA #TechCareers #SDE

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gx3m6RKt 💡 My thought process: The problem changes each element by moving a specific number of steps in a circular array. For each index i, we move nums[i] steps forward if it's positive, or backward if it's negative. The result at index i is the value we land on. We treat positive and negative steps differently. In both situations, we first calculate remaining = steps % n to remove full cycles since moving n steps in a circular array brings us back to the same position. For negative steps (moving backward), we check if remaining <= i. If this is true, we can move backward within the current array without wrapping, so result[i] = nums[i - remaining]. If it's false, we need to wrap around to the end of the array. After moving i steps backward, we reach index 0. Then, we have remaining - i - 1 more steps to go backward from the end. Starting from the last index n - 1 and moving remaining - i - 1 steps backward gives us index n - 1 - (remaining - i - 1), which simplifies to the formula used. For positive steps (moving forward), we check if remaining <= n - 1 - i. If this is true, we can move forward without wrapping, so result[i] = nums[i + remaining]. If it's false, we wrap around to the beginning. After moving n - 1 - i steps forward, we reach the last index. Then, we have remaining - (n - 1 - i) - 1 more steps to go forward from index 0, leading us to the formula used. The main insight is that after taking modulo n, we only need to address cases where we wrap around once, either from the beginning to the end or from the end to the beginning. 👉 My Solution: https://lnkd.in/ghMYnR3D 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

Here are some platforms to practice your coding skills: 1. LeetCode 2. HackerRank 3. CodeSignal 4. CodeChef 5. TopCoder 6. Frontend Mentor 7. freeCodeCamp 8. CodePen 9. GeeksforGeeks 10. W3Schools 11. Scrimba 12. Coderbyte 13. Project Euler 14. SoloLearn 15. Codewars 16. DevChallenges 17. The Odin Project 18. Practice.dev 19. Pluralsight 20. CodeCombat 21. AlgoExpert 22. Programiz 23. Hack The Box 24. Edabit 25. Exercism Explore these resources to enhance your coding abilities and tackle various challenges.

LeetCode POTD | Minimize–Maximum Pair Sum in an Array So the goal here is simple minimize the maximum pair sum. The only way this works is when we pair the largest number with the smallest one 🤝 this balances the pair sums across all elements. Since n is even, we’ll always be able to form valid pairs. 💭 Thought process I started by thinking: I need to balance the sums but how do I ensure that? Sorting felt like the right move 🔍 because it lets me pick one element from the start and one from the end. I kept pairing like this until the left pointer crossed the right pointer, which means all elements are paired ✨ While forming each pair, I tracked the maximum pair sum using a variable maxi. At the end, maxi gives the answer, the minimum possible maximum among all pair sums 🎯 ⏱️ Overall time complexity: O(n log n) #problem_solving #dsa #leetcode #consistency #interview_prep #programming #learnInPublic #womenInTech 

🚀 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

Day 12 | LeetCode Progress 🚀 Today, I worked on LeetCode 401 – Binary Watch, a problem that focuses on bit manipulation and binary representation. 🧠 Problem Overview A binary watch uses: 4 LEDs to represent hours (0–11) 6 LEDs to represent minutes (0–59) The task was to return all possible valid times where the total number of LEDs turned on equals a given number. 💡 Key Learnings Applied bit manipulation techniques to count set bits efficiently using __builtin_popcount() in C++. Strengthened understanding of binary representation in practical scenarios. Reinforced the importance of clean formatting and edge case handling (e.g., leading zero in minutes, no leading zero in hours). Learned that sometimes a well-structured brute-force approach is both optimal and readable. 🔍 Approach Iterated through all valid hour (0–11) and minute (0–59) combinations and selected those where the total number of set bits matched the input condition. Time Complexity: O(1) (since the search space is fixed at 720 combinations) Consistent practice is helping me improve my logical thinking and problem-solving efficiency every day. 📈 Day 12/100 — Building discipline through daily DSA practice. #100DaysOfCode #DSA #CPlusPlus #LeetCode #ProblemSolving #SoftwareEngineering #ComputerScience

𝗗𝗮𝘆 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