LeetCode Challenge: Binary Substrings with Sliding Window Approach

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gJUJE-YA 💡 My thought process: The provided code uses a backtracking approach to generate all possible strings of length n that satisfy the happy string condition: no two adjacent characters can be identical. The algorithm builds these strings in lexicographical order by exploring 'a', 'b', and then 'c'. The main logic is in the solve function, which acts as a recursive explorer. It takes the current string and the number of characters left to add. At each step, it tries appending 'a', 'b', and 'c'. Before adding a character, it checks for safety by ensuring that the character is not the same as the last one in the string. This prevents violating the happy constraint. Once a character is added, the function calls itself with n-1 to fill the next position. After finishing that branch of the search, it removes the character to backtrack and try the next alphabetical option. In the getHappyString function, the process starts by launching three separate recursive chains: one with 'a', one with 'b', and one with 'c'. Since the loops and initial calls follow alphabetical order, the allStrings vector is filled with every valid combination in sorted order. Finally, the code checks if the requested index k exists within the total count of generated strings. If k is within bounds, it returns the string at index k-1; otherwise, it returns an empty string. 👉 My Solution: https://lnkd.in/gKDqj84r 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/g5TWhSTr 💡 My thought process: The idea is to build the binary array recursively while tracking the remaining number of `0`s and `1`s, the last placed element, and the current streak of that element. A state `dp[zero][one][last][cons]` shows how many valid ways there are to form the remaining array when `zero` zeros and `one` ones are left, the previous element was `last`, and it has appeared `cons` times in a row. From each state, the recursion tries to add either `0` or `1`. A `0` can be added if there are remaining zeros and either the last element was different or the consecutive count has not gone over the set `limit`. The same applies when adding `1`. If both counts reach zero, a valid stable array is formed. Memoization saves the result of each state in the `dp` table to prevent recomputing overlapping subproblems. The final result is found by starting the recursion with either `0` or `1` as the first element (if available) and adding up the valid configurations. All computations are done modulo (10^9 + 7) to manage large counts effectively. 👉 My Solution: https://lnkd.in/g8Tr9MEc 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: The brute force method checks all possible rotations of the binary string by moving the first character to the end repeatedly. For each rotated string, it counts the number of mismatches needed to create an alternating pattern that starts with 1. The opposite alternating pattern, which starts with 0, would require different changes. The method takes the minimum of the two counts for each rotation and returns the lowest value overall. The optimized method does not generate all rotations. Instead, it doubles the string and uses a sliding window of size n to represent every possible rotation. It keeps track of the mismatch count for forming an alternating pattern that starts with 1. As the window slides, it updates this count by subtracting the contribution of the character that leaves the window and adding the incoming character. At each step, it compares both alternating patterns to find the minimum number of flips needed. 👉 My Solution: https://lnkd.in/gP2FWVYP 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/gwdQDKx4 💡 My thought process: The code calculates the sum of all root-to-leaf paths in a binary tree where each node contains either 0 or 1. Each path from root to leaf represents a binary number. The goal is to convert these binary numbers to decimal and return their total sum. The helper function solve performs a depth-first search. It builds a binary string along the current path by adding the node’s value. When a leaf node is reached, the binary string is saved in a vector. The recursion continues for the left and right children until all root-to-leaf paths are explored. In sumRootToLeaf, after collecting all binary path strings, each string is converted to its decimal equivalent using bit shifting. For each character, its value is multiplied by the corresponding power of 2 and added to a running total. The final result is the sum of all converted values. The time complexity is linear based on the number of nodes, and additional space is needed for recursion and storing path strings. 👉 My Solution: https://lnkd.in/gwAHXfX6 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/grtpbGeG 💡 My thought process: A counter tracks the number of operations. The loop runs until the string length becomes 1, which means the number has been reduced to 1. If the last character of the string is 0, the number is even in binary. Dividing by 2 is the same as removing the last bit, so pop_back removes the trailing 0. If the last character is 1, the number is odd and needs to be increased by 1. To simulate binary addition, the code goes through the string from right to left. All consecutive trailing 1 characters are changed to 0 to manage the carry. When a 0 is found, it becomes 1, and the carry stops. If the loop finishes without finding a 0, it means the string was made entirely of 1 characters. Adding 1 then results in an extra leading 1, which is added by putting 1 at the front of the string. Each iteration counts as one step. This process continues until only one character is left. The function finally returns the total number of steps needed to reduce the binary number to 1. 👉 My Solution: https://lnkd.in/guc6fia6 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

