LeetCode Challenge: Lambda Function for Sorting by Set Bits

🚀 Day 28/60 — LeetCode Discipline Problem Solved: Number of 1 Bits (Hamming Weight) Difficulty: Easy Today’s problem explored the fundamentals of bit manipulation, one of the most powerful and efficient areas in programming. The task was to count the number of set bits (1s) in the binary representation of a number. Instead of converting the number to a binary string, the solution uses bitwise operations to efficiently extract each bit. This approach highlights how low-level operations can lead to high-performance solutions with minimal overhead. 💡 Focus Areas: • Strengthened bit manipulation concepts • Practiced use of bitwise AND (&) • Understood right shift operations (>>>) • Improved efficiency by avoiding extra space • Built deeper understanding of binary representation ⚡ Performance Highlight: Achieved 0 ms runtime (100% performance). Mastering bits is like learning the language of machines — once you understand it, everything becomes faster and sharper. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #BitManipulation #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering #Java #Developers #TechGrowth #Consistency #LearnToCode

🚀 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

🚀 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

𝗗𝗮𝘆 52 𝗼𝗳 𝟯𝟲𝟬 days of LeetCode Challenge. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 :- 1356. Sort Integers by The Number of 1 Bits You are given an integer array arr. Sort the integers in the array in ascending order by the number of 1's in their binary representation and in case of two or more integers have the same number of 1's you have to sort them in ascending order. Return the array after sorting it. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗶𝗻𝗸:- https://lnkd.in/g7rb8s8j 𝗛𝗶𝗻𝘁:- 1. write a function to find no of 1 bits in a number 2. Pass it to the comparator in a sort method. 𝗚𝗶𝘁𝗵𝘂𝗯 𝗰𝗼𝗱𝗲:- https://lnkd.in/gQ73xHu9 #SoftwareEngineering #DSAJourney #Coding #LeetCode #DSA #TechCareers #SDE

🚀 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

Day 98 of my 100 Days of LeetCode Challenge 🚀 Solved Longest Increasing Subsequence (LIS) — a classic Dynamic Programming + Binary Search problem. The task is to find the length of the longest strictly increasing subsequence in an array. Approach used in my solution (Optimized O(n log n)): • Maintained a list res to store the smallest possible tail value for increasing subsequences of different lengths • If the current number is greater than the last element in res, append it • Otherwise, use binary search to find the correct position and replace the element • The size of res at the end gives the length of LIS Important Insight: The list does not store the actual LIS, but it maintains optimal subsequence tails to guarantee maximum possible length. Time Complexity: O(n log n) Space Complexity: O(n) This problem is a huge milestone in understanding advanced DP optimization techniques. #100DaysOfCode #100DaysOfLeetCode #LeetCode #DynamicProgramming #BinarySearch #LIS #Java #DSA #Algorithms #CodingJourney

🚀 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/gDzrB9cW 💡 My thought process: This solution creates the binary string step by step, starting from "0". For each level from 2 to n, it forms a new string by taking the previous string, inserting "1" in the middle, and then adding the reversed and bit-flipped version of the previous string (0 changes to 1 and 1 changes to 0). After each construction, it checks if the string has reached or exceeded the required k position. If it has, it immediately returns the k-th character. This approach prevents any extra construction once the answer is found. 👉 My Solution: https://lnkd.in/gFXgkTpm 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 2 of #100DaysOfCode 📌 Reverse Integer 🔗 https://lnkd.in/gtKB8Mdi ✅ Accepted (All test cases passed) ⚡ Runtime: 0 ms 🧠 Approach: Reversed the number digit by digit using modulo and division, while handling overflow conditions carefully. ⏱️ Time: O(log n) | 📦 Space: O(1) 💡 Learning: Handling edge cases like overflow is the key part of this problem. #leetcode #dsa #cpp #coding #developers

🚀 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