Optimizing FizzBuzz in Java with Counter-Based Approach

One of the best habits I’m currently building is writing pseudocode before writing real code. It forces me to slow down, think clearly, and design the logic first instead of jumping straight into syntax and getting stuck. If you’re new to programming, pseudocode is one of the simplest tools to reduce overwhelm and build real problem-solving skills. Clear thinking first. Clean code later. #OctoPrep #PythonDeveloper #DataScience #DataAnalysis

Day 33 – Solving LeetCode problems 🚀 📌 Problem: 42. Trapping Rain Water (Hard) 🧠 Key Idea: Water trapped at any index depends on min(maxLeft, maxRight) − height[i] Precompute left max & right max (or use two pointers) One pass to accumulate trapped water 💡 What I reinforced today: How precomputation simplifies complex-looking problems Translating a visual problem into mathematical logic Writing efficient and clean Java code for array problems ⚙️ Complexity: Time: O(n) Space: O(n) (can be optimized to O(1) using two pointers) Hard problems feel tough until logic clicks—one step closer to mastering DSA. #LeetCode #Day33 #DSA #Java #ProblemSolving #CodingJourney

👇 🚀 Day 52 of #100DaysOfCode 💻 Consistency check: still going strong 💪 Today’s problem was a clean and practical string manipulation question — 📝 Length of Last Word (LeetCode) 📌 Problem Summary Given a string consisting of words and spaces, find the length of the last word in the string. Example: "Hello World" → 5 Sounds simple, but edge cases matter: Trailing spaces Multiple spaces between words 🧠 My Approach Instead of splitting the string (which uses extra space), I traversed the string from the end: 1️⃣ Skip all trailing spaces 2️⃣ Count characters until a space is found This keeps the solution efficient and clean. ⚙️ Complexity Analysis ⏱ Time: O(n) 💾 Space: O(1) Optimized and interview-friendly 🚀 🔥 Key Learning Not every problem needs complex logic Backward traversal is a powerful trick for string problems Handling edge cases is what makes solutions robust ✅ Accepted with 0 ms runtime Another step forward in my coding journey ✔️ On to Day 53! 🚀💻 #100DaysOfCode #LeetCode #Java #Strings #ProblemSolving #DSA #CodingJourney #Consistency

✏️ DSA Diary Day 16/100 📚🔤: Solving LeetCode’s “Minimum ASCII Delete Sum for Two Strings” 🚀✨ Today I worked on a Dynamic Programming + String Optimization problem on LeetCode 🔥👇 👉 Minimum ASCII Delete Sum for Two Strings This problem beautifully shows how DP helps minimize deletion cost while preserving the maximum common structure between two strings 🧠💡 🔹 My Approach 🛠️🧠 I used Bottom-Up Dynamic Programming (Tabulation) 🔽👇 🔸 Step 1: Define the DP Idea 📌 Instead of directly calculating what to delete, I focused on maximizing the ASCII value of the common subsequence between both strings. The more valuable the common part is, the less we need to delete 🔁✨ 🔸 Step 2: Decision Making 🔍 At every character comparison: 1️⃣ If both characters match → Add their ASCII value to the total 2️⃣ If they don’t match → Carry forward the maximum value from previous comparisons This is similar to the Longest Common Subsequence (LCS) concept, but with weights (ASCII values) instead of length 📈 🔸 Step 3: Getting the Final Answer 🧮 We calculate the total ASCII value of both strings, then subtract twice the value of the common subsequence. This ensures: ✔ Only unnecessary characters are deleted ✔ The deletion cost is minimum #LeetCode 🚀 #Java ☕ #DSA 🧠 #DynamicProgramming 📊 #ProblemSolving 💡 #CodingChallenge 💻 #100DaysOfCode 🔥 #DSADiaryByRethanya ✨ #Strings 🔤 #Tabulation 🧩 #LearnInPublic 📢 #TechJourney 🚀

