Service Lane Challenge on HackerRank: Simplifying Logic

Day 1 of #30DaysOfLeetCode Solved #2. Add Two Numbers on LeetCode using C. Approach: • Used Linked List traversal to process both numbers digit by digit • Added digits from both lists along with a carry value • Created new nodes dynamically to store each result digit • Handled cases where lists have different lengths • Continued the loop until both lists and carry were processed Performance: • Runtime: 0 ms (Beats 100% submissions) • Memory: 13.50 MB (Beats 8.30% submissions) Key Learning: • Strengthened understanding of Linked Lists and pointer manipulation • Learned how to manage carry during digit addition • Improved problem-solving skills with dynamic node creation Learning one problem every day 💻🔥 #30DaysOfCode #LeetCode #CProgramming #DSA #LinkedList #ProblemSolving

🚀 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 4/100 — LeetCode Challenge It looks like a very simple problem… and honestly, it is. But explaining it clearly is what matters. Solved Maximum Consecutive Ones At first, a brute force idea comes to mind: *Start from every index *Count consecutive 1s *Track the maximum But that leads to O(n²) time, which is unnecessary. 👉 Instead, I used a much cleaner approach: *Traverse the array once *Maintain a current count of consecutive 1s *Reset when encountering 0 *Keep updating the maximum 💡 Key Insight: We don’t need to check all subarrays — just track the current streak. 🧠 Time Complexity: O(n) 💾 Space Complexity: O(1) Simple problem, but a good reminder that even easy questions can test clarity of thinking. #LeetCode #DSA #100DaysOfCode #Cpp #ProblemSolving #CodingJourney

Day 6 of My LeetCode Consistency Journey Today I solved Longest Consecutive Sequence (LeetCode 128). At first, my instinct was to sort the array and then check for consecutive elements. But sorting leads to O(n log n) time complexity, while the problem expects an O(n) solution. After thinking through it, I realized the key idea is to use hashing. 💡 Main insight: A number should only start a sequence if (num - 1) does not exist. This ensures we only start counting from the beginning of a sequence and avoid unnecessary checks. From there, the sequence can be expanded using num + 1 until the chain breaks. Key learnings from today: • Using a hash set for O(1) lookup can drastically improve performance. • Identifying the start of a sequence avoids redundant computation. • Small implementation details matter — like not modifying the loop variable during iteration. This problem was a great reminder that sometimes the real challenge is recognizing the pattern, not writing the code. Day by day, the goal remains the same: consistency and better problem-solving thinking. #LeetCode #DSA #ProblemSolving #CodingJourney #Consistency

🚀 Day 77 of LeetCode Problem Solving Journey — 100 Days LeetCode Challenge Today, I solved LeetCode #141 — Linked List Cycle using C++, under the guidance of Trainer NEKAL SINGH SALARIA Singh at REGex Software Services. 🔍 Problem Summary: Given the head of a linked list, determine if the list contains a cycle. A cycle exists if a node can be revisited by continuously following the next pointer. 🧠 Approach Used (Floyd’s Cycle Detection - Two Pointers): I used the slow and fast pointer technique: Initialize two pointers → slow and fast Move slow by one step and fast by two steps If there is a cycle → both pointers will eventually meet If fast reaches NULL → no cycle exists This approach efficiently detects cycles without extra space. 📚 Key Learnings of the Day ✔ Floyd’s algorithm is efficient for cycle detection ✔ Fast pointer helps identify loops quickly ✔ No extra memory is required ✔ Pointer movement patterns are crucial in linked list problems ⏱ Complexity • Time Complexity: O(n) • Space Complexity: O(1) 💡 Optimization Insight: Using a hash set is another approach but requires O(n) space, whereas the two-pointer method is optimal with constant space. Consistency is paying off — see you on Day 78 🚀 #Day77 #100DaysLeetCodeChallenge #LeetCode #RegexSoftwareServices #NekalSingh #ProblemSolving #DSA #CPlusPlus #CodingChallenge #ProgrammingJourney #LinkedList #KeepGrowing

