LeetCode Challenge: Binary String Generation and Removal

🚀 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

🚀 Do you solve array problems randomly… or with a plan? Recently, I worked on 16 array problems in Java but this time, I didn’t just jump from one question to another. I followed a clear approach. Instead of solving randomly, I broke it down like this: 🔹 Problems 1–6 → Simple array traversal (Counting, sum, product, basic operations) 🔹 Problems 7–12 → Min–Max tracking (Largest, smallest, kth elements, second largest/smallest) 🔹 Problems 13–16 → Array transformation (Two-pointer approach) (Copy, reverse, left rotation, right rotation) At first, arrays felt easy… just loops. But while solving these step by step, I realized something 👉 The real challenge is not coding, it’s how you approach the problem. This practice helped me: ✔ Think more clearly before writing code ✔ Understand when to use which approach ✔ Improve my problem-solving flow ✔ Build confidence in handling DSA basics Honestly, this didn’t just improve my coding… it changed the way I look at problems now. Grateful for the learning environment at Global Quest Technologies and for the constant guidance from sir G.R NARENDRA REDDY (CEO, GQT). #Java #DSA #Arrays #CodingPractice #ProblemSolving #LearningJourney #GlobalQuestTechnologies

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gBvd5iWy 💡 My thought process: For this question, I am precalculating the total sum of the grid and row-wise and column-wise sums. Store the precalculated values in a vector and then simply do a cumulative sum over the vector. If the cumulative sum equals the total sum - cumulative sum, this means that a single cut is possible to split the array. The calculation part is done in another method, and I simply call the method twice for row-wise check and then column-wise. 👉 My Solution: https://lnkd.in/gNYsk6iz 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

🔥 𝗛𝗼𝘄 𝗜 𝗦𝘁𝗼𝗽𝗽𝗲𝗱 𝗕𝗿𝘂𝘁𝗲 𝗙𝗼𝗿𝗰𝗶𝗻𝗴 𝗡𝘂𝗺𝗯𝗲𝗿𝘀 𝗮𝗻𝗱 𝗦𝘁𝗮𝗿𝘁𝗲𝗱 𝗧𝗵𝗶𝗻𝗸𝗶𝗻𝗴 𝗶𝗻 𝗗𝗶𝗴𝗶𝘁𝘀 Today’s problem looked simple: 𝗖𝗼𝘂𝗻𝘁 𝗵𝗼𝘄 𝗺𝗮𝗻𝘆 𝗻𝘂𝗺𝗯𝗲𝗿𝘀 𝗶𝗻 [𝗹𝗼𝘄, 𝗵𝗶𝗴𝗵] 𝗮𝗿𝗲 𝗕𝗮𝗹𝗮𝗻𝗰𝗲𝗱. A number is balanced if it has 𝗮𝘁 𝗹𝗲𝗮𝘀𝘁 𝘁𝘄𝗼 𝗱𝗶𝗴𝗶𝘁𝘀 and the 𝘀𝘂𝗺 𝗼𝗳 𝗱𝗶𝗴𝗶𝘁𝘀 𝗮𝘁 𝗼𝗱𝗱 𝗽𝗼𝘀𝗶𝘁𝗶𝗼𝗻𝘀 𝗲𝗾𝘂𝗮𝗹𝘀 𝘁𝗵𝗲 𝘀𝘂𝗺 𝗮𝘁 𝗲𝘃𝗲𝗻 𝗽𝗼𝘀𝗶𝘁𝗶𝗼𝗻𝘀. A brute force check over the range isn’t practical for large limits — this is where 𝗗𝗶𝗴𝗶𝘁 𝗗𝗣 comes in. 🧠 𝗧𝘂𝗿𝗻𝗶𝗻𝗴 𝗧𝘄𝗼 𝗦𝘂𝗺𝘀 𝗶𝗻𝘁𝗼 𝗢𝗻𝗲 𝗩𝗮𝗹𝘂𝗲 Instead of tracking two sums, I tracked: balance = (odd position sum) − (even position sum) If this balance becomes 0 at the end, the number is balanced. 🧩 𝗧𝗵𝗲 𝗖𝗹𝗮𝘀𝘀𝗶𝗰 𝗥𝗮𝗻𝗴𝗲 𝗧𝗿𝗶𝗰𝗸 answer = solve(high) − solve(low − 1) Now the task reduces to counting balanced numbers from 0 to a given number. ⚙️ 𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝘁𝗵𝗲 𝗡𝘂𝗺𝗯𝗲𝗿 𝗗𝗶𝗴𝗶𝘁 𝗯𝘆 𝗗𝗶𝗴𝗶𝘁 While forming the number left to right, I tracked: 1. digit index 2. current balance 3. whether we are under prefix restriction (tight) DP state: dp[idx][balance][tight] An OFFSET handles negative balances. 💡 𝗪𝗵𝗮𝘁 𝗧𝗵𝗶𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗧𝗮𝘂𝗴𝗵𝘁 𝗠𝗲 Converting conditions into a running state Thinking in terms of digit positions, not full numbers Understanding how the tight flag controls the search space Why Digit DP is powerful for large range constraints This problem helped me truly understand Digit DP by walking through the logic step by step. #DataStructures #Coding #Programming #Java #Recursion #Memoization #Tech #SoftwareEngineering #Developer #LearnInPublic #100DaysOfCode #CodeNewbie #CompetitiveCoding #CodeDaily #InterviewPrep #LeetCode #GeeksforGeeks #ComputerScience #ProblemSolvingSkills #CodingJourney

