Crushing LeetCode's Reverse Linked List Challenge in 0ms

Here : https://lnkd.in/gZNV5bdp Just went LIVE for 1 full hour 🚀 Built and implemented all core Entity classes for a Lovable-style clone, purely from a system design perspective — no shortcuts, no boilerplate thinking. This session focused on: Translating system design → domain models Designing entities the way real products need Laying a scalable foundation before writing services or APIs Building in public. Learning by doing. Explaining while coding. More LIVE backend builds coming soon 👨💻🔥 #SystemDesign #BackendDevelopment #SpringBoot #Java #BuildInPublic #SoftwareArchitecture #LearningInPublic

Small code style decisions matter more than we think. One habit I’ve consciously adopted in my backend work is avoiding wildcard imports and keeping imports explicit. Why it matters: - Improves readability for reviewers - Makes dependencies clear at a glance - Reduces accidental coupling - Avoids surprises during refactoring - Keeps diffs clean and predictable Tools help, such as IDEs and linters, but consistency is a team discipline. Over time, I’ve realized that senior engineering isn’t about writing more code; it’s about writing code that’s easier to understand, review, and maintain. #Java #BackendDevelopment #CleanCode #SoftwareEngineering #CodeQuality #EngineeringPractices #LearningInPublic

🚀 LinkedIn Post – Day 2 Day 2 of My LeetCode Journey 🚀 Today I solved LeetCode – Summary Ranges problem. 🔹 Problem Summary: Given a sorted array of unique integers, return the smallest list of ranges that cover all the numbers exactly. Example: Input: [0,1,2,4,5,7] Output: ["0->2","4->5","7"] 🔹 Approach Used: Iterative Range Tracking 💡 Idea: Start building a range using StringBuilder Traverse the array and check: If current number is consecutive → extend range If not → close previous range and start a new one Handle the last range carefully after the loop 🔹 Time Complexity: O(n) 🔹 Space Complexity: O(1) (excluding output list) 🔹 What I Learned: Edge case handling is crucial (especially the last element) Tracking consecutive sequences simplifies interval problems Clean logic > complicated conditions 2 days in. Consistency mode: ON 🔥 #Day2 #LeetCode #DSA #Java #ProblemSolving #100DaysOfCode

How can a simple += make your Ruby application 10x slower? When we work with high-level languages like Ruby, performance is in the slightest details. A lot of things happen under the hood, and it is important to get familiar with them. In the code below, every time you call += Ruby: * Creates a new String * Copies the previous content inside "report" * And calls Garbage Collector to clean the previous content This degrades your "innocent" loop to an O(n²) complexity behaviour. Using the << or map/join approaches, you avoid all of that and end up with an O(n) complexity code. Little decisions can become silent bottlenecks, so before jumping to vertical or horizontal scaling, which can cost a lot 💸 , make sure your application is efficient enough by profiling your requests and async jobs. Let me know if you think this is helpful, and feel welcome to share other valuable insights 💡 #Ruby #RubyOnRails #SoftwareEngineering #BackendDevelopment #PerformanceOptimization #Scalability #CleanCode #SystemDesign #TechLeadership #Programming

🚀 Day 57 of #100DaysOfCode Today’s problem was a clean and classic two-pointer exercise — 🔁 LeetCode 344: Reverse String Simple on the surface, but a great reminder of in-place algorithms and pointer manipulation. 📌 Problem Summary You’re given a character array s. Your task is to reverse the array in-place, using O(1) extra space. 🧠 Approach Used: Two Pointers ✔️ Initialize: left = 0 right = s.length - 1 ✔️ Swap characters while left < right, then move pointers inward. This ensures: No extra memory Linear traversal Clean and readable logic ⚙️ Complexity Analysis ⏱ Time Complexity: O(n) 💾 Space Complexity: O(1) (in-place) ✔️ 477 / 477 test cases passed 🚀 Runtime: 0 ms (Beats 100%) 🔥 Key Learning Even the simplest problems reinforce core fundamentals: Two-pointer technique In-place operations Space optimization Mastering basics = dominating harder problems later 💪 Onward to Day 58 🚀 #100DaysOfCode #LeetCode #ReverseString #TwoPointers #Java #DSA #ProblemSolving #CodingJourney #Consistency