🚀 Day 36/100 of My LeetCode Challenge: Mastering Greedy & Dynamic Programming! Just solved LeetCode 3507: Minimum Pair Removal to Sort Array I – an interesting problem that beautifully blends greedy operations with dynamic programming thinking! 🧠 🔍 The Challenge: Given an array, repeatedly replace the adjacent pair with the minimum sum until the array becomes non-decreasing. Return the minimum number of such operations required. 💡 Key Insights: This isn't just about blindly following the operation description (selecting minimum sum pairs) The optimal solution requires recognizing this as a dynamic programming problem We need to find the minimum operations to partition the array into segments that can be merged while maintaining the non-decreasing property Each merge operation happens only when the left segment's sum exceeds the right segment's sum 🛠️ My Approach: Implemented a memoized DP solution that explores all possible partition points For each possible split position, recursively solve left and right subarrays Add a merge cost when the left segment's sum is greater than the right segment's sum Use memoization to avoid redundant computations for O(n²) time complexity 📊 Performance: Runtime: 66.06% Memory: 44.62 MB Beats: 32.51% of Java submissions 🎯 Why This Matters: This problem is a great example of how: Problem understanding matters more than just following instructions Dynamic programming can elegantly solve what seems like a greedy problem Memoization dramatically improves performance for recursive solutions Real-world scenarios often require transforming problem statements into solvable patterns ✨ The Journey Continues: Every day of this 100-day challenge brings new learning opportunities. Today reinforced that sometimes the direct approach isn't optimal, and we need to think one level deeper about the underlying structure of the problem. #LeetCode #CodingChallenge #100DaysOfCode #ProblemSolving #DynamicProgramming #GreedyAlgorithms #Java #SoftwareEngineering #TechCareer #DeveloperJourney #Algorithm #DataStructures #CodingInterview #Programming

🚀Day 1 of #100 Days of Code Solved: Minimum Limit of Balls in a Bag (LeetCode) Just wrapped up this interesting problem that combines Binary Search + Greedy thinking. Sharing a quick breakdown of the approach I used 👇 Key Idea :- We are not distributing balls directly — instead, we binary search on the answer (the maximum balls allowed in any bag). ✅ Steps followed in the code: 1️⃣ Search Space Setup left = 1 → minimum possible size of a bag right = max(nums) → worst case, no split at all 2️⃣ Binary Search on the Answer For a guessed value mid, assume no bag can have more than mid balls 3️⃣ Calculate Required Operations For each bag with n balls, operations needed = (n - 1) / mid This formula tells how many splits are required to keep each part ≤ mid 4️⃣ Decision Making If total operations > maxOperations → mid is too small → move left = mid + 1 Else → mid is valid → try smaller value → right = mid 5️⃣ Final Answer When left == right, we’ve found the minimum possible maximum bag size ⏱️ Complexity Time: O(n log max(nums)) Space: O(1) This problem is a great example of how binary search isn’t just for sorted arrays — it’s powerful when applied to answer optimization problems. #LeetCode #BinarySearch #DSA #ProblemSolving #Java #CodingJourney 🚀

🎉 Ruby 4.0 has arrived – and it's a gift for the entire community! Released on Christmas Day 2025, Ruby 4.0 marks the language's 30th anniversary (Ruby Programming Language) with groundbreaking features that set the stage for Ruby's next decade. 🚀 What's New: ZJIT Compiler – A next-generation just-in-time compiler built with Rust (Ruby Programming Language) , designed with a traditional method-based compilation approach that encourages community contributions. While still experimental, it's faster than the interpreter and lays the foundation for major performance gains in Ruby 4.1. Ruby Box – An experimental isolation feature that separates definitions within boxes (Ruby Programming Language) , enabling powerful use cases like running multiple gem versions simultaneously, isolating test monkey patches, and executing parallel web app instances within a single Ruby process. Ractor Improvements – Ruby's parallel execution mechanism gets a major upgrade with the new Ractor::Port class, making concurrent programming more intuitive and bringing Ruby closer to production-ready true parallelism. Quality-of-Life Enhancements – Logical operators can now appear at the beginning of lines for better code readability (Saeloun Blog) , Unicode updates to version 17.0, and various syntax improvements that make Ruby even more developer-friendly. The Bottom Line: Ruby 4.0 isn't just a version bump—it's a strategic investment in the language's future. The groundwork being laid with ZJIT and Ruby Box will unlock performance and flexibility that developers have been asking for. Props to Matz and the entire Ruby core team for continuing to push this beautiful language forward! 💎 Official document: Source: Ruby Programming Language https://lnkd.in/g7tZRJ65 #Ruby #Programming #SoftwareDevelopment #Ruby4 #DevCommunity #TechNews

Almost two years ago I wrote an article with concerns about the directions the Go programming language evolves to - https://lnkd.in/daSpTqHN . TL;DR: increased complexity without the increased practical productivity. I mentioned there that adding generics to Go was a mistake - they didn't increase productivity for Go developers, while they complicated significantly Go specification and Go compiler (which, in turn, may complicate further maintenance, refactoring and optimization of Go compiler and runtime). Additionally, generics in Go lack many features developers expect when they work with generic code. The most requested missing feature in Go was generic methods. I mentioned it in the article. It is likely this "feature" will be added in Go1.27, complicating the Go language and the average Go code further :( https://lnkd.in/dmQU8-Hq Please add comments to this "feature" request with arguments while it shouldn't be implemented. My argument - it has close to zero practical use cases, while it continues complicating Go.