ElixirConf®’s Post

Day 39 — #100DaysOfLeetCode 🚀 Problem: Implement Queue using Stacks (LeetCode 232) ✅ Approach: Used two stacks — one for enqueue and one for dequeue operations. ⚡ Complexity: Amortized O(1) per operation Learning: Enhanced understanding of stack–queue relationships and algorithmic trade-offs 🔁 #LeetCode #100DaysOfCode #DSA #Stack #Queue #ProblemSolving #CodingJourney

GitHub Octoverse 2025: TypeScript Takes the Lead for the First Time, AI Sets New Development Dynamics TypeScript just overtook Python and JavaScript as the #1 language on GitHub — driven by the AI boom and Copilot adoption. 💡 180M+ developers now use GitHub (1 joins every second). 🤖 200+ new AI projects are created every minute. Read the full Octoverse 2025 report here: https://lnkd.in/dfjaYnwu AI isn’t just helping us code faster - it’s reshaping how we build software. #GitHub #Octoverse2025 #TypeScript #AI #Copilot #SoftwareDevelopment

Day-83 of #100DaysOfCodeChallenge 🚀 🚀 LeetCode Daily Challenge — Maximize the Minimum Powered City 💡 Today’s problem was an interesting mix of Binary Search and Difference Array concepts. It focused on finding the maximum possible minimum power supply for cities by smartly distributing additional power stations LeetCode. 🧠 Key Concepts Used: Binary Search to determine the highest feasible minimum power. Difference Array for efficient power range calculations. Greedy approach for placing additional stations. ✅ Successfully solved with 91.67% runtime efficiency — 29ms! Each daily challenge is another step toward sharpening problem-solving and optimization skills 🔥 #LeetCode #ProblemSolving #CodingJourney #BinarySearch #DataStructures #Algorithms #WomenInTech #Java #CodingChallenge

Legacy code. Modern headache. Your tech stack shouldn’t give you migraines. Legacy code slows innovation, frustrates developers, and drains budgets. Thebes AI Toolkit uses generative AI to automatically refactor legacy .NET and Java, freeing your teams to focus on growth - not firefighting. Discover how AI removes the headache - not just the symptoms. And if you’re not satisfied? You can have your old code back. #AIModernisation #RiskFirst #GenAI #SmashTheLegacy #ThebesTechnology #TechDebt #ThebesGroup #CodeModernisation #FutureProofCode #ThebesGenAIToolkit #IBMSilverPartner #LegacyModernisation #UnsupportedCode #Code #Modernisation #Thebes

🚀 LeetCode POTD — 1611. Minimum One Bit Operations to Make Integers Zero 🎯 Difficulty: Hard | Topics: Bit Manipulation, Recursion, Mathematical Patterns 🔗 Solution Link: https://lnkd.in/g4RHfa8h Today’s #LeetCode Problem of the Day was one of those that really make you stop and think. The problem looked simple on the surface — transform a number into 0 using a defined set of bit operations — but understanding how the bits interact recursively was the real challenge. At first, I tried approaching it directly by simulating the operations… but quickly realized that wasn’t scalable. I took a hint, tried to reason it out again, but still couldn’t fully connect the dots. Then I watched Mazhar Imam Khan’s explanation — and everything finally clicked! 🎯 The key insight was understanding that for a number like 1100, you can derive its result by simply calculating: 👉 f(1100) = f(1000) - f(100) That single conceptual shift completely changed how I looked at the problem. 💡 Core Idea: Build an array (holder) representing the number of operations required for each bit position. Traverse from the most significant bit downward. If the current bit is set, adjust the result using a sign-flip mechanism to handle transitions between set bits. 🧠 Key Learnings: Many bit-manipulation problems are built on mathematical symmetry, not just logical operations. Understanding the pattern behind Gray Code transformations helps reveal the structure. Sometimes, one line of conceptual clarity from a great teacher saves hours of debugging. 🕒 Complexity: Time: O(size of binary transformation ) Space: O(size of binary transformation + 1) 💬 Takeaway: Don’t hesitate to seek clarity when stuck — a well-explained insight can bridge the gap between confusion and understanding. #LeetCode #ProblemOfTheDay #BitManipulation #HardProblem #DSA #C++ #CodingJourney #Consistency #ProblemSolving #LearningInPublic #100DaysOfCode #SoftwareEngineering #TechCommunity