🚀 Day 6/50 – LeetCode Challenge 🧩 Problem #123 – Best Time to Buy and Sell Stock III Today’s problem was about maximizing profit from stock trading with constraints — a great exercise in Dynamic Programming and decision-making. 📌 Problem Summary: Given an array of stock prices, find the maximum profit you can achieve with at most two transactions. You cannot hold multiple stocks at the same time — meaning you must sell before buying again. 🔍 Approach Used: Tracked: ✔️ First Buy ✔️ First Sell ✔️ Second Buy ✔️ Second Sell Updated values while iterating through the price list Used optimized state transitions instead of brute force This allows us to simulate the best possible outcome of two transactions efficiently. ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) 💡 Key Learning: ✔️ Understanding multi-transaction constraints ✔️ Applying Dynamic Programming logic ✔️ State tracking for optimal decisions ✔️ Optimizing without using extra memory A great problem that builds strong intuition for real-world optimization scenarios. Consistency leads to mastery 🚀 🔗 Problem Link: https://lnkd.in/gFBHphPb #50DaysOfLeetCode #LeetCode #DSA #DynamicProgramming #ProblemSolving #CodingJourney #FutureAIEngineer #Consistency

🧩 LeetCode Challenge – Day 77 ✅ Today’s problem was more about careful condition handling and implementation than applying a heavy algorithm. 🔗 LeetCode 3461 The challenge required translating the problem statement precisely into code and making sure all constraints were handled correctly during iteration. 💡 Key Takeaways: • Clear understanding of constraints is crucial for correctness • Simple logic can fail if edge cases are ignored • Writing clean and structured conditions improves reliability #Day77 #LeetCodeChallenge #365DaysOfCode #DSA #CodingJourney #ProblemSolving #Arrays

Day 23 of solving LeetCode 💻🧠 Today I solved “Counting Bits” (LeetCode 338). The task was to return an array where each index "i" contains the number of 1s in the binary representation of "i". I used Brian Kernighan’s Algorithm, which removes the lowest set bit using "n & (n-1)" until the number becomes 0. This efficiently counts the number of set bits in each number. Key learning today: • Bit manipulation can significantly optimize counting operations • "n & (n-1)" is a powerful trick to remove the lowest set bit • Understanding binary operations helps write more efficient algorithms Another small step forward in the journey of becoming a better problem solver. 🚀 #Day23 #LeetCode #DSA #BitManipulation #CodingJourney #ProblemSolving

🚀 LeetCode Problem I Enjoyed Solving Today I solved one of my favorite grid problems from LeetCode: "Minimum Swaps to Arrange a Binary Grid". Problem Idea💡 We are given an n × n binary grid and need to arrange the rows so that for every row i, there are at least n - i - 1 trailing zeros. We can only swap adjacent rows, and the goal is to minimize the number of swaps. 🔍 Key steps Instead of manipulating the entire grid repeatedly, we can: Compute the number of trailing zeros in each row. For row i, we need at least n - i - 1 trailing zeros. Find a row below that satisfies this condition. Bubble it up using adjacent swaps. If no such row exists → return -1. 💡 Why I liked this problem This question nicely combines: Greedy thinking Array manipulation Simulation of swaps It also teaches how precomputing useful metrics (like trailing zeros) can simplify a complex problem. Problems like this remind me why I enjoy problem solving. Happy Coding!!✌️ #LeetCode #DataStructures #Algorithms #DSA #CodingInterview

🚀 Day 70 of LeetCode Problem Solving Journey — 100 Days LeetCode Challenge Today, I solved LeetCode #507 — Perfect Number using C++, under the guidance of Trainer NEKAL SINGH SALARIA Singh at REGex Software Services. 🔍 Problem Summary: A perfect number is a positive integer that is equal to the sum of its positive divisors excluding the number itself. Given an integer num, return true if it is a perfect number, otherwise return false. 🧠 Approach Used (Divisor Summation): I calculated the sum of all divisors except the number itself: Traverse from 1 to num/2 Check if the number divides num evenly If yes → add it to the sum After the loop, compare the sum with num If both are equal → it is a perfect number This approach directly verifies the definition of a perfect number. 📚 Key Learnings of the Day ✔ Perfect numbers are equal to the sum of their proper divisors ✔ Checking divisors is a common technique in number theory problems ✔ Understanding mathematical definitions simplifies coding logic ✔ Brute-force solutions are sometimes useful as a starting point ⏱ Complexity • Time Complexity: O(n) • Space Complexity: O(1) 💡 Optimization Insight: The loop can be optimized by checking divisors only up to √n, which reduces the time complexity significantly. Another step forward in the challenge — see you on Day 71 🚀 #Day70 #100DaysLeetCodeChallenge #LeetCode #RegexSoftwareServices #NekalSingh #ProblemSolving #DSA #CPlusPlus #CodingChallenge #ProgrammingJourney #Math #KeepGrowing