100DaysOfCode: LeetCode Challenge and Spring Boot Exception Handling

🚀 #100DaysOfCode – Day 17 Consistency is turning into confidence. Showing up daily 🔥 ✅ What I accomplished today: 🧠 LeetCode Daily Challenge – XOR After Queries 📌 Problem Overview: You are given an array and a list of queries. Each query contains: left, right → range k → step increment value → multiplier 👉 For each query: ✔ Update elements from left to right with step k ✔ Multiply each selected element by value Finally, compute the XOR of the entire array 💡 My Approach (Simulation): 🔹 Iterated through each query 🔹 For every query: ✔ Started from left ✔ Jumped with step k until right ✔ Applied multiplication with modulo (10^9 + 7) 🔹 After processing all queries: ✔ Calculated final XOR of array ⚡ Time Complexity: 👉 O(Q * (N / K)) in worst case ⚡ Space Complexity: 👉 O(1) 🧩 Key Insights: ✔ Step-based traversal reduces unnecessary operations ✔ Careful handling of large numbers using modulo ✔ XOR aggregation at the end is straightforward but important ✔ Simulation works, but optimization scope exists (future improvement 🚀) 🔗 LeetCode Submission Link: https://lnkd.in/gZKCZf87 ☕ Spring Boot Learning – Lambda & Stream API Today I explored one of the most powerful features in modern Java 💡 📌 Key Concepts Covered: ✔ Introduction to Lambda Expressions ✔ Writing concise and readable functional code ✔ Using Stream API for data processing ✔ Performing operations like: filter() map() forEach() collect() ✔ Converting collections into streams for clean transformations 🌍 Why This Matters: ✔ Reduces boilerplate code ✔ Improves readability and maintainability ✔ Encourages functional programming style ✔ Makes data processing more expressive and efficient 🧠 Big Learning: Writing less code doesn’t mean doing less— it means writing smarter, cleaner, and more expressive code. 🔥 Learning Streak: Day 17/100 Discipline today → Results tomorrow 🚀 #100DaysOfCode #Java #SpringBoot #BackendDevelopment #LeetCode #DSA #ProblemSolving #CodingJourney #SoftwareDevelopment #LearningInPublic #Developers #Consistency #BuildInPublic

🚀 Day 74 — Slow & Fast Pointer (Cycle Detection in Linked Lists) Continuing the slow‑fast pointer pattern — today I solved the two foundational problems that every DSA learner encounters. No guilt about past breaks, just consistent action. 📌 Problems Solved Today:   - LeetCode 141 – Linked List Cycle   - LeetCode 142 – Linked List Cycle II 🧠 Key Learnings: 1️⃣ Detecting a Cycle (LeetCode 141)   - Initialize `slow` and `fast` at `head`.   - `slow` moves 1 step, `fast` moves 2 steps.   - If they meet → cycle exists.   - If `fast` reaches `null` → no cycle.   - Edge case: empty list or single node → return false immediately. 2️⃣ Finding the Cycle Start (LeetCode 142)   - First detect cycle using same two pointers.   - Once they meet, reset `slow` to `head`.   - Move both pointers 1 step each until they meet again.   - The meeting point is the start of the cycle.  3️⃣ The Math Behind It (Why this works)  Let distance from head to cycle start = X, cycle start to meeting point = Y, meeting point back to cycle start = Z.   - Slow travels: `X + Y`   - Fast travels: `X + Y + Z + Y` (because it lapped the cycle)   - Fast speed = 2 × Slow speed → `2(X + Y) = X + 2Y + Z` → simplifies to `X = Z`.   - So resetting slow to head and moving both 1 step makes them meet exactly at cycle start. 💡 Takeaway:   These two problems are the gateway to understanding cycle‑related linked list problems. Master this pattern, and you unlock ~40% of linked list interview questions. No looking back — just solving, learning, and moving forward. #DSA #SlowFastPointer #FloydCycleDetection #LinkedList #LeetCode #CodingJourney #Revision #Java #ProblemSolving #Consistency #GrowthMindset #TechCommunity #LearningInPublic

🚀 Day 10: Classes & Objects – The Core of Object-Oriented Programming 💎🏗️ Today marks a significant step in my Java journey. I moved beyond writing simple logic and started understanding how to represent real-world entities in code using Classes and Objects. Here’s how I structured my learning: 🔹 1. Class – The Blueprint 📋 A class is a logical structure—a blueprint that defines what an object will look like. It contains: • Properties (State): Variables like name, age, etc. • Behaviors (Actions): Methods that define functionality 👉 Think of it as an architect’s design—you can’t live in it, but it guides construction. 🔹 2. Object – The Real Entity 🏠 An object is an instance of a class. It exists in memory and represents a real-world entity. Created using the new keyword: Car myCar = new Car(); 👉 If the class is the design, the object is the actual building. 🔹 3. Class–Object Relationship 🔗 • A class is defined once • Multiple objects can be created from it • Each object holds its own unique data 💡 Key Takeaway: Programming is not just about writing instructions—it’s about modeling the real world digitally using structured and reusable designs. I’m starting to see how powerful Object-Oriented Programming is in building scalable and maintainable applications. This feels like the foundation for becoming a strong backend developer. 💻 #JavaFullStack #OOP #ObjectOrientedProgramming #JavaDeveloper #CodingJourney #Day10 #BackendDev2026