My thoughts on Claude Code for platforms that I have 0 experience in. To be more specific, I learned to program using C++ in Qt and I have dabbles in python coding for my studies (literally as a fancy calculator) I have been using Claude.ai to plan and to help create the prompts and structure etc. and Claude code to build the projects, largely unsupervised. Then when it eventually hits that critical mass (usually with some monolith .py or .js file, then I have claude.ai explain the entire flow of the project as if it is in a .h file with members and functions. Now I can apply my own data structure and design patterns and design it from the ground up in such a way that I can find things when they break. It's not a very time efficient way to do this, but I am finding it very helpful in rapid testing other concepts like pip and npm and even online tools like netlify and aplify. Now when I have to wait for Claude to get his mandatory rest, I can climb into the code and keep working in react.vite or ktinker. What's my next platform? #REACT #VITE #KTINKER

🚀 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

Can you spot what happens here? 👇 Set<Integer> set = new HashSet<>(); set.add(1); set.add(1); set.add(2); System.out.println(set.size()); 👉 Output: 2 ✅ Reason? Set does not allow duplicate values. So even though we added 1 twice, it gets stored only once. 💡 Simple concept, but easy to overlook. Have you used Set in your projects? 👇 #Java #CoreJava #Programming #BackendDeveloper #Coding #TechLearning

#100DaysOfLeetcode journey 🚀 Day 48/100 — Reversing LCP Matrices! Today’s Problem: 2573. Find the String with LCP (Hard) 🔹 The Goal: Given an $n \times n$ matrix representing the Longest Common Prefix (LCP) for every possible pair of suffixes, reconstruct the lexicographically smallest string that generates this exact matrix. 🔹 The Insight: This problem is a beautiful mix of Greedy Construction and Dynamic Programming. The "lexicographically smallest" constraint tells us exactly how to group indices. If lcp[i][j] > 0, indices $i$ and $j$ must share the same character. By processing indices from left to right and assigning the smallest available letter ('a' through 'z'), we build our candidate string. 🔹 The Logic: Grouping: We use the matrix to cluster indices that are forced to be identical. Transitivity Check: The matrix might be a "trap"—it could define relationships that are logically impossible. Verification: The only way to be sure is a full $O(n^2)$ verification. We use the DP relation LCP[i][j] = (s[i] == s[j]) ? LCP[i+1][j+1] + 1 : 0 to regenerate the matrix from our candidate string and compare it to the input. ✨ Achievement: Day 48! Tackled a Hard-level string reconstruction problem. It’s a fantastic exercise in understanding the internal properties of LCP arrays and how to use greedy logic to satisfy lexicographical requirements. 🔍 Steps followed: ✔ Greedy Character Assignment: Clustered indices based on positive LCP values. ✔ Alphabetical Minimization: Prioritized 'a' for the earliest possible unassigned groups. ✔ $O(n^2)$ Consistency Validation: Verified every single cell in the matrix using DP to ensure the matrix was valid. 🔧 Complexity Analysis: Time Complexity: $O(n^2)$ Space Complexity: $O(n)$ 48 days down! The intersection of string algorithms and mathematical consistency is where the most rewarding challenges live. 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #StringAlgorithms #DP #LCP #Day48

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/eC4nGYRx 💡 My thought process: The code checks if two strings can be made equal by swapping characters only between indices that have the same parity. This means characters at even indices can only move among even positions, while those at odd indices can only move among odd positions. To manage this, the code first goes through the first string and records the frequency of characters separately for even and odd indices using two unordered maps. This captures how many times each character appears in each parity group. Next, it goes through the second string. For each character, it checks if it exists in the corresponding parity map. If the current index is even, it checks the even map; if odd, it checks the odd map. When it finds a match, it decreases the frequency and removes the entry from the map if it reaches zero. If a character isn’t found in the required parity map, the function returns false right away. This approach is necessary because checking overall character frequency isn’t enough due to the swapping restrictions. Since characters can’t move between even and odd indices, both parity groups must have identical frequency distributions in both strings. Using separate maps ensures that this rule is enforced. If all characters from the second string match with the corresponding parity groups from the first string, the function returns true, confirming that the transformation is possible. 👉 My Solution: https://lnkd.in/erhV7_HJ 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