Implementing Max-Heap with PriorityQueue in Java

🚀 Day 146 / 180 of #180DaysOfCode ✅ Today’s Highlight: Revisited LeetCode 3234 — “Count the Number of Substrings With Dominant Ones.” 🧩 Problem Summary: Given a binary string s, the task is to count how many of its substrings have dominant ones. A substring is considered dominant if: number of 1s ≥ (number of 0s)² This creates an interesting balance check between zeros and ones, pushing you to think about substring ranges, prefix behavior, and efficient counting techniques. 💡 Core Takeaways: Great exercise in string analysis and prefix-based reasoning Highlights how mathematical conditions influence algorithm design Reinforces handling frequency relationships inside a sliding or expanding window Efficient counting becomes essential due to potential O(n²) substrings 💻 Tech Stack: Java ⏱ Runtime: 115 ms (Beats 84.11%) 💾 Memory: 47 MB 🧠 Learnings: Strengthened understanding of substring behavior under unique constraints Refined thinking around optimizing brute-force patterns A good reminder of how theoretical conditions (like squaring zeros) change practical implementation choices 📈 Progress: Today’s problem significantly improved my intuition around constraint-based substring evaluation—valuable for more advanced algorithmic challenges ahead. #LeetCode #Java #Algorithms #SubstringProblems #DSA #ProblemSolving #CodingJourney #SoftwareEngineering #180DaysOfCode #LogicBuilding #LearningEveryday

✨ Two Paths, One Goal: From Patterns to Problems (Day 48) ✨ Today, in collaboration with Chitrang Potdar, we begin a brand-new chapter in our DSA journey — Stacks. After exploring the flexibility of Linked Lists, we now move into a structure that defines order, control, and execution flow — the Stack. 💡 What is a Stack? A Stack is a linear data structure that follows the LIFO (Last In, First Out) principle. The element inserted last is the first one to be removed — just like a stack of plates or books. 🧩 Terminologies: Push → Insert an element onto the top of the stack. Pop → Remove the topmost element. Peek / Top → View the top element without removing it. isEmpty() → Check if the stack is empty. 🏗 Structure of a Stack: Top → [ 30 | 20 | 10 ] → Bottom (New elements are always added and removed from the top.) ⚙️ Importance of Stacks: Simplifies management of nested and sequential tasks. Provides controlled access — only one end is accessible. Backbone of recursion, parsing, and expression evaluation. 🌍 Real-Life Applications: 1️⃣ Undo/Redo operations in editors 2️⃣ Function call management (Recursion Stack) 3️⃣ Backtracking algorithms (Maze, Sudoku) 4️⃣ Expression evaluation and syntax parsing 5️⃣ Browser navigation (Forward/Backward) 🧠 Implementation in Java: We implemented Stacks using: Arrays → Fixed-size, index-based implementation. Linked Lists → Dynamic memory allocation, no fixed limit. 📌 Concepts Covered: Stack fundamentals and LIFO principle Core stack operations (push, pop, peek) Array-based and Linked List-based implementations Real-world significance and use cases 🚀 From tomorrow, we’ll begin working on Stack operations and applications — exploring how logic control and recursion work under the hood. 👉 Swipe for Java code examples. 👉 Don’t miss the Python edition by Chitrang Potdar. #Java #DSA #Stack #TwoPathsOneGoal #PatternToProblem #CodingJourney #LearningByDoing

Today was a really productive day — I got to learn and revise a lot of new things in DSA, Java, and System Design. Let me quickly share what I covered 👇 1️⃣ DSA — Stack & Monotonic Stack I started with revising Stack, how it works internally, and different real-world problems based on it. Then I learned the Monotonic Stack concept — how it helps in solving problems like Next Greater Element, Stock Span, and Largest Rectangle in Histogram. After that, I implemented a few problems to strengthen my logic and get more comfortable with the pattern. 2️⃣ Java — Collections & Generics Next, I continued with Java Collections Framework, understanding why it was introduced and how it simplifies data management. Then I explored Generics — how they help in writing reusable and type-safe code — and even learned about Bounded Generics, which was really interesting to see how type constraints work in real-time. 3️⃣ System Design — Getting the Big Picture In System Design, I focused on the basics — Functional and Non-Functional Requirements — and how both are essential for designing a reliable system. Also learned about key concepts like: Scalability (Horizontal vs Vertical Scaling) Availability and Reliability Maintainability These concepts helped me understand how large-scale systems are designed for real-world applications. #LearningJourney #Java #SystemDesign #DSA #BackendDevelopment #AI #Generics #Scalability #CodingJourney #SoftwareEngineering #Motivation