🚀 Today’s LeetCode Problem — Sort Integers by Number of 1 Bits Let’s solve today’s LC in story mode 🎭 Imagine numbers are contestants in a Binary Costume Contest. Today’s contestants: 👉 [5, 3, 7] But this contest has a twist 👇 👨⚖️ The judge doesn’t care about the number itself first. He cares about… 🎈 How many 1s are in their binary costume 🎭 What Are They Wearing? 🔹 5 → 101 → 🎈🎈 (2 ones) 🔹 3 → 011 → 🎈🎈 (2 ones) 🔹 7 → 111 → 🎈🎈🎈 (3 ones) 🏆 Judge’s Rules 1️⃣ Fewer 1s → Higher priority 2️⃣ Same number of 1s → Smaller number wins 👉 Step 1: 3 & 5 → 2 ones 7 → 3 ones So 7 goes last. 👉 Step 2: Tie between 3 and 5 Smaller number first → 3 before 5 ✅ Final Answer: [3, 5, 7] 💡 How I Solved It I implemented this using: 🔹 Brian Kernighan’s Algorithm for efficient bit counting 🔹 TreeMap to maintain sorted order by bit count + value 🔹 Also compared with built-in bitCount() + custom comparator sorting This ensures: ✔ Efficient bit counting ✔ Clean tie-breaking ✔ Optimal sorting logic If you’re interested, I’ve pushed the complete solution (Kernighan + TreeMap + built-in approach) : https://lnkd.in/gV9HZ9w4 👨💻 Would love feedback from fellow developers 🙌 #LeetCode #DSA #Java #ProblemSolving #CodingJourney #100DaysOfCode #Tech #SoftwareEngineering

Day 41 on LeetCode — Count the Number of Consistent Strings ✅ Today’s problem focused on hash maps and efficient character validation in strings. 🔹 Approach Used in My Solution The idea was to first store all allowed characters in a hash map for quick lookup. After that, I iterated through each word and checked whether every character exists in the allowed set. Key steps in the logic: • Store characters from the allowed string in an unordered_map • Traverse each word in the words array • Check every character of the word against the map • If a character is not allowed, mark the word as invalid • Count only the words where all characters are valid This approach keeps the lookup efficient and the implementation straightforward. ⚡ Complexity: • Time Complexity: O(n × m) (n = number of words, m = average length of each word) • Space Complexity: O(1) (since the character set is limited) 💡 Key Takeaways: • Practiced using hash maps for fast membership checks • Strengthened understanding of string traversal and validation • Reinforced building clean and readable solutions for character-based problems #LeetCode #DSA #Algorithms #DataStructures #HashMap #Strings #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 22/60 — LeetCode Discipline Problem Solved: Reverse Integer (Revision) Difficulty: Medium Today’s practice focused on revisiting the classic integer manipulation problem — Reverse Integer. At first glance the problem appears straightforward: reverse the digits of a number. However, the real challenge lies in carefully handling edge cases such as integer overflow and maintaining correctness within the 32-bit signed integer range. Instead of using built-in conversions, the solution iteratively extracts digits and rebuilds the reversed number while ensuring that the result stays within valid bounds. 💡 Focus Areas: • Strengthened digit extraction using modulo operations • Practiced iterative number reconstruction • Handled integer overflow edge cases • Reinforced careful boundary condition checks • Focused on writing efficient and clean logic ⚡ Performance Highlight: Achieved ~99.9% runtime efficiency on submission. Revisiting foundational problems like this continues to sharpen attention to detail and improve algorithmic discipline. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers #Java