Java DSA Practice: Product of Array Except Self

🚀 Mastering Java Through LeetCode 🧠 Day 2 I’m continuing my journey of solving problems from the LeetCode 75 list to strengthen my Data Structures and Algorithms (DSA) skills using Java. Consistency in problem-solving is helping me improve logical thinking and prepare for real-world software engineering interviews. 📌 LeetCode problem solved today: Q. 1071 – Greatest Common Divisor of Strings 📝 Problem Summary: For two strings s and t, we say t divides s if s is formed by repeating t multiple times. 👉 The goal is to find the largest string x that divides both str1 and str2. 💡 Key Insight: ✔️ If (str1 + str2).equals(str2 + str1) → a common pattern exists ✔️ Then the answer is based on GCD of lengths 💻 Key Java concepts practiced: ✔️ String concatenation & comparison ✔️ Pattern recognition in strings ✔️ Recursion (GCD using Euclidean algorithm) ✔️ Substring operations ✔️ Combining math with programming logic Takeaway: This problem shows how combining Mathematical concepts (GCD) with String manipulation can lead to efficient solutions. #Java #DSA #LeetCode #ProblemSolving #CodingJourney #JavaDeveloper #TechSkills #LearningInPublic #CodingPractice #SoftwareEngineering #Developers #CodingLife

🚀 Week 8 – Java + DSA Journey Update This week was all about strengthening my problem-solving skills and diving deeper into Data Structures using Java. 💻 🔹 What I focused on: Arrays & Advanced Array Problems Two Pointer Technique Sliding Window Concepts Solved multiple problems on LeetCode 🔹 Key Learnings: Learned how to optimize brute force solutions into efficient ones (O(n)) Understood real use of two pointers in problems like pair sum & sorting-based questions Sliding window made problems like longest substring much more efficient 🔹 Challenges faced: Some problems looked easy but required deep thinking to optimize. Debugging logic took time, but consistency helped 💪 🔹 Progress: Improved coding speed ⏱️ Better understanding of patterns instead of just memorizing solutions 📌 Goal for next week: Start Linked List Practice medium-level problems consistently Consistency is the only key 🔑 #Java #DSA #LeetCode #CodingJourney #SoftwareEngineering #LearningInPublic

Day 14 of my coding journey — Extracting Unique Words using Java Streams Today I explored a clean and efficient way to extract unique words from a string using Java Streams. Instead of writing multiple loops and conditional checks, I leveraged the power of functional programming: Grouped words using a frequency map Filtered out words that appear more than once Collected only truly unique words in a concise pipeline What I really liked about this approach is how readable and expressive the code becomes. It clearly shows what we want to achieve rather than how step-by-step. Key takeaway: Writing optimized code is not just about performance — it’s also about clarity, maintainability, and using the right abstractions. Every day I’m getting more comfortable thinking in terms of streams, transformations, and data flow. If you have alternative approaches or optimizations, I’d love to hear them. #Day14 #Java #CodingJourney #JavaStreams #BackendDevelopment #ProblemSolving #CleanCode

🚀 DAY 69/150 — FINDING PATTERNS THROUGH SORTING! 🚀 Day 69 of my 150 Days DSA Challenge in Java and today I solved a problem that highlights the power of sorting and pattern observation 💻🧠 📌 Problem Solved: Minimum Absolute Difference 📌 LeetCode: #1200 📌 Difficulty: Easy–Medium The task is to find all pairs of elements with the minimum absolute difference in a given array. 🔹 Approach Used Instead of comparing every pair (which would take O(n²)), I used a more optimized approach: • First, sort the array • Then check only adjacent elements • Keep track of the minimum difference • Store all pairs that match this minimum difference Sorting helps reduce unnecessary comparisons and simplifies the logic. ⏱ Complexity Time Complexity: O(n log n) (due to sorting) Space Complexity: O(n) (for storing result pairs) 🧠 What I Learned • Sorting can significantly reduce the complexity of comparison-based problems • Adjacent elements in a sorted array often reveal important patterns • Avoid brute-force when a structured approach exists 💡 Key Takeaway This problem taught me that sometimes the simplest optimization is just reordering the data first. Once sorted, many complex problems become easier to solve. It also strengthened my understanding of how pattern recognition + sorting can lead to efficient solutions. ✅ Day 69 completed 🚀 81 days to go 🔗 Java Solution on GitHub: 👉 https://lnkd.in/gYHCJmkv 💡 Sorting is not just a technique — it’s a problem-solving strategy. #DSAChallenge #Java #LeetCode #Sorting #Greedy #150DaysOfCode #ProblemSolving #CodingJourney #InterviewPrep #LearningInPublic

“Where does data actually live in Java… Stack or Heap?” Not how to write the code. But what really happens in memory when the code runs. When a Java program runs, memory is mainly divided into two places. Stack and Heap. Here’s the simple way to think about it. The Stack stores method calls and local variables. Every time a method runs, a new stack frame is created. When the method finishes, that frame disappears. It’s fast, structured, and managed automatically. The Heap, on the other hand, is where objects actually live. Whenever you create something with new, the object goes into the heap. The stack only keeps the reference pointing to that object. So something like this: Person p = new Person(); What really happens is: ↳ p (reference) lives in the stack ↳ Person object lives in the heap This small distinction explains a lot of things developers struggle with: • why objects persist beyond a method call • how memory leaks happen • how garbage collection works • why references behave the way they do Sometimes the hardest part of software engineering isn’t writing code. It’s understanding what the runtime is doing behind the scenes. How do you usually explain Stack vs Heap to someone learning Java? #Java #SoftwareEngineering #Programming #JavaDeveloper #Coding