🚀 Day 38 of #100DaysOfCode – LeetCode Problem #747: Largest Number At Least Twice of Others 💡 Problem Summary: Given an integer array nums, find whether the largest number is at least twice as large as all other numbers. If it is, return the index of the largest element; otherwise, return -1. 📘 Example: Input: nums = [3,6,1,0] Output: 1 Input: nums = [1,2,3,4] Output: -1 🧠 Approach: Find the largest and second largest numbers in the array. If largest >= 2 * secondLargest, return the index of the largest. Otherwise, return -1. 💻 Java Solution: class Solution { public int dominantIndex(int[] nums) { int max = -1, second = -1, index = -1; for (int i = 0; i < nums.length; i++) { if (nums[i] > max) { second = max; max = nums[i]; index = i; } else if (nums[i] > second) { second = nums[i]; } } return second * 2 <= max ? index : -1; } } ⚙️ Complexity: Time: O(n) Space: O(1) ✅ Result: Accepted (Runtime: 0 ms) 🎯 Key Takeaway: Sometimes, solving problems isn’t about complex algorithms — it’s about thinking clearly and tracking key elements efficiently.

🚀 Day 60 of #100DaysOfCode 🚀 Today, I solved LeetCode Problem #137 – Single Number II 🧩 📘 Problem Statement: Given an integer array where every element appears three times except for one that appears exactly once, find that single element and return it. The challenge: solve it with O(n) time and O(1) space complexity. 💻 Language: Java ⚡ Runtime: 0 ms — Beats 100.00% 📉 Memory: 45.54 MB — Beats 56.30% 🧠 Concept Used: 🔹 Bit Manipulation — A powerful yet tricky technique that leverages binary operations to track occurrences of bits efficiently. 🔹 Instead of using extra space or hash maps, we track bits that appear once and twice using two integer variables: ✅ once → bits that appeared once ✅ twice → bits that appeared twice The trick lies in updating them using XOR (^) and NOT (~) to "cancel out" bits appearing three times. 🧩 Approach Summary: 1️⃣ Initialize two variables once = 0 and twice = 0. 2️⃣ For every number in the array: - Update once and twice based on how many times a bit has appeared. 3️⃣ After processing all numbers, once holds the value of the single element. ✅ Complexity: Time: O(n) Space: O(1) ✨ Takeaway: This problem teaches how bitwise logic can replace traditional data structures, achieving the same result with constant space — a crucial optimization in system-level programming and interviews. #100DaysOfCode #LeetCode #Java #BitManipulation #ProblemSolving #CleanCode #DataStructures #Algorithms #TechLearning #CodingChallenge #SoftwareEngineering #InterviewPreparation

In this session excerpt, Keyhole CTO Jaime Niswonger introduces Spring AI and walks through a hands-on code demo, showing how Java-based teams can build RAG-powered solutions—connecting LLMs with vector databases and delivering context-aware answers—without switching to Python. Highlights include how Spring AI: - Provides abstraction layers for any #LLM (Claude, GPT, Gemini, etc.) - Supports structured outputs like JSON/XML for seamless downstream use - Integrates with vector databases for RAG-powered applications - Simplifies enterprise-ready AI development through configuration #RAG code demo: See a Slack bot that delivers context-aware answers from PDFs and employee handbooks—without exposing private data externally. This #SpringAI approach enables Java teams to unlock the power of LLMs using familiar Spring patterns, maintain control over proprietary data, and accelerate AI adoption across their organization. https://lnkd.in/gEWaaEAz #Java #EnterpriseAI

