Markus Eisele’s Post

Day 94/100 – #100DaysOfCode 🚀 | #Java #DynamicProgramming #UnboundedKnapsack ✅ Problem Solved: Coin Change II (LeetCode 518) 🧩 Problem Summary: Given an integer amount and an array of coin denominations, return the number of combinations that make up the amount. Each coin can be used unlimited times, and the order of coins does not matter. 💡 Approach Used: ✔ Used Dynamic Programming (1D DP) ✔ This is a classic Unbounded Knapsack problem Steps: Initialize dp[0] = 1 (one way to make amount 0) For each coin: Iterate from coin to amount Update dp[i] += dp[i - coin] This ensures combinations are counted, not permutations ⚙ Time Complexity: O(N × amount) 📦 Space Complexity: O(amount) (where N = number of coins) ✨ Takeaway: The order of loops in DP matters! Iterating coins first avoids counting duplicate permutations and keeps combinations unique. #Java #LeetCode #DynamicProgramming #UnboundedKnapsack #100DaysOfCode #CodingChallenge

🎯 Java 21: A Game Changer for Modern Development The Virtual Threads feature in Java 21 is incredible. Write highly scalable applications without the complexity of traditional threading. ✨ Key Highlights: • Virtual Threads - Lightweight concurrency at scale • Pattern Matching - Cleaner code, less boilerplate • Record Classes - Faster data modeling • Foreign Function & Memory API - Direct interop with native code If you haven't upgraded yet, now's the time. What's your favorite Java 21 feature? #Java #Java21 #SoftwareDevelopment #VirtualThreads

Ready to take a trip down memory lane—and build something cool in the process? This tutorial walks you through how to recreate the classic Snake game in Java, complete with logic, rendering, and controls. Sample code included. #Java #GameDev #CodingProjects #ProgrammingBasics #RheinwerkComputingBlog Read here: https://hubs.la/Q03-ngrv0

🚀 DSA Day 3 | Arrays & Prefix Sum (Java) Today’s focus was on Prefix Sum, an important array technique that helps optimize range sum queries efficiently. ✅ What I learned: How to build a prefix sum array Difference between in-place and extra array prefix sums How prefix sum reduces time complexity from O(n) to O(1) for range queries Solved multiple practice problems to strengthen logic 🧠 Key Insight: Pre-computation makes problem solving faster and cleaner. Consistency over motivation. One day at a time 💪 #DSA #Java #PrefixSum #Arrays #CodingJourney #LearningEveryDay #100DaysOfCode

Day 6/30 – LeetCode #242 (Valid Anagram) | Java My initial thought was to sort both strings and compare them, but that adds unnecessary overhead. The more efficient approach was to use a frequency count, since only character occurrences matter here. By using an int[26] array and incrementing/decrementing counts while iterating through both strings, I was able to solve this in O(n) time with O(1) space. This problem reinforced how fixed-size arrays in Java can outperform maps when the character set is known. #LeetCode #Java #DSA #Strings #Hashing #Consistency #LearningInPublic

⚠️ Why multithreaded code gives unexpected output? When multiple threads access shared data without synchronization, the result can change unpredictably — this is called a Race Condition. 🔴 Without synchronization Threads overwrite each other → unexpected output 🟢 With synchronization Only one thread accesses shared data at a time → correct, predictable output ✅ Key takeaway: Always protect shared resources in Java using synchronized, locks, or thread-safe utilities. #Java #Multithreading #Concurrency #ThreadSafety #JavaDeveloper #BackendDevelopment

Day 8/30 – LeetCode #14 (Longest Common Prefix) | Java The challenge here wasn’t complexity, but handling edge cases cleanly. My initial thought was to compare characters column by column, but managing bounds made the logic harder to read. Using the first string as a reference prefix and gradually shrinking it with substring() until it matched all other strings simplified the solution. The startsWith() check kept the code readable while maintaining correctness. This problem reinforced how clarity in string manipulation often matters more than clever logic. #LeetCode #Java #DSA #Strings #ProblemSolving #Consistency #LearningInPublic

Java just became incredibly lightweight. Version 21 has redefined high-throughput applications with the introduction of Virtual Threads. For years, we were bound by the heavy one-to-one mapping of Java threads to OS threads. Virtual threads sever this dependency, allowing you to spawn millions of concurrent tasks without crashing your memory footprint. Here is how to leverage them effectively: Stop Pooling: Unlike platform threads, virtual threads are cheap to create. You no longer need heavy thread pools to manage resources; just create them as needed. Adopt the New Executor: Use Executors.newVirtualThreadPerTaskExecutor() to submit tasks. The JVM handles the mounting and unmounting on carrier threads automatically. Regain Observability: Reactive streams often obscure stack traces, making debugging a nightmare. Virtual threads preserve the context, allowing you to step through code and read logs just like traditional synchronous applications. Do you see Virtual Threads replacing Reactive frameworks in your current stack? #Java #SoftwareDevelopment #VirtualThreads #BackendEngineering #Scalability #Java21

Java 22 is here to revolutionize your workflow! Following our first deep dive, Part 2 focuses on the features that maximize your productivity and slash boilerplate code. What’s inside: Stream Gatherers: Mastering Batching & Windowing. Unnamed Variables: Using _ for cleaner code. Statements Before super(): Logic-first constructors. Implicit Classes: Java at scripting speed. Swipe to see the code! #Java #SoftwareEngineering #CleanCode #Java22

I reworked Ordo CLI and fixed folder recursion issues and improved error handling to prevent unintended file changes.  Full documentation is now live on github pages: https://lnkd.in/gWrECNnw A new version has also been released: https://lnkd.in/g8ndFxfx #Java #Picocli #GraalVM #CLI #OpenSource #GithubPages