🚀 Day 8 of #100DaysOfLeetCode Challenge 😎 📌Today's problem: Palindrome Number (LeetCode #9) 💡 🔹 Concept: Check whether a given integer reads the same backward and forward — without converting it to a string! 🔹 Logic Used: Instead of reversing the entire number, I reversed only half of it to improve efficiency. This avoids unnecessary computation and eliminates integer overflow risks. 🔹 Key Learnings: ✅ Optimized logic using mathematical manipulation ✅ Improved understanding of number reversal techniques ✅ Importance of edge case handling (negative numbers, trailing zeros) ⚙️ Result: 💻 Runtime: 4 ms (Beats 100%) 💾 Memory: 44.84 MB 😎Small optimizations make a big difference in performance! 💪 📌Problem: https://lnkd.in/ef6AC2j6 🔥Each day is a step closer to writing cleaner and more optimized code. ✨ Let’s keep pushing forward and refining our problem-solving skills! 💻🔥 #LeetCode #Day8 #100DaysOfCode #ProblemSolving #Java #CodingChallenge #PalindromeNumber #DataStructures #Algorithms #LearningEveryday

🔍 Day 30 | Shift Happens (and That’s Beautiful) Today’s LeetCode challenge was #848 – Shifting Letters 🌀 At first glance, it looks like a simple “shift characters” task — but under the hood, it’s a neat example of prefix-sum logic meets modular arithmetic. 💡 The Problem: For each index i, shift the first i+1 letters by shifts[i] times — wrapping around from 'z' to 'a'. 🧠 The Trick: If we start from the end of the string and move backward, we can keep a cumulative shift sum that already accounts for all later shifts. This avoids repeatedly looping over the prefix and keeps our time complexity O(n) instead of O(n²). ⚙️ Approach: Traverse from right to left Keep adding each shift to a running total (totalShift) Apply totalShift % 26 to shift the current character efficiently Update the string using a StringBuilder 💨 Why It’s Optimal: ✅ Single pass — linear time ✅ Constant extra space ✅ Clean and scalable even for large inputs (up to 10⁵ length! Sometimes the cleanest solutions come from flipping your perspective — literally shifting your direction Shishir chaurasiya and PrepInsta #LeetCode #CodingChallenge #Java #Algorithms #ProblemSolving #LearningEveryday

🚀 LeetCode Daily Challenge – Day 51 🧩 Problem: LeetCode 3289 – The Two Sneaky Numbers of Digitville 🔗 Problem Link: https://lnkd.in/gsaJMm8J 🧠 Intuition: Today’s challenge takes us into the realm of frequency counting and pattern detection 🔢🔍. We’re asked to find the “sneaky” numbers — the ones that appear more than once in a given array. It’s a simple yet elegant problem that highlights how crucial data tracking is — whether it’s in code or in real-world analytics. ⚙️ Approach (Counting Technique): 1️⃣ Initialize a frequency array count[] to keep track of occurrences. 2️⃣ Traverse through the input nums — increment the count for each number. 3️⃣ After the pass, any number with a count greater than 1 is a sneaky number 👀. 4️⃣ Collect these numbers and return them. 💡 Key Insight: This problem emphasizes the importance of frequency mapping — a foundational concept for problems like duplicates, anagrams, and data analysis. Sometimes, solving efficiently is about counting smartly rather than searching repeatedly. ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(1) (since the number range is fixed to <100) 📈 Learning from Day 51: Even the simplest algorithms teach big lessons — tracking, observation, and attention to detail. Whether it’s arrays, logs, or life — what you measure, you can master. 📊✨ 🌟 Motivation: Don’t underestimate the power of small problems — they build the intuition that drives big solutions. Keep counting your progress, not your setbacks. Every line of code adds up. 💪💻 #️⃣ Hashtags: #Day51 #LeetCode #CodingChallenge #Java #DSA #ProblemSolving #FrequencyCount #LogicBuilding #100DaysOfCode #Consistency #GrowthMindset #KeepCoding #LearnByDoing

#Day-62 ) Solved LeetCode #2528 – Maximize the Minimum Powered City 🔍 Tackled this optimization challenge using binary search + difference array for efficient power distribution across cities. 💡 Key insight: simulate power coverage with a sliding window and greedily allocate extra stations to maintain minimum power. 📈 Time complexity: O(n log(maxPower)), space: O(n) 🧠 Languages used: Java ✅ Problem solved as part of my daily grind to sharpen algorithmic thinking! 📌 Let me know if you'd approach it differently or spot any optimization! #LeetCode #Java #DailyCoding #BinarySearch #Optimization #TechPrep #ProblemSolving

New video on Spring AI from Catherine Edelveis. She explains why SSE can struggle with LLM token parcing and how NDJSON avoids broken spacing and merged words. The walkthrough covers a full reactive setup with Spring Boot, WebFlux, Ollama and a Vaadin client, focusing on error handling, backpressure and clean token delivery. Tested with Spring Boot 3.5.7, Java 25 and Ollama in Docker: https://hubs.li/Q03Tj_b-0