🚀 #100DaysOfCode – Day 12 | Backend Journey Continues 💻🔥 Consistency is starting to feel powerful now. Day 12 done ✅ 🧠 LeetCode Daily Challenge 📌 Problem: Maximum Walls Destroyed by Robots 💡 Approach & Learnings: Today’s problem was a mix of Sorting + Binary Search + Dynamic Programming, which made it super interesting. 🔹 Sorted robots and walls to process efficiently 🔹 Used Binary Search to quickly count walls in a given range 🔹 Applied Dynamic Programming to maximize total walls destroyed 👉 The key challenge was handling overlapping ranges between robots and deciding the optimal strategy to avoid double counting. This problem really tested how well I can combine multiple concepts into one optimized solution. Submission Link: https://lnkd.in/gp99D5sS 🌱 Spring Boot Learning Today I focused on some very important backend concepts: 🔹 PUT vs PATCH Mapping 👉 PUT Mapping Used when updating the entire object Missing fields → become NULL Best for full replacement 👉 PATCH Mapping Used for partial updates Only updates required fields Avoids unnecessary null values 🔹 ReflectionUtils in PATCH Learned how to use Reflection to dynamically update fields inside an entity. 💡 This helps in: Updating fields without writing multiple setters Making PATCH APIs more flexible Writing cleaner and scalable backend code 🔹 ResponseEntity Understood how to structure API responses properly: ✅ Control HTTP status codes ✅ Customize response body ✅ Improve API clarity and standards 📈 Key Takeaways ✔️ Combining multiple DSA concepts is key for optimization ✔️ PATCH is essential for real-world API design ✔️ Reflection adds flexibility to backend logic ✔️ Clean API responses improve overall system design NotesLink: https://lnkd.in/gNZWz96m 🔥 Day 12 done. Still consistent. Still improving. #BackendDevelopment #SpringBoot #Java #LeetCode #100DaysOfCode #CodingJourney

I Thought My Code Was Clean… Until I Read It Again 👀 Early in my career, I believed: 👉 “If the code works, it’s good code.” It compiled. It gave the right output. So I moved on. But a few weeks later, I opened the same code again… And struggled to understand it. That’s when it hit me: 👉 Code is not just written to run. 👉 It’s written to be read. From that moment, my focus shifted. Not just “Will this work?” But also “Will this be clear to someone else?” 💡 What Changed My Approach I stopped trying to be clever. And started trying to be clear. Instead of writing one big method… I started breaking it into smaller ones. Each function doing just one thing. Instead of short, confusing names… I began using names that actually explain the purpose. Because: 👉 Good naming reduces confusion more than comments ever can. Instead of repeating logic… I started reusing it. Because copy-paste code always comes back as a bug later. Instead of deeply nested conditions… I simplified the flow. Because if it’s hard to read… it’s hard to maintain. ⚠️ One Hard Truth Most code doesn’t fail in production because it doesn’t work. It fails because: • It’s hard to understand • Hard to modify • Easy to break 🧠 The Mindset That Helped Me Before writing code, I now ask: • Can this be simpler? • Can this be reused? • Will this confuse someone later? 💬 Final Thought Clean code is not about impressing others. It’s about making life easier for: • your teammates • your future self If you read your code after a month and understand it easily… 👉 That’s clean code. What’s one habit that helped you improve your code quality? 👇 #CleanCode #SoftwareEngineering #Java #BackendDevelopment #Programming #DeveloperGrowth #BestPractices

30 days into my #100DaysOfCode journey. One thing I’ve learned so far: Learning to code is less about writing code and more about learning how to think. Over the last 30 days, I’ve: • struggled with concepts like async/await, OOP, and TypeScript • taken extra time to actually understand things instead of rushing • built small projects and improved them step by step • started thinking more in terms of logic and data flow There were days when: • things didn’t make sense • progress felt slow • I had to revisit the same concept multiple times But I kept showing up. And that’s what matters. Right now, I’m focusing on: • building projects gradually • strengthening fundamentals • improving problem-solving skills Still a long way to go, but definitely more clarity than Day 1. Next → keep building + keep learning. #100DaysOfCode #SoftwareTesting #QAAutomation #TypeScript #LearningInPublic