Day 18 – LeetCode 7 | Reverse Integer | Handling Overflow Like a Pro Solved LeetCode 7 – Reverse Integer today. At first glance, it looks like a basic number problem. It’s not. The real challenge is overflow handling, not reversing digits. Most beginners: → reverse digits correctly → fail when the number exceeds 32-bit integer range → get wrong answers If you ignore overflow, your solution is broken. Period. Core idea Extract last digit using % 10 Append using rev = rev * 10 + digit BEFORE multiplying → check overflow Complexity Time → O(log10 n) Space → O(1) What I improved today Edge case thinking Overflow detection Defensive coding mindset Simple problems hide important fundamentals. Master these → interviews become easy. #LeetCode #Day18 #Java #DSA #ProblemSolving #CodingInterview #100DaysOfCode #SoftwareEngineer #Algorithms #LearningInPublic

0ms Runtime. 100% Beats. The Power of Two Pointers. There is nothing quite like the feeling of seeing your code hit that 0ms mark on LeetCode. It’s that instant feedback that tells you your logic isn’t just correct—it’s optimized. I just solved the "Remove Nth Node From End of List" challenge using the Two-Pointer (Fast & Slow) technique. The Strategy: By moving a 'fast' pointer n steps ahead first, I created a fixed gap. Then, I moved both 'fast' and 'slow' pointers together until the end. This allowed me to find the target node and remove it in a single pass (O(n) time complexity). The Results: * Runtime: 0ms (Beats 100.00% of Java users). * Test cases: 208/208 passed. * Complexity: Efficient pointer manipulation with no extra space needed. In software engineering, we often look for complex tools to solve problems. This was a great reminder that sometimes, the most elegant solution is just a clever bit of pointer arithmetic. Keep pushing, keep optimizing. #Java #LeetCode #DataStructures #SoftwareEngineering #CodingLife #Algorithms

🚀 LeetCode Day 45 | Maximum Product Subarray Today’s challenge was all about handling positive, negative, and zero values smartly. 🔑 Key insight: While solving product-based problems, tracking both maximum and minimum values is crucial — because a negative number can flip the result. 🧠 This problem improved my understanding of: How negatives affect products Why we maintain two variables instead of one Writing efficient one-pass solutions ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) Consistency over intensity. One problem a day. 💪 #LeetCode #Day46 #DSA #ProblemSolving #CodingJourney #Java #Consistency

🚀 Day 35 of 50 Days of Code on LeetCode 🚀 Today I worked on a problem that highlighted the importance of ordering data correctly to uncover optimal solutions—finding all pairs with the minimum absolute difference in an array of distinct integers. 🔍 Approach: • Sorted the array to ensure proper ordering • Compared adjacent elements to identify the minimum absolute difference • Collected all pairs matching this minimum difference • Returned the pairs in ascending order automatically 💡 Key Learnings: • The closest values in a dataset often appear after sorting • Minimum absolute differences are found between adjacent elements • Preprocessing steps like sorting are crucial for correctness • Clean logic improves both efficiency and readability ⚙️ Complexity: Time: O(n log n) Space: O(1) (excluding output) This problem reinforced how a simple preprocessing step can transform a problem into an elegant and interview-ready solution. Continuing to build strong DSA fundamentals in Java 🚀 #Day35 #50DaysOfCode #LeetCode #Java #DSA #ProblemSolving #Algorithms #CodingJourney #PlacementPreparation #LearningByDoing

🚀 LeetCode 151 Challenge – Day 8 🚀 Progress isn’t about solving many problems in one day — it’s about solving one problem every day consistently 💪 🔹 Goal: Solve 151 LeetCode problems 🔹 Focus: DSA fundamentals + optimized approaches 🔹 Language: Java 🔹 Day: 8 ✅ ✅ Today’s Problem: 35. Search Insert Position (Easy) 🔍 Approach: – Applied Binary Search on a sorted array – Compared target with middle element – Adjusted left and right pointers accordingly – Returned correct insert position if target not found ⏱ Time Complexity: O(log n) 📦 Space Complexity: O(1) This problem reinforces a key interview concept: 👉 Whenever you see a sorted array + O(log n) requirement, think Binary Search immediately. 💬 Quick question: Can Binary Search be applied to problems beyond arrays? Where else have you used it? Let’s keep building strong fundamentals 👇 #LeetCode #DSA #ProblemSolving #Java #BinarySearch #Consistency #CodingJourney #SoftwareEngineering #LearningEveryDay #100DaysOfCode