LeetCode Daily Challenge: Minimum Value with Bit Manipulation

🚀 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/dfbaS-gp 💡 My thought process: Looking at the constraints, it’s clear that this problem needs either sorting or binary search. The goal is to minimize the maximum pair sum. The key idea is to control how large any individual pair can get. A good strategy is to sort the array first. Once sorted, pairing the smallest element with the largest one helps balance the sums. If the smallest number were paired with anything other than the largest, the largest would then have to be paired with a larger number, which would increase the maximum pair sum even more. By consistently pairing the smallest remaining element with the largest remaining one, we make sure that no single pair becomes too large. This method spreads the values evenly across pairs and keeps the maximum pair sum as small as possible. 👉 My Solution: https://lnkd.in/dsTD-CFh 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

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gfWSucCh 💡 My thought process: This solution calculates the minimum cost to change a `source` string into a `target` string using allowed substring transformation rules that have specific costs. The transformations form a weighted directed graph, where each substring is a node, and each transformation is an edge with a cost. To manage indirect transformations effectively, Dijkstra’s algorithm finds the shortest path between two substrings. Since the same substring conversions can be requested multiple times, the algorithm saves the shortest-path results to avoid repeating graph searches. The overall solution employs top-down dynamic programming, with each state showing the minimum cost to transform the string starting from a given index. If the characters at the current position match, the algorithm moves forward at no cost. If they do not match, it examines all valid substring lengths and adds the transformation cost to the result of the remaining suffix. This mix of dynamic programming, shortest-path computation, and saved results ensures both accuracy and efficiency. 👉 My Solution: https://lnkd.in/gCv3cXCf 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/gxntCVfP 💡 My thought process: I used Dijkstra’s algorithm to find the minimum cost path because all edge weights are non-negative. To manage edge reversals, I modeled the graph by adding: - the original directed edge with cost w - a reverse edge with cost 2w, which represents the reversal operation This converts the problem into a standard shortest-path graph, eliminating the need for extra state handling. An adjacency list and a min-heap priority queue make traversal efficient, while a visited array tracks the minimum cost to reach each node. This method is straightforward, efficient, and works well for large graphs. 👉 My Solution: https://lnkd.in/gBkufJ5G 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

Proud to present our Compiler Construction project on Intermediate Code Generation (ICG) using Three Address Code (TAC). Through this project, we explored how high-level conditional statements such as if and if–else are translated into intermediate representations using labels, jumps, and backpatching techniques. It significantly improved our understanding of control flow representation, execution paths, and the internal working of compilers in a machine-independent way. I am truly grateful to our respected teacher Zobia Zafar for the guidance and insightful feedback. Special thanks to my teammates Ali Ashiq and Syed Taha Nasir for their dedication and teamwork, which made this project a valuable learning experience. #CompilerConstruction #CompilerDesign #IntermediateCodeGeneration #ThreeAddressCode #Coding #ComputerScience #ConditionalExpressions

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/djbQcgTX 💡 My thought process: Problem is same as the before, the constraints are just a bit higher. We store the current values in temp (as long long) and simulate deletions using prevIndex/nextIndex as a doubly linked list, so after merging/removing an element we can find and update neighbors in O(1) without shifting the array. All current adjacent pairs are kept in an ordered set as (pairSum, leftIndex), which gives the minimum-sum adjacent pair in O(1) (begin()) and supports updates in O(log n). When we merge the chosen pair (first, second), only pairs involving first_left–first and second–second_right can change, so we erase those (if they exist), relink pointers to remove second, update temp[first] += temp[second], and insert the new affected pairs. We also maintain badPairs (count of adjacent inversions) and update it using only local comparisons around the merge boundary, since no other adjacencies are affected. Bad pairs will never increase than n-1. 👉 My Solution: https://lnkd.in/dcxVVSjV 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/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