💡 LeetCode 3370 – Smallest Number With All Set Bits Greater Than or Equal to n 💡 Today, I solved LeetCode Problem #3370, a concise yet insightful bit manipulation problem that sharpened my understanding of binary operations and number construction using bitwise logic in Java. ⚙️💻 🧩 Problem Overview: Given an integer n, the task is to find the smallest number that is greater than or equal to n and has all bits set to 1 in its binary form. 👉 Examples: Input → n = 5 (binary 101) → Output → 7 (binary 111) Input → n = 10 (binary 1010) → Output → 15 (binary 1111) 💡 Approach: 1️⃣ Initialize x = 1 (binary 1). 2️⃣ Continuously left-shift and OR with 1 → x = (x << 1) | 1, until x becomes ≥ n. 3️⃣ Return x as the final result — a number with all bits set to 1 that satisfies the condition. ⚙️ Complexity Analysis: ✅ Time Complexity: O(log n) — Each iteration handles one bit of n. ✅ Space Complexity: O(1) — Uses only constant extra space. ✨ Key Takeaways: Reinforced understanding of bitwise shift (<<) and bitwise OR (|) operators. Demonstrated how to efficiently generate numbers following binary patterns. Proved that elegant logic often lies in simplicity — especially in bit manipulation problems. 🌱 Reflection: This problem showcases how bit-level operations can simplify what might seem like mathematical complexity. Mastering these techniques is essential for building deeper intuition in algorithms and optimization. 🚀 #LeetCode #3370 #Java #BitManipulation #BinaryLogic #DSA #ProblemSolving #AlgorithmicThinking #CodingJourney #CleanCode #ConsistencyIsKey

💭 I finally stopped memorizing Data Structures… and started understanding how they power real-world applications. After days of reading, coding, debugging, and rewriting — I compiled everything into this Java Data Structures Handbook (2025 Edition) ☕ It’s not just definitions — it’s packed with diagrams, time complexities, comparisons, and real-world uses that helped me truly connect theory to practice. 📘 What’s inside (8 pages): 🔹 What are Data Structures & why they matter 🔹 Linear vs Non-linear (Array, LinkedList, Stack, Queue, Tree, Graph, HashMap) 🔹 Real-time use cases — from browsers to maps to schedulers 🔹 Time complexity charts (easy reference) 🔹 Key differences & interview quick notes 🧠 Who is this for: ➡️ Java learners building their fundamentals ➡️ Developers revising for interviews ➡️ Anyone who wants to truly understand data organization in code 🎯 Why I made this: Because when I started learning, I realized most tutorials only show syntax. This guide focuses on how these structures actually impact performance, design, and debugging. I’ve used these exact concepts in my mini-projects — like my Student Record Manager built using HashMap, HashSet, and ArrayList. 💡 Takeaway: You don’t need to memorize data structures — you need to experience them in action. Once you do, Java stops being syntax… and starts feeling like logic. 🚀 📎 Download the full PDF below 👇 Comment “DS” if you’d like me to DM you a copy directly. #Java #DataStructures #SoftwareEngineering #BuildInPublic #Programming #100DaysOfCode #DeveloperMindset #CodingJourney #LearningInPublic #SoftwareDevelopment #CleanCode #OOP #LearningByDoing #TechCommunity #FromMechanicalToSoftware #ProblemSolving #SelfTaughtDeveloper #EngineerMindset #KeepBuilding #JavaLearning

Use Streams for Cleaner Data Processing Are you tired of convoluted code that’s hard to read? Let's talk about how streams can make your Java code cleaner and more efficient! → Using loops can lead to messy code that's difficult to maintain. → Streams allow you to process data in a more functional style, which is easier to understand. → The example shows a simple transformation: filtering high-value orders. → This not only reduces the lines of code but also improves readability. → Cleaner code means fewer bugs and faster development times. What do you think about using streams in your projects? Have you tried them yet? Share your thoughts in the comments! #systemdesign #coding #interviewtips

With Streams, we can use functional operations such as: + filter : select based on condition + map : Transform each element + reduce: combine element into single result eg. finding max. + forEach: perform action on each element #JAVA #SpringBoot