🚀 Day 6 of LeetCode Problem Solving Solved today’s problem — LeetCode #1480: Running Sum of 1d Array 💻🔥 ✅ Approach: Prefix Sum (Running Sum) ⚡ Time Complexity: O(n) 📊 Space Complexity: O(n) The task was to compute the running sum of an array where each element represents the sum of all previous elements including itself. 👉 Example: Input: [1,2,3,4] Output: [1,3,6,10] 💡 Key Idea: Keep adding elements as you traverse the array and store the cumulative sum. 👉 Core Logic: Initialize sum = 0 Traverse array Add current element → sum += nums[i] Store in result array 💡 Key Learning: Simple problems help build strong fundamentals — mastering basics like prefix sum is very important for advanced problems. Grateful to my mentor Pulkit Aggarwal — your guidance is helping me strengthen my fundamentals every day 🙌 Consistency is the key — small steps lead to big results 🚀 #Day6 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #100DaysOfCode

🚀 Day 13 of Spring: Conquering Dependency Ambiguity & The Power of FactoryBeans The more I dive into the Spring Framework, the more I appreciate its ability to handle complex object relationships. Today was all about solving a common challenge: The Ambiguity Problem. What is the Ambiguity Problem? In a loosely coupled system, you might have multiple beans of the same type (e.g., different implementations of an Engine interface). When Spring tries to inject one, it gets confused: "Which one should I use?". How do we solve it? 🛠️ According to today’s session, we have several powerful tools to resolve this: @Primary: Use this to mark one bean as the "leader" or default choice when multiple candidates exist. @Qualifier: A more surgical approach. You can specify the exact bean ID at the injection point to tell Spring exactly what you need. FactoryBean (The Advanced Choice): This is a game-changer! A FactoryBean is a special bean that acts as a factory for other beans. By implementing the FactoryBean interface, you can write custom logic in the getObject() method to decide which implementation to return at runtime. Profiles: You can also use @Profile to choose beans based on your environment (like Dev vs. Production). Bonus Learning: Internationalization (I18n) 🌍 I also explored how Spring handles I18n using ResourceBundleMessageSource. It’s incredible how easily Spring can swap messages based on a user's Locale (like English vs. French) using simple properties files!. Learning Spring isn't just about writing code; it's about understanding how to build scalable, flexible, and global-ready applications. Question for my network: Which do you prefer for dependency resolution—@Qualifier for its explicitness or FactoryBean for its dynamic flexibility? Let's discuss! 👇 #SpringFramework #JavaDevelopment #LearningToCode #SoftwareEngineering #SpringBoot #BackendDevelopment #100DaysOfCode #JavaLearning

🚀 From Writing Code → To Automating Everything! Recently, I worked on my project WealthLens and took a big step forward — I implemented my first CI/CD pipeline using GitLab. At first, I didn’t even understand why CI/CD is important… but while building it, everything started making sense. Here’s what I learned 👇 🔹 Every push is automatically verified No more “it works on my machine” — GitLab builds, runs, and tests everything automatically. 🔹 Real errors taught me real lessons Faced issues like: Maven not found Wrong environment setup Missing configurations And fixed them step by step. 🔹 Team collaboration became clear Worked with branches, commits, and Merge Requests — just like real companies. 🔹 Confidence boost 🚀 Now I know how real-world development works: Write → Push → Validate → Merge 💡 Biggest takeaway: CI/CD is not just automation… it’s a safety system for your code. 🔗 Project Link: https://lnkd.in/d6HgAD2C Tech Stack: Java | Spring Boot | Python (Flask) | GitLab CI/CD | Git Next step: Deployment 🌐 #CICD #GitLab #JavaDeveloper #SpringBoot #LearningByDoing #FullStackJourney

🚀 Day 7 of LeetCode Problem Solving Solved today’s problem — LeetCode #414: Third Maximum Number 💻🔥 ✅ Approach: Tracking Top 3 Maximums ⚡ Time Complexity: O(n) 📊 Space Complexity: O(1) The challenge was to find the third distinct maximum number in an array. If it doesn’t exist, return the maximum number. 👉 Instead of sorting (which takes extra time), I tracked the top 3 distinct maximum values in a single pass. 💡 Key Idea: Maintain three variables (max, smax, tmax) to store the first, second, and third maximum values while traversing the array. 👉 Core Logic: Skip duplicates Update max, second max, third max accordingly If third max doesn’t exist → return max 💡 Key Learning: Optimizing from sorting to a single-pass solution can significantly improve efficiency. Grateful to my mentor Pulkit Aggarwal — your guidance is helping me think more optimally 🙌 Consistency is the key — improving step by step 🚀 #Day7 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #100DaysOfCode