🎉 Day 9 of My 100-Day Programming Challenge! 🚀 Today, I solved the “Number of Steps to Reduce a Number to Zero” problem on LeetCode. The task is simple yet interesting — reduce a number to zero by applying the following rules: • If the number is even → divide it by 2 • If the number is odd → subtract 1 🔍 Approach: I used a recursive approach to repeatedly apply the rules until the number becomes zero, while counting the number of steps taken. ⚙️ Steps: • Check if the number is zero → return steps • If even → divide by 2 and increment steps • If odd → subtract 1 and increment steps • Continue recursively until reaching zero 💡 Key Insights: ✔ Demonstrates the concept of recursion and base condition ✔ Simple logic but helps build strong fundamentals ✔ Can also be solved iteratively for better space optimization 🧠 Complexity: • Time Complexity: O(log n) • Space Complexity: O(log n) (due to recursion stack) Another great problem to strengthen problem-solving and recursion skills. Consistency is key — onto Day 10! 💻🔥 #100DaysOfCode #Java #LeetCode #DSA #Recursion #Programming #CodingChallenge

🎉 Day 13 of My 100-Day Programming Challenge! 🚀 Today, I solved the “Minimum Absolute Distance Between Mirror Pairs” problem on LeetCode. The goal is to find the minimum index distance between pairs where one number is the reverse of the other. 🧩 🔍 Approach: I used a HashMap + number reversal technique to efficiently track and compare mirror pairs. ⚙️ Steps: • Traverse the array from left to right • Reverse the current number • Check if the current number already exists in the map • If yes → calculate distance using i - previousIndex • Store the reversed number in the map for future matches 💡 Key Insights: ✔ Reversing numbers helps identify mirror pairs quickly ✔ HashMap enables O(1) lookup for efficient comparison ✔ Single pass solution makes it optimal 🧠 Complexity: • Time Complexity: O(n × d) (d = number of digits) • Space Complexity: O(n) A great problem to strengthen concepts in Hashing, Number Manipulation, and Optimization. Consistency continues — let’s keep building! 💻🔥 #100DaysOfCode #Java #LeetCode #DSA #HashMap #Programming #CodingChallenge

🎉 Day 8 of My 100-Day Programming Challenge! 🚀 Today, I solved the “Sqrt(x)” problem on LeetCode. The task is to compute the square root of a non-negative integer and return the result rounded down to the nearest integer, without using built-in functions like pow() or sqrt(). 🧩 🔍 Approach: I used the Binary Search technique to efficiently find the square root. ⚙️ Steps: • Define the search space from 1 to x. • Calculate the middle value (mid). • Check if mid * mid is equal to x. • If less than x, move right and store the potential answer. • If greater than x, move left. • Continue until the search space is exhausted. 💡 Key Insights: ✔ Binary Search reduces time complexity significantly. ✔ Avoids overflow using mid <= x / mid instead of mid * mid. ✔ Efficient way to compute roots without built-in functions. 🧠 Complexity: • Time Complexity: O(log n) • Space Complexity: O(1) Another great problem to strengthen Binary Search fundamentals and mathematical problem-solving skills. On to the next challenge! 💻🔥 #100DaysOfCode #Java #LeetCode #DSA #BinarySearch #Programming #CodingChallenge

🚀 Days 64-100 #100DaysLeetCodeChallenge Completed! 🎉 What started as a small daily commitment turned into one of the most disciplined journeys of my learning phase. Solving problems consistently helped me improve my problem-solving skills, logic building, and confidence in coding Here are some of the problems I worked on recently: 🔹 Array-based pattern problems (peaks, rotations, and sequences) 🔹 Matrix-based challenges involving counting and traversal 🔹 Searching and sorting-based problems 🔹 Linked List manipulations and edge case handling 🔹 Classic algorithmic problems like sum combinations and unique elements Key Takeaways: Consistency > Motivation Practice makes patterns visible Mistakes are the best teachers #100DaysOfCode #LeetCode #DSA #CodingJourney #Consistency #Learning #Java

When you read good code, you learn: How to structure logic How to name things properly How experienced developers think Lately, I’ve been spending more time understanding existing codebases instead of just building from scratch. Because in real-world projects, you don’t always start fresh — you improve what already exists. #Developers #Programming #CleanCode #Java #Learning #SoftwareEngineering #Growth

🚀 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 559 of #750DaysOfCode 🚀 🔍 LeetCode 3741: Minimum Distance Between Three Equal Elements II Today’s problem was an extension of yesterday’s question — but with larger constraints (n up to 1e5), making efficiency crucial ⚡ 💡 Problem Recap: Find three indices (i, j, k) such that: nums[i] == nums[j] == nums[k] Distance = |i - j| + |j - k| + |k - i| is minimized ✨ Approach I Used (Clean & Intuitive): ✔ Stored indices of each number using a HashMap ✔ For each number: If it appears ≥ 3 times Check consecutive triplets of indices ✔ Compute distance using: 👉 |i - j| + |j - k| + |k - i| 💻 Key Code Insight: Instead of checking all combinations, I only checked sliding windows of size 3 within index lists — reducing unnecessary work. 🧠 Learning: Even in medium problems, a simple structured approach (grouping + sliding window) can pass efficiently when applied correctly. ⚡ Complexity: Time: O(n) to build map + O(n) traversal Space: O(n) 💬 Takeaway: Don’t overcomplicate — sometimes the same idea from an easy problem scales well with just a small optimization in thinking. #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Tech #Programming #Developers #100DaysOfCode

Day 53 of #100DaysOfCode Didn’t post after Day 7… not because I stopped — but because I got deeper into the process. Some problems don’t take hours, they take days. And honestly, that’s where the real growth happens. So far: ✔️ 25 problems solved ✔️ Countless hours of thinking, debugging, and rethinking One thing I’ve realized (something not many people talk about): Most DSA questions aren’t about knowing the solution — they’re about recognizing the *pattern*. But here’s the catch— The same pattern can appear in completely different forms, and unless you’ve struggled with it before, you won’t even recognize it. That’s why sometimes a single question can take 2–3 days — not because it’s “hard”, but because it’s *teaching you how to think*. I’ve started noticing: • Many problems are just variations of a few core ideas (two pointers, sliding window, hashing, recursion) • The difficulty lies in identifying *which lens to use* Still learning. Still showing up. Consistency isn’t loud — it’s quiet and repetitive. On to Day 100 💪 #DSA #LeetCode #Consistency #ProblemSolving #Java

Day 5 / 100 Days of Coding : Solved: Best Time to Buy and Sell Stock Today’s problem looked simple but taught a powerful concept — tracking minimums and maximizing profit in a single pass. Key Learning: Instead of checking all pairs (which is slow), we maintain: Minimum price so far Maximum profit so far This reduces complexity from O(n²) → O(n) Consistency is the real game. Showing up every day matters more than perfection. #100DaysOfCode #DSA #LeetCode #Java #CodingJourney #ProblemSolving #GreedyAlgorithm

Learn how to send emails using Spring Boot with Gmail SMTP in this complete step-by-step tutorial. In this video, we cover how to configure SMTP settings, use JavaMailSender, and send both simple and HTML emails from your Spring Boot application. This tutorial is perfect for beginners and students preparing for interviews or building real-world projects like OTP systems, password reset features, and notification service #SpringBoot #Java #JavaMailSender #GmailSMTP #EmailSending #BackendDevelopment #FullStackDeveloper #LearnJava #SpringBootTutorial #Coding #Programming #Developers #SoftwareEngineering #TechEducation #JavaDeveloper