Mastering Java with LeetCode: Increasing Triplet Subsequence

🚀 Java Full Stack Development Journey | Day 13 Today, I focused on understanding Inheritance and Polymorphism in Java — key concepts that help in writing reusable, scalable, and flexible code. 🔑 Key Concepts I Explored: 🔹 Inheritance Allows one class to acquire properties and behaviors of another class using extends, promoting code reusability. 🔹 Types of Inheritance Learned about Single, Multilevel, and Hierarchical inheritance in Java. 🔹 Method Overriding Redefining a parent class method in a child class to provide a specific implementation. 🔹 Polymorphism One interface, multiple forms — achieved through method overloading (compile-time) and method overriding (runtime). 💡 Simple Example: class Animal { void sound() { System.out.println("Animal makes sound"); } } class Dog extends Animal { void sound() { System.out.println("Dog barks"); } } public class Main { public static void main(String[] args) { Animal obj = new Dog(); // Polymorphism obj.sound(); } } 📌 Key Learning: Inheritance helps in reducing code duplication, while polymorphism increases flexibility and maintainability in applications. #Java #JavaDeveloper #FullStackDevelopment #JavaFullStack #Programming #CodingJourney #LearningJava #SoftwareDevelopment #OOP #DeveloperLife #TechLearning #Inheritance #ObjectOrientedProgramming #Polymorphism #Coding

Day 93/100 | Building Consistency 🦅 Showing up every day. Learning, growing, and improving. I stopped coding first… and started thinking in constraints. Most people do this: Write Java code → then check Time Complexity But today I flipped it: Analyze constraints → choose approach → then code in Java What I focused on: Before touching the keyboard, I asked: • Can this problem afford O(n²)? • Do I need O(n log n)? • Is O(n) the only scalable solution? then i realized: In Java, writing code is easy… but writing efficient code with the right approach is what actually matters. Because: • Nested loops = danger if constraints are high • Collections (HashMap, ArrayList) = powerful when used right • Choosing the wrong approach = TLE, no matter how clean your code is Pattern I’m building: Constraints → Approach → Data Structure → Clean Java Implementation Day 93 — not just coding in Java, but thinking like a problem solver before coding. 🚀 #Day93 #100DaysOfCode #DSA #Java #JavaDeveloper #CodingJourney #ProblemSolving #TimeComplexity #SoftwareEngineering #Tech #Developers #Programming #LearnToCode #CodeNewbie #CareerGrowth #TechCareers #CodingLife #DeveloperMindset

🚀 Mastering Java Through LeetCode 🧠 Day 22 of My DSA Journey Today I solved an interesting matrix-based problem that improved my understanding of arrays and comparison logic. 📌 LeetCode Problem Solved Today: 2352 – Equal Row and Column Pairs Problem Statement: Given an n x n matrix, find how many pairs (row, column) are exactly the same. A pair is valid only if both contain the same elements in the same order. 🧠 Key Idea: Compare each row with every column Check element-by-element equality Count all matching pairs 🔍 Example: Input: [[3,2,1], [1,7,6], [2,7,7]] Output: 1 Matching Pair: Row 2 = Column 1 → [2,7,7] ⚙️ Approach: Traverse all rows Build each column dynamically Compare row[i][k] with column[k][j] If all elements match → increment count ⏱️ Time Complexity: O(n³) (Optimized solution using HashMap possible in O(n²)) What I Learned: Matrix traversal techniques Row vs Column comparison logic Importance of nested loops in grid problems 🔥 Consistency is the key! Every day one problem closer to my goal of becoming a Software Engineer #LeetCode #DSA #Java #CodingJourney #100DaysOfCode #SoftwareEngineer #ProblemSolving #Learning #Tech

🚀 Mastering Java Through LeetCode 🧠 Day 17 of My DSA Journey Today I solved another problem from the LeetCode list to improve my understanding of arrays and prefix sum concepts. 📌 LeetCode Problem Solved Today: Q.1732. Find the Highest Altitude In this problem, a biker starts a road trip from altitude 0, and we are given an array that represents the gain or loss in altitude between points. The task is to find the highest altitude reached during the trip. Method 1: Using ArrayList (My 1st Approach) I stored all altitudes step by step in an ArrayList and then used Collections.max() to find the highest altitude. Method 2: Optimized Approach (My Second Approach Without Extra Space) Instead of storing all values, we can directly track the maximum altitude while iterating. 💻 Optimized Java Solution class Solution { public int largestAltitude(int[] gain) { int altitude = 0; int maxAltitude = 0; for (int g : gain) { altitude += g; maxAltitude = Math.max(maxAltitude, altitude); } return maxAltitude; } } Example: Input: gain = [-5,1,5,0,-7] Altitudes formed: [0, -5, -4, 1, 1, -6] Highest altitude = 1 Consistent practice is helping me strengthen my DSA and problem-solving skills step by step. #LeetCode #DSA #Java #CodingJourney #ProblemSolving #ArrayList #100DaysOfCode #SPPU #EngineeringLife #TechCommunity #CDAC

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

🚀 Mastering Java Through LeetCode 🧠 Day 10 of My DSA Journey Today I solved another problem from the LeetCode 75 list to strengthen my problem-solving skills and improve my understanding of arrays and two-pointer techniques. 📌 LeetCode Problem Solved Today: 283 – Move Zeroes from LeetCode 💡 Problem Statement: Given an integer array, move all 0s to the end while maintaining the relative order of the non-zero elements. The important condition is to solve it in-place without creating another array. 🧩 Example: Input: [0,1,0,3,12] Output: [1,3,12,0,0] ⚡ Key Learning: Today I learned how the Two Pointer Technique works efficiently: One pointer scans the array. The other pointer keeps track of where the next non-zero element should be placed. Swap elements when needed. Time Complexity: O(n) Space Complexity: O(1) This problem helped me better understand array manipulation and in-place algorithms, which are very important for coding interviews. Consistency is the key — solving problems daily to become a better software engineer. 💻🔥 #LeetCode #Java #DSA #ProblemSolving #CodingJourney #LearningInPublic #SoftwareDevelopment #Programming #Coding #Tech #Developers #100DaysOfCode #TechCareer #InterviewPreparation #ArrayProblems #CodingPractice

🚀 Day 2 of My Java Full Stack Journey Today I focused on understanding how programs make decisions using conditional statements. 📌 What I learned: 🔹 If-Else Statements Used to control the flow of execution based on conditions 🔹 Types I Practiced: • if • if-else • else-if ladder 🔹 Comparison Operators Used: • == (equal to) • != (not equal to) • > (greater than) • < (less than) • >= (greater than or equal to) • <= (less than or equal to) 🔹 Input / Output Functions • printf() → used to display output • scanf() → used to take input 🔹 Comments • // single-line comment • /* multi-line comment */ 🔹 What I Practiced: Taking user input and applying conditions Understanding how program flow changes step-by-step. Applying concepts in real programs and improving my logic step by step 🚀 #Learninginpublic #javafullstackdevloper #CProgramming #ProblemSolving #Consistency

🚀 Mastering Java Through LeetCode 🧠 Day 15 of My DSA Journey Today I solved another problem from the LeetCode 75 list to strengthen my understanding of Sliding Window and Two Pointer techniques, which are widely used in coding interviews and real-world problem solving. LeetCode Problem Solved Today: Q. 1004 – Max Consecutive Ones III Problem Statement: Given a binary array nums and an integer k, return the maximum number of consecutive 1's in the array if you can flip at most k zeros. Example: Input: nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2 Output: 6 Explanation: By flipping at most 2 zeros, we can form the longest subarray of consecutive 1s. Approach Used: I implemented the Sliding Window Technique: • Expand the window using the right pointer • Track the number of zeros in the window • Shrink the window when zeros exceed k • Continuously update the maximum valid window size Time Complexity: O(n) Space Complexity: O(1) What I’m focusing on right now: Improving problem-solving skills, strengthening DSA fundamentals, and preparing for software engineering opportunities. Small improvements every day lead to big results over time. #LeetCode #Java #DSA #ProblemSolving #CodingJourney #LearningInPublic #SoftwareDevelopment #Programming #Developers #100DaysOfCode #TechCareer #InterviewPreparation #SlidingWindow #CodingPractice

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 3 of My Coding Challenge Improving my problem-solving skills step by step! Today I solved a number-based problem on reversing an integer. 🔹 Platforms: LeetCode & GeeksforGeeks 🔹 Problem: LeetCode #7 – Reverse Integer 🔹 Problem Statement: Given a signed 32-bit integer, reverse its digits. If the reversed integer overflows, return 0. 🔹 Approach: 1️⃣ Extract last digit using modulo (%) 2️⃣ Build reversed number step by step 3️⃣ Check for overflow before updating result 🔹 Example: Input: 123 → Output: 321 Input: -123 → Output: -321 Input: 120 → Output: 21 🔹 What I learned: ✔ Handling integer overflow conditions ✔ Working with digits using modulo & division ✔ Writing safe and optimized code 💻 Code: import java.util.*; public class ReverseIntegerLeetCode7 { ``` public static int reverse(int x) {   int rev = 0;   while (x != 0) {     int rem = x % 10;     x = x / 10;     // Check overflow     if (rev > Integer.MAX_VALUE / 10 ||        (rev == Integer.MAX_VALUE / 10 && rem > 7)) {       return 0;     }     if (rev < Integer.MIN_VALUE / 10 ||        (rev == Integer.MIN_VALUE / 10 && rem < -8)) {       return 0;     }     rev = (rev * 10) + rem;   }   return rev; } public static void main(String[] args) {   int x = 123;   System.out.println(reverse(x));   x = -123;   System.out.println(reverse(x));   x = 120;   System.out.println(reverse(x)); } ``` } 🔗 GitHub: https://lnkd.in/g-wNSrPq #Java #DSA #LeetCode #CodingChallenge #50DaysChallenge #Consistency #GrowthMindset #LearningJourney