Day 83 - LeetCode Journey Solved LeetCode 237: Delete Node in a Linked List in Java ✅ This problem was a bit different from usual linked list questions. Instead of deleting a node in the traditional way, we weren’t given access to the head of the list. That’s what made it interesting. The trick was to think differently. Instead of removing the node directly, copy the value of the next node into the current node and skip the next node. Simple idea, but not obvious at first. This problem really tests your understanding of how linked lists work internally. Key takeaways: • Thinking beyond standard approaches • Understanding pointer manipulation deeply • Writing minimal and efficient code • Strengthening core linked list concepts ✅ All test cases passed ✅ Clean and optimal solution Problems like these remind me that DSA is not just about coding, but about thinking differently 💡 #LeetCode #DSA #Java #LinkedList #ProblemSolving #Algorithms #CodingJourney #InterviewPreparation #Consistency

From implementing basic arrays to building my own Generic ArrayList from scratch in Java 🚀 Recently, in an interview, I was asked to implement an ArrayList with major operations. Instead of stopping there, I took it as a challenge and went deeper. Here’s what I built: ✔ Dynamic resizing (handled capacity growth) ✔ Generic support using <T> ✔ add(element) and add(index, element) ✔ remove(index) with shifting ✔ get(index) with boundary checks ✔ size() and capacity() methods ✔ Custom toString() for clean output Along the way, I also understood an important concept: 👉 Why Java doesn’t allow new T[] (due to type erasure) 👉 How real ArrayList internally uses Object[] This wasn’t just about coding — it was about understanding how data structures actually work internally. Small improvements daily → big progress over time. #Java #DataStructures #DSA #CodingInterview #Learning #Consistency

🚀 #Headline: Day 10 — How Arrays Work in Java (Deep Dive into Memory) After learning array syntax in Part 1, today's lecture went beneath the surface. This wasn't about writing more code – it was about understanding what actually happens inside the JVM when you write new int[5]. This is the kind of knowledge that separates surface-level coders from developers who truly understand their tools. Covered in this lecture: ✔️ Why arrays are stored in contiguous memory ✔️ How arrays are allocated in Heap memory (not Stack!) ✔️ Stack vs Heap – what goes where ✔️ What happens inside the JVM during array creation ✔️ How memory indexing actually works (base address + offset) ✔️ Why array access is O(1) – constant time random access ✔️ Performance implications of contiguous storage ✔️ Special case of boolean arrays ✔️ How 2D arrays are stored in memory ✔️ Array of Strings – reference behavior The "aha" moment came when the instructor explained the math behind indexing: address = base + (index × size). This is why arrays are so fast – no traversal needed, just a direct calculation. Understanding that array references live on the Stack while the actual data lives on the Heap clarifies so many concepts about memory management. This lecture truly delivered on its promise: "This is not just coding. This is internal understanding." Learning from: 👨🏫 Aditya Tandon (Instructor) 🚀 Rohit Negi (CoderArmy) 📺 Source: https://lnkd.in/gpFpcpDs Let's connect 🤝 Pankaj Kumar #Java #100DaysOfCode #ProgrammingJourney #JavaBasics #BuildInPublic

Day 22/30 Understanding the Power of Polymorphism in Java 💡 Polymorphism is one of the core pillars of Object-Oriented Programming, enabling developers to write flexible, reusable, and maintainable code. This visual highlights some key advantages of polymorphism: 🔹 Increased Flexibility – A parent class reference can point to different subclass objects, allowing dynamic behavior at runtime. 🔹 Code Reusability – Through method overriding and method overloading, developers can reuse logic while adapting behavior. 🔹 Consistent Interface – Different classes can implement the same method structure, making systems easier to understand and use. 🔹 Reduced Complexity – Using the same method name with different parameters simplifies code readability. 🔹 Easier Debugging – Fewer method names and clear logical flow make debugging more efficient. 🔹 Support for Design Patterns – Many patterns like Strategy and Factory rely on polymorphism for flexible design. 🔹 Better Maintainability – Changes in child classes do not affect the overall system structure, helping build scalable applications. Mastering concepts like polymorphism is essential for building robust, scalable, and production-ready software systems. Always remember: 👉 Write code that is not just functional, but also flexible and maintainable. #Java #OOP #Polymorphism #SoftwareDevelopment #Programming #JavaDeveloper #Coding #TechLearning #ObjectOrientedProgramming #SoftwareEngineering #DeveloperCommunity #CodeNewbie #LearnToCode #TechCareers #ProgrammingConcepts

Most people try to solve 3Sum using 3 nested loops. That solution works... but it's O(n³) and too slow. Today I learned how to reduce it to O(n²). 🚀 Day 81/365 — DSA Challenge Solved: 3Sum 🧠 The Idea Steps: 1. Sort the array 2. Fix one number 3. Use two pointers to find the other two numbers 4. Skip duplicates to avoid repeating triplets ⏱ Complexity Approach & Time 3 loops -> O(n³) Sort + Two pointers -> O(n²) Big improvement. 💡 What I learned today Whenever you see: • Sorted array • Pair sum • Triplet sum • Target sum Think: Sort + Two Pointers Day 81/365 complete. Still learning. Still coding. Code: https://lnkd.in/dad5sZfu #DSA #Java #LeetCode #LearningInPublic #100DaysOfCode #365Days365DSAProblems